@db-bridge/redis 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,330 @@
+import { EventEmitter } from 'eventemitter3';
+import Redis, { RedisOptions } from 'ioredis';
+import { CacheAdapter, Logger, CacheOptions, QueryResult, DatabaseAdapter } from '@db-bridge/core';
+export { CacheAdapter, ConnectionConfig, DatabaseAdapter } from '@db-bridge/core';
+
+declare class RedisCommands {
+    private adapter;
+    constructor(adapter: RedisAdapter);
+    private get client();
+    hget(key: string, field: string): Promise<string | null>;
+    hset(key: string, field: string, value: string): Promise<number>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    hmset(key: string, data: Record<string, string>): Promise<string>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    lpush(key: string, ...values: string[]): Promise<number>;
+    rpush(key: string, ...values: string[]): Promise<number>;
+    lpop(key: string): Promise<string | null>;
+    rpop(key: string): Promise<string | null>;
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    llen(key: string): Promise<number>;
+    sadd(key: string, ...members: string[]): Promise<number>;
+    srem(key: string, ...members: string[]): Promise<number>;
+    smembers(key: string): Promise<string[]>;
+    sismember(key: string, member: string): Promise<number>;
+    scard(key: string): Promise<number>;
+    zadd(key: string, ...args: (string | number)[]): Promise<number>;
+    zrem(key: string, ...members: string[]): Promise<number>;
+    zrange(key: string, start: number, stop: number, withScores?: boolean): Promise<string[]>;
+    zrevrange(key: string, start: number, stop: number, withScores?: boolean): Promise<string[]>;
+    zcard(key: string): Promise<number>;
+    publish(channel: string, message: string): Promise<number>;
+    subscribe(channels: string[], callback: (channel: string, message: string) => void): Promise<void>;
+    unsubscribe(channels?: string[]): Promise<void>;
+}
+
+interface RedisAdapterOptions$1 {
+    redis?: RedisOptions;
+    keyPrefix?: string;
+    ttl?: number;
+    logger?: Logger;
+    enableCompression?: boolean;
+    connectionTimeout?: number;
+    commandTimeout?: number;
+    retryOptions?: {
+        maxRetries?: number;
+        retryDelay?: number;
+    };
+}
+declare class RedisAdapter extends EventEmitter implements CacheAdapter {
+    private client?;
+    private isConnected;
+    private _commands?;
+    private readonly options;
+    constructor(options?: RedisAdapterOptions$1);
+    connect(config?: RedisOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    exists(key: string): Promise<boolean>;
+    clear(): Promise<void>;
+    mget<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    mset<T = unknown>(items: Array<{
+        key: string;
+        value: T;
+        ttl?: number;
+    }>): Promise<void>;
+    keys(pattern?: string): Promise<string[]>;
+    ttl(key: string): Promise<number>;
+    expire(key: string, ttl: number): Promise<boolean>;
+    increment(key: string, value?: number): Promise<number>;
+    del(key: string): Promise<boolean>;
+    decrement(key: string, value?: number): Promise<number>;
+    ping(): Promise<string>;
+    flushdb(): Promise<void>;
+    mdel(keys: string[]): Promise<number>;
+    persist(key: string): Promise<boolean>;
+    setNX(key: string, value: unknown, ttl?: number): Promise<boolean>;
+    hset(key: string, field: string, value: string): Promise<number>;
+    hget(key: string, field: string): Promise<string | null>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    hexists(key: string, field: string): Promise<boolean>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    lpush(key: string, ...values: string[]): Promise<number>;
+    rpush(key: string, ...values: string[]): Promise<number>;
+    lpop(key: string): Promise<string | null>;
+    rpop(key: string): Promise<string | null>;
+    llen(key: string): Promise<number>;
+    lrange(key: string, start: number, stop: number): Promise<string[]>;
+    sadd(key: string, ...members: string[]): Promise<number>;
+    srem(key: string, ...members: string[]): Promise<number>;
+    smembers(key: string): Promise<string[]>;
+    sismember(key: string, member: string): Promise<boolean>;
+    scard(key: string): Promise<number>;
+    zadd(key: string, score: number, member: string): Promise<number>;
+    zrem(key: string, ...members: string[]): Promise<number>;
+    zrange(key: string, start: number, stop: number): Promise<string[]>;
+    zrangeWithScores(key: string, start: number, stop: number): Promise<[string, number][]>;
+    zscore(key: string, member: string): Promise<number | null>;
+    zcard(key: string): Promise<number>;
+    scan(pattern: string): AsyncGenerator<string>;
+    private ensureConnected;
+    get commands(): RedisCommands;
+    getClient(): Redis | undefined;
+    getFullKey(key: string): string;
+    private serialize;
+    private deserialize;
+    private compress;
+    private decompress;
+    private isCompressed;
+    private scanKeys;
+}
+
+interface RedisCacheAdapterOptions {
+    redis: RedisAdapter;
+    defaultTTL?: number;
+    keyPrefix?: string;
+    invalidationPatterns?: Map<string, string[]>;
+}
+declare class RedisCacheAdapter {
+    private redis;
+    private defaultTTL;
+    private keyPrefix;
+    private invalidationPatterns;
+    constructor(options: RedisCacheAdapterOptions);
+    getCachedQuery<T = unknown>(key: string, options?: CacheOptions): Promise<QueryResult<T> | null>;
+    setCachedQuery<T = unknown>(key: string, result: QueryResult<T>, options?: CacheOptions): Promise<void>;
+    invalidateQueries(patterns: string[]): Promise<number>;
+    invalidateAll(): Promise<void>;
+    getStatistics(): Promise<{
+        totalKeys: number;
+        totalSize: number;
+        patterns: string[];
+    }>;
+    private getQueryKey;
+    private registerInvalidation;
+}
+declare function createDatabaseAdapterWithCache(adapter: DatabaseAdapter, cacheAdapter: CacheAdapter, options?: {
+    defaultTTL?: number;
+    cacheableCommands?: string[];
+}): DatabaseAdapter;
+
+interface ConnectionConfig {
+    redis?: RedisOptions;
+    keyPrefix?: string;
+    connectionTimeout?: number;
+    retryOptions?: {
+        maxRetries?: number;
+        retryDelay?: number;
+    };
+}
+declare class RedisConnectionManager extends EventEmitter {
+    protected client?: Redis;
+    protected isConnected: boolean;
+    protected config: ConnectionConfig;
+    constructor(config?: ConnectionConfig);
+    connect(overrideConfig?: RedisOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    getClient(): Redis | undefined;
+    ensureConnected(): void;
+    getFullKey(key: string): string;
+    private setupEventHandlers;
+}
+
+declare class BasicOperationsTrait extends RedisConnectionManager {
+    protected commandTimeout: number;
+    setCommandTimeout(timeout: number): void;
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    del(key: string): Promise<boolean>;
+    exists(key: string): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    expire(key: string, ttl: number): Promise<boolean>;
+    protected serialize<T>(value: T): string;
+    protected deserialize<T>(value: string): T;
+}
+
+declare class BatchOperationsTrait extends BasicOperationsTrait {
+    mget<T = unknown>(keys: string[]): Promise<(T | null)[]>;
+    mset<T = unknown>(items: Array<{
+        key: string;
+        value: T;
+        ttl?: number;
+    }>): Promise<void>;
+    clear(): Promise<void>;
+    keys(pattern?: string): Promise<string[]>;
+    private scanKeys;
+}
+
+declare class CounterOperationsTrait extends BatchOperationsTrait {
+    increment(key: string, value?: number): Promise<number>;
+    decrement(key: string, value?: number): Promise<number>;
+    incr(key: string): Promise<number>;
+    decr(key: string): Promise<number>;
+    incrby(key: string, value: number): Promise<number>;
+    decrby(key: string, value: number): Promise<number>;
+    incrbyfloat(key: string, value: number): Promise<string>;
+}
+
+interface RedisAdapterOptions {
+    redis?: RedisOptions;
+    keyPrefix?: string;
+    ttl?: number;
+    logger?: Logger;
+    enableCompression?: boolean;
+    connectionTimeout?: number;
+    commandTimeout?: number;
+    retryOptions?: {
+        maxRetries?: number;
+        retryDelay?: number;
+    };
+}
+declare class ModularRedisAdapter extends CounterOperationsTrait implements CacheAdapter {
+    private _commands?;
+    private defaultTtl;
+    private logger?;
+    private enableCompression;
+    constructor(options?: RedisAdapterOptions);
+    connect(config?: RedisOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    set<T = unknown>(key: string, value: T, ttl?: number): Promise<void>;
+    get commands(): RedisCommands;
+    protected serialize<T>(value: T): string;
+    protected deserialize<T>(value: string): T;
+    private compress;
+    private decompress;
+    private isCompressed;
+    private setupLogging;
+}
+
+interface StreamEntry {
+    id: string;
+    fields: Record<string, string>;
+}
+interface StreamInfo {
+    length: number;
+    radixTreeKeys: number;
+    radixTreeNodes: number;
+    groups: number;
+    lastGeneratedId: string;
+    firstEntry?: StreamEntry;
+    lastEntry?: StreamEntry;
+}
+declare class StreamBaseTrait extends EventEmitter {
+    protected client: Redis;
+    constructor(client: Redis);
+    protected parseEntries(raw: any[]): StreamEntry[];
+    protected parseFields(raw: string[]): Record<string, string>;
+    protected parseStreamResults(raw: any[]): Array<[string, StreamEntry[]]>;
+    protected camelCase(str: string): string;
+    protected throwError(message: string, key?: string, error?: Error): never;
+}
+
+declare class StreamCrudTrait extends StreamBaseTrait {
+    xadd(key: string, _id: string | "*" | undefined, fields: Record<string, string | number | boolean>, options?: {
+        maxlen?: number;
+        approximate?: boolean;
+    }): Promise<string>;
+    xdel(key: string, ...ids: string[]): Promise<number>;
+    xtrim(key: string, maxlen: number, approximate?: boolean): Promise<number>;
+    xlen(key: string): Promise<number>;
+}
+
+declare class StreamReadTrait extends StreamCrudTrait {
+    xread(streams: Record<string, string>, options?: {
+        count?: number;
+        block?: number;
+    }): Promise<Array<[string, StreamEntry[]]>>;
+    xrange(key: string, start?: string, end?: string, count?: number): Promise<StreamEntry[]>;
+    xrevrange(key: string, end?: string, start?: string, count?: number): Promise<StreamEntry[]>;
+}
+
+interface ConsumerGroupInfo {
+    name: string;
+    consumers: number;
+    pending: number;
+    lastDeliveredId: string;
+}
+declare class StreamConsumerTrait extends StreamReadTrait {
+    xgroupCreate(key: string, groupName: string, id?: string, mkstream?: boolean): Promise<void>;
+    xgroupDestroy(key: string, groupName: string): Promise<boolean>;
+    xgroupSetId(key: string, groupName: string, id: string): Promise<void>;
+    xreadgroup(groupName: string, consumerName: string, streams: Record<string, string>, options?: {
+        count?: number;
+        block?: number;
+        noack?: boolean;
+    }): Promise<Array<[string, StreamEntry[]]>>;
+    xack(key: string, groupName: string, ...ids: string[]): Promise<number>;
+    xpending(key: string, groupName: string, options?: {
+        start?: string;
+        end?: string;
+        count?: number;
+        consumer?: string;
+    }): Promise<any>;
+    xclaim(key: string, groupName: string, consumerName: string, minIdleTime: number, ids: string[], options?: {
+        idle?: number;
+        time?: number;
+        retrycount?: number;
+        force?: boolean;
+        justid?: boolean;
+    }): Promise<StreamEntry[] | string[]>;
+}
+
+declare class StreamInfoTrait extends StreamConsumerTrait {
+    xinfo(subcommand: 'STREAM' | 'GROUPS' | 'CONSUMERS', key: string, groupName?: string): Promise<StreamInfo | ConsumerGroupInfo[] | any[]>;
+    private parseStreamInfo;
+    private parseGroupsInfo;
+}
+
+declare class ModularRedisStreamManager extends StreamInfoTrait {
+    constructor(client: Redis);
+    createStreamWithGroup(key: string, groupName: string, options?: {
+        maxlen?: number;
+        approximate?: boolean;
+    }): Promise<void>;
+    getStreamStats(key: string): Promise<{
+        length: number;
+        info: any;
+        groups?: any[];
+    }>;
+    consumeStream(groupName: string, consumerName: string, keys: string[], options?: {
+        count?: number;
+        block?: number;
+        processMessage: (key: string, message: any) => Promise<void>;
+        autoAck?: boolean;
+    }): Promise<number>;
+}
+
+export { type ConsumerGroupInfo, ModularRedisAdapter, ModularRedisStreamManager, RedisAdapter, type RedisAdapterOptions$1 as RedisAdapterOptions, RedisCacheAdapter, type RedisCacheAdapterOptions, RedisCommands, type StreamEntry, type StreamInfo, createDatabaseAdapterWithCache };