@hotmeshio/hotmesh/build/types/redis.d.ts

Serverless Workflow

/// <reference types="node" />
import { ProviderClient, ProviderConfig, ProviderTransaction } from './provider';
import { StringStringType } from './serializer';
import { ReclaimedMessageType } from './stream';
/**
 * Redis types
 */
interface ConnectionOptions {
    host?: string;
    port?: number;
    path?: string;
    socket?: any;
    NPNProtocols?: string[] | Buffer[];
    ALPNProtocols?: string[] | Buffer[];
    servername?: string;
    checkServerIdentity?: (servername: string, cert: Buffer) => Error | undefined;
    session?: Buffer;
    minDHSize?: number;
    secureContext?: any;
    secureProtocol?: string;
    ciphers?: string;
    honorCipherOrder?: boolean;
    requestCert?: boolean;
    rejectUnauthorized?: boolean;
    maxVersion?: 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
    minVersion?: 'TLSv1.3' | 'TLSv1.2' | 'TLSv1.1' | 'TLSv1';
}
interface RedisRedisClientOptions {
    url?: string;
    socket?: {
        host?: string;
        port?: number;
        tls?: boolean;
        servername?: string;
    };
    username?: string;
    password?: string;
    database?: number;
    name?: string;
    readonly?: boolean;
    legacyMode?: boolean;
    commandsQueueMaxLength?: number;
    disableOfflineQueue?: boolean;
    connectTimeout?: number;
    autoResubscribe?: boolean;
    autoResendUnfulfilledCommands?: boolean;
    lazyConnect?: boolean;
    tls?: boolean | ConnectionOptions;
    enableReadyCheck?: boolean;
    keepAlive?: number;
    family?: 'IPv4' | 'IPv6';
    keyPrefix?: string;
    retry?: {
        maxReconnectionAttempts?: number;
        initialReconnectionDelay?: number;
        reconnectionBackoffFactor?: number;
        totalReconnectionTimeout?: number;
        maxRetryCount?: number;
    };
    stringNumbers?: boolean;
}
interface RedisRedisMultiType extends ProviderTransaction {
    sendCommand(command: string, ...args: string[]): Promise<any>;
    exec: () => Promise<unknown[]>;
    DEL(key: string): this;
    EXISTS(key: string): this;
    EXPIRE(key: string, seconds: number): this;
    HDEL(key: string, fields: string[] | string): this;
    HGET(key: string, itemId: string): this;
    HGETALL(key: string): this;
    HINCRBYFLOAT(key: string, itemId: string, value: number): this;
    HMPUSH(key: string, values: Record<string, string>): this;
    RPUSH(key: string, items: string[]): this;
    HMGET(key: string, itemIds: string[]): this;
    HSET(key: string, values: Record<string, string>): this;
    LPUSH(key: string, items: string[]): this;
    LRANGE(key: string, start: number, end: number): this;
    RPUSH(key: string, items: string[]): this;
    SET(key: string, value: string): this;
    XADD(key: string, id: string, fields: any): this;
    XACK(key: string, group: string, id: string): this;
    XACK(key: string, group: string, ...ids: string[]): this;
    XDEL(key: string, id: string): this;
    XDEL(key: string, ...ids: string[]): this;
    XCLAIM(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): this;
    XLEN(key: string): this;
    XGROUP(command: 'CREATE' | string, key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): this;
    XPENDING(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
    ZADD(key: string, values: {
        score: string;
        value: string;
    }, opts?: {
        NX: boolean;
    }): this;
    ZRANGE_WITHSCORES(key: string, start: number, end: number): this;
    ZRANK(key: string, member: string): this;
    ZSCORE(key: string, value: string): this;
}
interface RedisRedisClientType extends ProviderClient {
    multi(): Partial<RedisRedisMultiType>;
    connect(): Promise<void>;
    sendCommand(args: any[]): Promise<any>;
    exec(): Promise<unknown[]>;
    flushDb(): Promise<string>;
    quit(): Promise<string>;
    disconnect(): void;
    duplicate(): RedisRedisClientType;
    on(event: string, callback: (...args: any[]) => void): void;
    publish(channel: string, message: string): Promise<number>;
    pSubscribe(pattern: string, callback: (channel: string, message: string) => void): Promise<void>;
    pUnsubscribe(pattern: string): Promise<void>;
    subscribe(channel: string, callback: (channel: string, message: string) => void): Promise<void>;
    unsubscribe(channel: string): Promise<void>;
    punsubscribe(channel: string): void;
    get(key: string): Promise<string | null>;
    set(key: string, value: string): Promise<string>;
    DEL(key: string): Promise<number>;
    EXISTS(key: string): Promise<number>;
    HDEL(key: string, fields: string[] | string): Promise<number>;
    HGET(key: string, itemId: string): Promise<string | null>;
    HGETALL(key: string): Promise<StringStringType>;
    HINCRBYFLOAT(key: string, itemId: string, value: number): Promise<number>;
    HMGET(key: string, itemIds: string[]): Promise<string[]>;
    HSET(key: string, values: Record<string, string>): Promise<number>;
    LPUSH(key: string, items: string[]): Promise<number>;
    LRANGE(key: string, start: number, end: number): Promise<string[]>;
    RPUSH(key: string, items: string[]): Promise<number>;
    SET(key: string, value: string): Promise<string>;
    XADD(key: string, id: string, fields: any): Promise<string>;
    XACK(key: string, group: string, ...ids: string[]): Promise<number>;
    XACK(key: string, group: string, id: string): Promise<number>;
    XCLAIM(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
    XDEL(key: string, id: string): Promise<number>;
    XDEL(key: string, ...ids: string[]): Promise<number>;
    xGroupDestroy(key: string, groupName: string): Promise<boolean>;
    XINFO(command: 'GROUPS' | string, key: string): Promise<unknown>;
    XINFO_GROUPS(key: string): Promise<unknown>;
    XLEN(key: string): Promise<number>;
    XPENDING(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
    ZADD(key: string, values: {
        score: string;
        value: string;
    }, opts?: {
        NX: boolean;
    }): Promise<number>;
    ZRANGE_WITHSCORES(key: string, start: number, end: number): Promise<{
        score: number;
        value: string;
    }>;
    ZRANK(key: string, member: string): Promise<number>;
    ZSCORE(key: string, value: string): Promise<number>;
}
interface RedisRedisClassType {
    createClient(options: RedisRedisClientOptions): Partial<RedisRedisClientType>;
}
/**
 * IORedis types
 */
interface IORedisClientOptions {
    port?: number;
    host?: string;
    family?: 'IPv4' | 'IPv6';
    path?: string;
    keepAlive?: number;
    noDelay?: boolean;
    connectionName?: string;
    db?: number;
    password?: string;
    username?: string;
    sentinels?: Array<{
        host: string;
        port: number;
    }>;
    name?: string;
    readOnly?: boolean;
    keyPrefix?: string;
    reconnectOnError?: (err: Error) => boolean;
}
interface IORedisClient extends ProviderClient {
    multi(): IORedisMultiType;
    exec(): Promise<unknown[]>;
    sendCommand(args: any[]): Promise<any>;
    call(command: string, ...args: any[]): Promise<any>;
    quit(): Promise<string>;
    flushdb(): Promise<string>;
    publish(channel: string, message: string): Promise<number>;
    psubscribe(pattern: string, callback: (channel: string, message: string) => void): Promise<void>;
    punsubscribe(pattern: string): Promise<number>;
    subscribe(channel: string, callback: (channel: string, message: string) => void): Promise<void>;
    unsubscribe(channel: string): Promise<number>;
    punsubscribe(channel: string): Promise<number>;
    xadd(key: string, id: string, fields: any, message?: string): Promise<string>;
    xack(key: string, group: string, id: string): Promise<number>;
    xack(key: string, group: string, ...ids: string[]): Promise<number>;
    xdel(key: string, id: string): Promise<number>;
    xdel(key: string, ...ids: string[]): Promise<number>;
    xlen(key: string): Promise<number>;
    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number] | unknown[]>;
    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
    xinfo(command: 'GROUPS' | string, key: string): Promise<unknown>;
    xrange(key: string, start: string, end: string): Promise<string[][]>;
    xreadgroup(command: 'GROUP', groupName: string, consumerName: string, blockOption: string, blockTime: number, streamsOption: string, streamName: string, key: string): Promise<string[][]>;
    del(key: string): Promise<number>;
    exists(key: string): Promise<number>;
    get(key: string): Promise<string | null>;
    hdel(key: string, ...fields: string[]): Promise<number>;
    hget(key: string, itemId: string): Promise<string | null>;
    hgetall(key: string): Promise<StringStringType>;
    hincrbyfloat(key: string, itemId: string, value: number): Promise<number>;
    hmget(key: string, itemIds: string[]): Promise<string[]>;
    hset(key: string, values: Record<string, string>): Promise<number>;
    lpush(key: string, ...args: string[]): Promise<number>;
    lrange(key: string, start: number, end: number): Promise<string[]>;
    on(event: string, callback: (...args: any[]) => void): void;
    rpush(key: string, ...args: string[]): Promise<number>;
    set(key: string, value: string): Promise<string>;
    zadd(...args: Array<string | number>): Promise<number>;
    zrange(key: string, start: number, end: number, withScores?: 'WITHSCORES'): Promise<string[]>;
    zrank(key: string, member: string): Promise<number>;
    zscore(key: string, value: string): Promise<number>;
    xgroup(command: 'CREATE' | 'DESTROY' | string, key: string, groupName: string, id?: string, mkStream?: 'MKSTREAM'): Promise<string | number>;
}
type IORedisClassType = new (options: IORedisClientOptions, ...args: any[]) => IORedisClient;
interface IORedisMultiType extends ProviderTransaction {
    xadd(key: string, id: string, fields: any, message?: string): this;
    xack(key: string, group: string, id: string): this;
    xack(key: string, group: string, ...ids: string[]): this;
    xdel(key: string, id: string): this;
    xdel(key: string, ...ids: string[]): this;
    xlen(key: string): this;
    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): this;
    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): this;
    del(key: string): this;
    expire(key: string, seconds: number): this;
    hdel(key: string, itemId: string): this;
    hget(key: string, itemId: string): this;
    hgetall(key: string): this;
    hincrbyfloat(key: string, itemId: string, value: number): this;
    hmget(key: string, itemIds: string[]): this;
    hset(key: string, values: Record<string, string>): this;
    lrange(key: string, start: number, end: number): this;
    rpush(key: string, value: string): this;
    zadd(...args: Array<string | number>): this;
    xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): this;
    sendCommand(command: string[]): Promise<any>;
    exec: () => Promise<unknown[]>;
}
type RedisClass = RedisRedisClassType | IORedisClassType;
type RedisClient = RedisRedisClientType | IORedisClient;
type RedisOptions = RedisRedisClientOptions | IORedisClientOptions;
type RedisMulti = RedisRedisMultiType | IORedisMultiType;
declare function isRedisClient(client: RedisClient): client is RedisRedisClientType;
declare function isIORedisClient(client: RedisClient): client is IORedisClient;
interface RedisConfig extends ProviderConfig {
    class: Partial<RedisClass>;
    options: Partial<RedisOptions>;
}
export { RedisClass, RedisConfig, RedisRedisClientType, RedisRedisClientOptions, RedisRedisClassType, IORedisClient as IORedisClientType, RedisClient, RedisMulti, RedisRedisMultiType, IORedisClientOptions, IORedisClassType, IORedisMultiType, RedisOptions, isRedisClient, isIORedisClient, };