Review funkt

node_modules/bullmq/dist/esm/interfaces/redis-client.d.ts

@@ -0,0 +1,181 @@
+import { Readable } from 'stream';
+/**
+ * Redis client interface for BullMQ.
+ *
+ * Abstracts the underlying Redis client library (ioredis, node-redis, Bun
+ * built-in Redis, etc.) while keeping Redis semantics.  Only the Redis
+ * commands that BullMQ actually uses are declared here.
+ *
+ * Method signatures use **structured options objects** instead of ioredis-style
+ * varargs so that every adapter (ioredis, node-redis, Bun, …) can map the
+ * call to its native API without parsing positional string tokens.
+ *
+ * The reference implementation for ioredis lives in
+ * `src/classes/ioredis-client.ts`.
+ */
+export interface IRedisClient {
+    /**
+     * Current connection status.
+     * Adapters must expose at least the values `'ready'`, `'wait'`, and
+     * `'end'` so that {@link RedisConnection.waitUntilReady} works correctly.
+     */
+    status: string;
+    /** Whether this client is connected to a Redis Cluster. */
+    readonly isCluster: boolean;
+    /** Client configuration options (shape is adapter-specific). */
+    options: Record<string, any>;
+    connect(): Promise<void>;
+    disconnect(reconnect?: boolean): void;
+    quit(): Promise<string>;
+    /** Create a duplicate connection with optional overrides. */
+    duplicate(...args: any[]): IRedisClient;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    removeListener(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    setMaxListeners(n: number): this;
+    getMaxListeners(): number;
+    removeAllListeners(event?: string | symbol): this;
+    /**
+     * Register a Lua script as a named command so it can later be invoked via
+     * {@link runCommand}.
+     *
+     * @param name       - Command name that will be callable via runCommand.
+     * @param definition - Script definition.
+     *   - `numberOfKeys` – number of KEYS[] arguments the script expects.
+     *   - `lua`          – Lua source code.
+     *   - `readOnly`     – (optional) hint that the script only reads data;
+     *                       some adapters (e.g. ioredis) use this to route the
+     *                       call to a replica in read-only mode.
+     */
+    defineCommand(name: string, definition: {
+        numberOfKeys: number;
+        lua: string;
+        readOnly?: boolean;
+    }): void;
+    /**
+     * Execute a previously registered Lua script command by name.
+     *
+     * @param name - The command name passed to {@link defineCommand}.
+     * @param args - Arguments forwarded to the script (KEYS first, then ARGV).
+     * @returns A `Promise<any>` whose resolved value matches the return value of
+     *   the Lua script.  BullMQ scripts return integers, strings, or arrays of
+     *   strings/integers.  Callers in {@link Scripts.execCommand} cast the result
+     *   to the expected concrete type after the call.
+     */
+    runCommand(name: string, args: any[]): Promise<any>;
+    multi(): IRedisTransaction;
+    pipeline(): IRedisTransaction;
+    hgetall(key: string): Promise<Record<string, string>>;
+    hget(key: string, field: string): Promise<string | null>;
+    hmget(key: string, ...fields: string[]): Promise<(string | null)[]>;
+    /** SET one or more hash fields from a field→value map. */
+    hset(key: string, data: Record<string, string | number>): Promise<number>;
+    hdel(key: string, ...fields: string[]): Promise<number>;
+    hexists(key: string, field: string): Promise<number>;
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string | number, options?: {
+        PX?: number;
+        EX?: number;
+    }): Promise<string | null>;
+    del(...keys: string[]): Promise<number>;
+    zrange(key: string, start: number, end: number, options?: {
+        WITHSCORES?: boolean;
+    }): Promise<string[]>;
+    zrevrange(key: string, start: number, end: number, options?: {
+        WITHSCORES?: boolean;
+    }): Promise<string[]>;
+    zcard(key: string): Promise<number>;
+    zscore(key: string, member: string): Promise<string | null>;
+    lrange(key: string, start: number, end: number): Promise<string[]>;
+    llen(key: string): Promise<number>;
+    ltrim(key: string, start: number, end: number): Promise<string>;
+    lpos(key: string, value: string): Promise<number | null>;
+    smembers(key: string): Promise<string[]>;
+    /**
+     * Append an entry to a stream.
+     *
+     * @param key    - Stream key
+     * @param id     - Entry ID (typically `'*'` for auto-generated)
+     * @param fields - Field-value pairs for the stream entry
+     * @param options - Optional MAXLEN trimming parameters
+     */
+    xadd(key: string, id: string, fields: Record<string, string | number>, options?: {
+        MAXLEN?: number;
+        approximate?: boolean;
+    }): Promise<string>;
+    /**
+     * Read from one or more streams.
+     *
+     * @param streams - Array of stream/id pairs to read from
+     * @param options - Optional BLOCK timeout and COUNT
+     */
+    xread(streams: {
+        key: string;
+        id: string;
+    }[], options?: {
+        BLOCK?: number;
+        COUNT?: number;
+    }): Promise<any>;
+    /**
+     * Trim a stream.
+     *
+     * @param key       - Stream key
+     * @param strategy  - Trim strategy (e.g. `'MAXLEN'`)
+     * @param threshold - Maximum stream length
+     * @param options   - Optional approximate trimming
+     */
+    xtrim(key: string, strategy: 'MAXLEN', threshold: number, options?: {
+        approximate?: boolean;
+    }): Promise<number>;
+    /**
+     * Block until an element is available in the given sorted set, or the
+     * timeout expires.
+     *
+     * The return shape mirrors ioredis' native `bzpopmin`:
+     * `[key, member, score]` on success, or `null` on timeout. Adapters for
+     * other clients (node-redis, bun) MUST convert their native return value
+     * to this tuple form. This avoids mutating the shape of `bzpopmin` on
+     * shared ioredis instances, which would be a breaking change for code
+     * that uses the same client outside of BullMQ.
+     */
+    bzpopmin(key: string, timeout: number): Promise<[key: string, member: string, score: string] | null>;
+    info(): Promise<string>;
+    clientSetName(name: string): Promise<any>;
+    clientList(): Promise<string>;
+    scan(cursor: string | number, options: {
+        MATCH?: string;
+        COUNT?: number;
+    }): Promise<[string, string[]]>;
+    scanStream(options: {
+        match: string;
+        count?: number;
+    }): Readable;
+    /** Return connections for each cluster node (only when isCluster). */
+    nodes?(): IRedisClient[];
+}
+/**
+ * Redis pipeline or transaction (MULTI).
+ *
+ * Commands are queued and executed together via {@link exec}.
+ * Only the subset of commands BullMQ uses inside pipelines is declared.
+ */
+export interface IRedisTransaction {
+    hgetall(key: string): this;
+    hset(key: string, data: Record<string, string | number>): this;
+    hscan(key: string, cursor: string | number, options?: {
+        COUNT?: number;
+    }): this;
+    smembers(key: string): this;
+    sscan(key: string, cursor: string | number, options?: {
+        COUNT?: number;
+    }): this;
+    zrange(key: string, start: number, end: number): this;
+    lrange(key: string, start: number, end: number): this;
+    llen(key: string): this;
+    del(...keys: string[]): this;
+    runCommand(name: string, args: any[]): this;
+    /** Execute all queued commands. */
+    exec(): Promise<[Error | null, any][] | null>;
+}