tessl/npm-redis

A modern, high performance Redis client for Node.js with full TypeScript support and all Redis Stack modules

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Redis

Name: tessl/npm-redis
Author: tessl

Redis is a modern, high-performance Redis client for Node.js applications, built with TypeScript and designed for optimal performance and developer experience. It serves as a comprehensive Redis client library that includes all Redis Stack modules by bundling the core Redis client with specialized extensions for Bloom filters, JSON operations, search capabilities, and time-series data handling.

Package Information

Package Name: redis
Package Type: npm
Language: TypeScript
Installation: npm install redis

Core Imports

import { createClient, createCluster, createSentinel } from "redis";

For CommonJS:

const { createClient, createCluster, createSentinel } = require("redis");

Basic Usage

import { createClient } from "redis";

// Create and connect client
const client = createClient({
  url: "redis://localhost:6379"
});

await client.connect();

// Basic operations
await client.set("key", "value");
const value = await client.get("key");

// Disconnect
await client.disconnect();

Architecture

Redis client is built around several key components:

Core Client: The main RedisClientType providing connection management and all Redis commands
Connection Types: Support for single Redis instances, clusters, and sentinel configurations
Module System: Extensible architecture with built-in Redis Stack modules (JSON, Search, Time Series, Bloom)
Type Safety: Full TypeScript support with strongly typed command parameters and return values
RESP Protocol: Support for both RESP2 and RESP3 protocols with automatic type mapping
Connection Pooling: Built-in connection pooling for high-performance applications
Client-Side Caching: Optional client-side caching with configurable strategies

Capabilities

Client Creation and Connection Management

Core functionality for creating Redis clients and managing connections, including support for clusters and sentinel configurations.

function createClient<
  M extends RedisModules = {},
  F extends RedisFunctions = {},
  S extends RedisScripts = {},
  RESP extends RespVersions = 2,
  TYPE_MAPPING extends TypeMapping = {}
>(
  options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>
): RedisClientType<RedisDefaultModules & M, F, S, RESP, TYPE_MAPPING>;

function createCluster<
  M extends RedisModules = {},
  F extends RedisFunctions = {},
  S extends RedisScripts = {},
  RESP extends RespVersions = 2,
  TYPE_MAPPING extends TypeMapping = {}
>(
  options: RedisClusterOptions<M, F, S, RESP, TYPE_MAPPING>
): RedisClusterType<RedisDefaultModules & M, F, S, RESP, TYPE_MAPPING>;

function createSentinel<
  M extends RedisModules = {},
  F extends RedisFunctions = {},
  S extends RedisScripts = {},
  RESP extends RespVersions = 2,
  TYPE_MAPPING extends TypeMapping = {}
>(
  options: RedisSentinelOptions<M, F, S, RESP, TYPE_MAPPING>
): RedisSentinelType<RedisDefaultModules & M, F, S, RESP, TYPE_MAPPING>;

Client Management

Redis Commands

Complete implementation of all Redis commands with type-safe parameters and return values. Includes string, hash, list, set, sorted set, stream, pub/sub, transaction, and server commands.

// String commands
get(key: RedisArgument): Promise<BlobStringReply | null>;
set(key: RedisArgument, value: RedisArgument, options?: SetOptions): Promise<SimpleStringReply<'OK'> | null>;
incr(key: RedisArgument): Promise<NumberReply>;

// Hash commands  
hGet(key: RedisArgument, field: RedisArgument): Promise<BlobStringReply | null>;
hSet(key: RedisArgument, field: RedisArgument, value: RedisArgument): Promise<NumberReply>;
hGetAll(key: RedisArgument): Promise<Record<string, BlobStringReply>>;

// List commands
lPush(key: RedisArgument, ...elements: RedisArgument[]): Promise<NumberReply>;
rPop(key: RedisArgument): Promise<BlobStringReply | null>;
lRange(key: RedisArgument, start: number, stop: number): Promise<ArrayReply<BlobStringReply>>;

Redis Commands

JSON Operations

JSON path-based operations for storing, retrieving, and manipulating JSON documents in Redis using RedisJSON.

namespace json {
  function get(key: RedisArgument, options?: JsonGetOptions): Promise<RedisJSON | null>;
  function set(key: RedisArgument, path: string, value: RedisJSON, options?: JsonSetOptions): Promise<SimpleStringReply<'OK'> | null>;
  function del(key: RedisArgument, path?: string): Promise<NumberReply>;
  function type(key: RedisArgument, path?: string): Promise<BlobStringReply | null>;
}

JSON Operations

Search and Indexing

Full-text search, indexing, and aggregation capabilities using RediSearch for complex query operations.

namespace ft {
  function create(index: string, schema: RediSearchSchema, options?: FtCreateOptions): Promise<SimpleStringReply<'OK'>>;
  function search(index: string, query: string, options?: FtSearchOptions): Promise<SearchReply>;
  function aggregate(index: string, query: string, options?: FtAggregateOptions): Promise<ArrayReply>;
  function dropIndex(index: string, options?: FtDropIndexOptions): Promise<SimpleStringReply<'OK'>>;
}

Search and Indexing

Time Series Data

Time series data operations for storing and querying time-stamped data with aggregation rules and downsampling.

namespace ts {
  function create(key: RedisArgument, options?: TsCreateOptions): Promise<SimpleStringReply<'OK'>>;
  function add(key: RedisArgument, timestamp: number, value: number, options?: TsAddOptions): Promise<NumberReply>;
  function get(key: RedisArgument): Promise<ArrayReply | null>;
  function range(key: RedisArgument, fromTimestamp: number, toTimestamp: number, options?: TsRangeOptions): Promise<ArrayReply>;
}

Time Series

Bloom Filters and Probabilistic Data Structures

Probabilistic data structures including Bloom filters, Count-Min Sketch, Cuckoo filters, T-Digest, and Top-K.

namespace bf {
  function add(key: RedisArgument, item: RedisArgument): Promise<BooleanReply>;
  function exists(key: RedisArgument, item: RedisArgument): Promise<BooleanReply>;
  function reserve(key: RedisArgument, errorRate: number, capacity: number, options?: BfReserveOptions): Promise<SimpleStringReply<'OK'>>;
}

Bloom Filters

Core Types

// Client types
type RedisClientType<M = RedisDefaultModules, F = {}, S = {}, RESP = 2, TYPE_MAPPING = {}> = {
  connect(): Promise<RedisClientType<M, F, S, RESP, TYPE_MAPPING>>;
  disconnect(): Promise<void>;
  quit(): Promise<string>;
  isOpen: boolean;
  isReady: boolean;
} & RedisCommands & M;

type RedisClusterType<M = RedisDefaultModules, F = {}, S = {}, RESP = 2, TYPE_MAPPING = {}> = RedisClientType<M, F, S, RESP, TYPE_MAPPING>;

type RedisSentinelType<M = RedisDefaultModules, F = {}, S = {}, RESP = 2, TYPE_MAPPING = {}> = RedisClientType<M, F, S, RESP, TYPE_MAPPING>;

// Configuration types
interface RedisClientOptions<M = RedisModules, F = RedisFunctions, S = RedisScripts, RESP = RespVersions, TYPE_MAPPING = TypeMapping> {
  url?: string;
  socket?: RedisSocketOptions;
  username?: string;
  password?: string;
  name?: string;
  database?: number;
  modules?: M;
  functions?: F;
  scripts?: S;
  readonly?: boolean;
  legacyMode?: boolean;
  isolationPoolOptions?: RedisPoolOptions;
}

interface RedisClusterOptions<M = RedisModules, F = RedisFunctions, S = RedisScripts, RESP = RespVersions, TYPE_MAPPING = TypeMapping> {
  rootNodes: Array<RedisClusterNode>;
  defaults?: Partial<RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>>;
  minimizeConnections?: boolean;
  useReplicas?: boolean;
  maxCommandRedirections?: number;
  modules?: M;
  functions?: F;
  scripts?: S;
}

// Basic argument and reply types
type RedisArgument = string | Buffer;
type RedisJSON = string | number | boolean | null | RedisJSON[] | { [key: string]: RedisJSON };

// Reply types
type BooleanReply<T = boolean> = T;
type NumberReply<T = number> = T;
type BlobStringReply<T = Buffer> = T;
type SimpleStringReply<T = string> = T;
type ArrayReply<T> = T[];
type NullReply = null;

// Default modules type
type RedisDefaultModules = {
  bf: typeof import('@redis/bloom').bf;
  cf: typeof import('@redis/bloom').cf;
  cms: typeof import('@redis/bloom').cms;
  topK: typeof import('@redis/bloom').topK;
  tDigest: typeof import('@redis/bloom').tDigest;
  json: typeof import('@redis/json');
  ft: typeof import('@redis/search');
  ts: typeof import('@redis/time-series');
};