@minimaltech/node-infra/dist/helpers/redis.helper.d.ts

Minimal Technology NodeJS Infrastructure - Loopback 4 Framework

import { BaseHelper } from '../base/base.helper';
import { Cluster, ClusterOptions, Redis } from 'ioredis';
export interface IRedisHelperProps {
    name: string;
    host: string;
    port: string | number;
    password: string;
    database?: number;
    autoConnect?: boolean;
    maxRetry?: number;
}
export interface IRedisClusterHelperProps {
    name: string;
    nodes: Array<Pick<IRedisHelperProps, 'host' | 'port'> & {
        password?: string;
    }>;
    clusterOptions?: ClusterOptions;
}
export interface IRedisHelperCallbacks {
    onInitialized?: (opts: {
        name: string;
        helper: DefaultRedisHelper;
    }) => void;
    onConnected?: (opts: {
        name: string;
        helper: DefaultRedisHelper;
    }) => void;
    onReady?: (opts: {
        name: string;
        helper: DefaultRedisHelper;
    }) => void;
    onError?: (opts: {
        name: string;
        helper: DefaultRedisHelper;
        error: any;
    }) => void;
}
export interface IRedisHelperOptions extends IRedisHelperProps, IRedisHelperCallbacks {
}
export interface IRedisClusterHelperOptions extends IRedisClusterHelperProps, IRedisHelperCallbacks {
}
export declare class DefaultRedisHelper extends BaseHelper {
    client: Redis | Cluster;
    name: string;
    constructor(opts: {
        scope: string;
        identifier: string;
        client: Redis | Cluster;
    } & IRedisHelperCallbacks);
    getClient(): Redis | Cluster;
    ping(): Promise<"PONG">;
    connect(): Promise<boolean>;
    disconnect(): Promise<boolean>;
    set(opts: {
        key: string;
        value: any;
        options?: {
            log: boolean;
        };
    }): Promise<void>;
    get(opts: {
        key: string;
        transform?: (input: string) => any;
    }): Promise<any>;
    del(opts: {
        keys: Array<string>;
    }): Promise<number>;
    getString(opts: {
        key: string;
    }): Promise<any>;
    getStrings(opts: {
        keys: Array<string>;
    }): Promise<any[] | null>;
    getObject(opts: {
        key: string;
    }): Promise<any>;
    getObjects(opts: {
        keys: Array<string>;
    }): Promise<any[] | null>;
    hset(opts: {
        key: string;
        value: any;
        options?: {
            log: boolean;
        };
    }): Promise<number | undefined>;
    hSet(opts: {
        key: string;
        value: any;
        options?: {
            log: boolean;
        };
    }): Promise<number | undefined>;
    hgetall(opts: {
        key: string;
        transform?: <T, R>(input: T) => R;
    }): Promise<unknown>;
    hGetAll(opts: {
        key: string;
        transform?: <T, R>(input: T) => R;
    }): Promise<unknown>;
    mset(opts: {
        payload: Array<{
            key: string;
            value: any;
        }>;
        options?: {
            log: boolean;
        };
    }): Promise<void>;
    mSet(opts: {
        payload: Array<{
            key: string;
            value: any;
        }>;
        options?: {
            log: boolean;
        };
    }): Promise<void>;
    mget(opts: {
        keys: Array<string>;
        transform?: (input: string) => any;
    }): Promise<any[] | null>;
    mGet(opts: {
        keys: Array<string>;
        transform?: (input: string) => any;
    }): Promise<any[] | null>;
    keys(opts: {
        key: string;
    }): Promise<string[]>;
    jSet<T = any>(opts: {
        key: string;
        path: string;
        value: T;
    }): Promise<any>;
    jGet<T = any>(opts: {
        key: string;
        path?: string;
    }): Promise<T>;
    jDelete(opts: {
        key: string;
        path?: string;
    }): Promise<number>;
    jNumberIncreaseBy(opts: {
        key: string;
        path: string;
        value: number;
    }): Promise<any>;
    jStringAppend(opts: {
        key: string;
        path: string;
        value: string;
    }): Promise<any>;
    jPush<T = any>(opts: {
        key: string;
        path: string;
        value: T;
    }): Promise<any>;
    jPop<T = any>(opts: {
        key: string;
        path: string;
    }): Promise<T>;
    execute<R = any>(command: string, parameters?: Array<string | number | Buffer>): Promise<R>;
    publish<T = any>(opts: {
        topics: Array<string>;
        payload: T;
        useCompress?: boolean;
    }): Promise<void>;
    subscribe(opts: {
        topic: string;
    }): void;
}
export declare class RedisHelper extends DefaultRedisHelper {
    constructor(opts: IRedisHelperOptions);
    getClient(): Redis;
}
export declare class RedisClusterHelper extends DefaultRedisHelper {
    constructor(opts: IRedisClusterHelperOptions);
    getClient(): Cluster;
}