@taicode/common-server 3.7.4 → 3.7.7

package/output/redis-queue/redis-queue-provider.d.ts

@@ -1,69 +0,0 @@
-import { RedisQueueCommon } from './redis-queue-common.js';
-import type { RedisQueueRegistry, RedisQueueProviderConfig, Task, QueueStats } from './types.js';
-/**
- * Redis 队列生产者
- *
- * 只负责任务的入队和队列管理,不包含消费逻辑
- *
- * @template R Registry 类型,默认为 RedisQueueRegistry
- * @template K 队列键类型
- *
- * @example
- * ```ts
- * // 方式 1: 使用默认 RedisQueueRegistry (需要提前声明模块扩展)
- * const provider = new RedisQueueProvider('email-queue', {
- *   redisUrl: 'redis://localhost:6379'
- * })
- *
- * await provider.enqueue({
- *   to: 'user@example.com', // 类型自动推断
- *   subject: 'Hello',
- *   body: 'World'
- * })
- *
- * // 方式 2: 使用自定义 Registry
- * interface MyRegistry {
- *   'order-queue': { orderId: string; amount: number }
- * }
- *
- * const provider = new RedisQueueProvider<MyRegistry, 'order-queue'>(
- *   'order-queue',
- *   { redisUrl: 'redis://localhost:6379' }
- * )
- *
- * await provider.enqueue({ orderId: '123', amount: 100 })
- * ```
- */
-export declare class RedisQueueProvider<R extends Record<string, any> = RedisQueueRegistry, K extends keyof R & string = keyof R & string> extends RedisQueueCommon {
-    private readonly processingDelay;
-    constructor(queueKey: K, config?: RedisQueueProviderConfig);
-    protected getLogPrefix(): string;
-    /**
-     * 将任务推入队列(支持单个或批量)
-     * @param data 任务数据(单个或数组)。可以在 data 中包含 `id` 字段来实现幂等性
-     *
-     * @example
-     * // 普通任务,自动生成 ID
-     * await provider.enqueue({ to: 'user@example.com' })
-     *
-     * // 幂等任务,手动指定 ID,重复提交会被忽略
-     * await provider.enqueue({ id: 'email-123', to: 'user@example.com' })
-     * await provider.enqueue({ id: 'email-123', to: 'user@example.com' }) // 会被跳过
-     */
-    enqueue(data: R[K][]): Promise<string[]>;
-    enqueue(data: R[K]): Promise<string>;
-    /**
-     * 获取任务详情
-     */
-    getTask(taskId: string): Promise<Task<R[K]> | null>;
-    /**
-     * 获取队列统计信息（O(1) 时间复杂度）
-     */
-    statistics(): Promise<QueueStats>;
-    /**
-     * 清空所有队列和任务数据
-     * 使用 Lua 脚本确保原子性
-     */
-    clear(): Promise<void>;
-}
-//# sourceMappingURL=redis-queue-provider.d.ts.map

package/output/redis-queue/redis-queue-provider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"redis-queue-provider.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-provider.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAEhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,kBAAkB,CAC7B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,kBAAkB,EAClD,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,CAC7C,SAAQ,gBAAgB;IACxB,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAQ;gBAE5B,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAE,wBAA6B;IAU9D,SAAS,CAAC,YAAY,IAAI,MAAM;IAMhC;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IACxC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IA0F1C;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAWzD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAevC;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAmD7B"}

package/output/redis-queue/redis-queue-provider.js

@@ -1,205 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { logger } from '@taicode/common-base';
-import { RedisQueueCommon } from './redis-queue-common.js';
-/**
- * Redis 队列生产者
- *
- * 只负责任务的入队和队列管理,不包含消费逻辑
- *
- * @template R Registry 类型,默认为 RedisQueueRegistry
- * @template K 队列键类型
- *
- * @example
- * ```ts
- * // 方式 1: 使用默认 RedisQueueRegistry (需要提前声明模块扩展)
- * const provider = new RedisQueueProvider('email-queue', {
- *   redisUrl: 'redis://localhost:6379'
- * })
- *
- * await provider.enqueue({
- *   to: 'user@example.com', // 类型自动推断
- *   subject: 'Hello',
- *   body: 'World'
- * })
- *
- * // 方式 2: 使用自定义 Registry
- * interface MyRegistry {
- *   'order-queue': { orderId: string; amount: number }
- * }
- *
- * const provider = new RedisQueueProvider<MyRegistry, 'order-queue'>(
- *   'order-queue',
- *   { redisUrl: 'redis://localhost:6379' }
- * )
- *
- * await provider.enqueue({ orderId: '123', amount: 100 })
- * ```
- */
-export class RedisQueueProvider extends RedisQueueCommon {
-    processingDelay;
-    constructor(queueKey, config = {}) {
-        super(queueKey, {
-            redisUrl: config.redisUrl,
-            redisClient: config.redisClient,
-            cleanupDelay: config.cleanupDelay,
-        });
-        this.processingDelay = config.processingDelay ?? 0; // 默认立即执行
-    }
-    getLogPrefix() {
-        return 'RedisQueueProvider';
-    }
-    async enqueue(data) {
-        if (!this.redis) {
-            logger.warn('[RedisQueueProvider] Redis not available, skipping task enqueue');
-            return Array.isArray(data) ? [] : '';
-        }
-        // 统一处理为数组
-        const dataList = Array.isArray(data) ? data : [data];
-        const taskIds = [];
-        const tasks = [];
-        // 准备任务数据
-        for (const item of dataList) {
-            const customId = item.id;
-            // 严格检查 id 类型,只接受 string
-            if (customId !== undefined && typeof customId !== 'string') {
-                throw new TypeError(`[RedisQueueProvider] Task id must be a string, got ${typeof customId}. ` +
-                    `Please use string type for task id field.`);
-            }
-            const taskId = customId || randomUUID();
-            const task = {
-                id: taskId,
-                data: item,
-                retryCount: 0,
-                maxRetries: 3, // 默认值,实际由 Consumer 控制
-                createdTime: new Date().toISOString(),
-                status: 'pending',
-                ...(this.processingDelay > 0 && { delayUntil: Date.now() + this.processingDelay }),
-            };
-            taskIds.push(taskId);
-            tasks.push(task);
-        }
-        // 使用 Lua 脚本批量原子化入队
-        const batchEnqueueScript = `
-      local pendingQueue = KEYS[1]
-      local ttl = tonumber(ARGV[1])
-      local queueKeyPrefix = ARGV[2]
-      local successCount = 0
-      
-      -- ARGV[3], ARGV[5], ARGV[7]... 是 taskId
-      -- ARGV[4], ARGV[6], ARGV[8]... 是 taskData
-      for i = 3, #ARGV, 2 do
-        local taskId = ARGV[i]
-        local taskData = ARGV[i + 1]
-        local taskKey = queueKeyPrefix .. ':task:' .. taskId
-        
-        -- 检查任务是否已存在
-        local exists = redis.call('EXISTS', taskKey)
-        if exists == 0 then
-          -- 原子化操作: 创建任务 + 推入队列
-          redis.call('SETEX', taskKey, ttl, taskData)
-          redis.call('RPUSH', pendingQueue, taskId)
-          successCount = successCount + 1
-        end
-      end
-      
-      return successCount
-    `;
-        // 构建参数数组 - Redis 要求所有参数都是字符串
-        const args = [this.cleanupDelay.toString(), this.queueKey];
-        for (let i = 0; i < tasks.length; i++) {
-            args.push(taskIds[i]);
-            args.push(JSON.stringify(tasks[i]));
-        }
-        const successCount = await this.redis.eval(batchEnqueueScript, {
-            keys: [this.pendingQueue],
-            arguments: args,
-        });
-        if (successCount < tasks.length) {
-            logger.info(`[RedisQueueProvider] ${tasks.length - successCount} tasks already exist, skipped`);
-        }
-        if (successCount > 0) {
-            logger.info(`[RedisQueueProvider] Enqueued ${successCount} tasks`);
-        }
-        // 返回单个 ID 或 ID 数组
-        return Array.isArray(data) ? taskIds : taskIds[0];
-    }
-    /**
-     * 获取任务详情
-     */
-    async getTask(taskId) {
-        if (!this.redis)
-            return null;
-        const taskKey = `${this.queueKey}:task:${taskId}`;
-        const taskData = await this.redis.get(taskKey);
-        if (!taskData)
-            return null;
-        return JSON.parse(taskData);
-    }
-    /**
-     * 获取队列统计信息（O(1) 时间复杂度）
-     */
-    async statistics() {
-        if (!this.redis) {
-            return { pending: 0, processing: 0, completed: 0, failed: 0 };
-        }
-        const [pending, processing, completed, failed] = await Promise.all([
-            this.redis.lLen(this.pendingQueue),
-            this.redis.lLen(this.processingQueue),
-            this.redis.lLen(this.completedQueue),
-            this.redis.lLen(this.failedQueue),
-        ]);
-        return { pending, processing, completed, failed };
-    }
-    /**
-     * 清空所有队列和任务数据
-     * 使用 Lua 脚本确保原子性
-     */
-    async clear() {
-        if (!this.redis)
-            return;
-        // 使用 Lua 脚本原子化清空队列和任务
-        const clearScript = `
-      local queueKeyPrefix = ARGV[1]
-      local pendingQueue = KEYS[1]
-      local processingQueue = KEYS[2]
-      local completedQueue = KEYS[3]
-      local failedQueue = KEYS[4]
-      
-      -- 获取所有队列中的任务 ID
-      local allTaskIds = {}
-      local pendingIds = redis.call('LRANGE', pendingQueue, 0, -1)
-      local processingIds = redis.call('LRANGE', processingQueue, 0, -1)
-      local completedIds = redis.call('LRANGE', completedQueue, 0, -1)
-      local failedIds = redis.call('LRANGE', failedQueue, 0, -1)
-      
-      -- 合并所有任务 ID
-      for _, id in ipairs(pendingIds) do table.insert(allTaskIds, id) end
-      for _, id in ipairs(processingIds) do table.insert(allTaskIds, id) end
-      for _, id in ipairs(completedIds) do table.insert(allTaskIds, id) end
-      for _, id in ipairs(failedIds) do table.insert(allTaskIds, id) end
-      
-      -- 删除所有任务数据
-      for _, taskId in ipairs(allTaskIds) do
-        local taskKey = queueKeyPrefix .. ':task:' .. taskId
-        redis.call('DEL', taskKey)
-      end
-      
-      -- 删除所有队列
-      redis.call('DEL', pendingQueue, processingQueue, completedQueue, failedQueue)
-      
-      return #allTaskIds
-    `;
-        const deletedCount = await this.redis.eval(clearScript, {
-            keys: [
-                this.pendingQueue,
-                this.processingQueue,
-                this.completedQueue,
-                this.failedQueue,
-            ],
-            arguments: [this.queueKey],
-        });
-        if (deletedCount > 0) {
-            logger.info(`[RedisQueueProvider] Cleared ${deletedCount} tasks`);
-        }
-    }
-}

package/output/redis-queue/redis-queue-provider.test.d.ts

@@ -1,28 +0,0 @@
-type TestTaskData = {
-    id?: string;
-    value?: number | string;
-    test?: boolean | string;
-    index?: number;
-    payload?: string;
-    order?: number;
-    taskId?: number;
-    message?: string;
-    name?: string;
-    shouldFail?: boolean;
-    step?: number;
-    real?: boolean;
-    nested?: {
-        value: number;
-    };
-    example?: string;
-    foo?: string;
-    number?: number;
-    data?: any;
-};
-declare module "./types.js" {
-    interface RedisQueueRegistry {
-        [key: `test:provider:${string}`]: TestTaskData;
-    }
-}
-export {};
-//# sourceMappingURL=redis-queue-provider.test.d.ts.map

package/output/redis-queue/redis-queue-provider.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"redis-queue-provider.test.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-provider.test.ts"],"names":[],"mappings":"AAMA,KAAK,YAAY,GAAG;IAClB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IACvB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,CAAC,EAAE,GAAG,CAAA;CACX,CAAA;AAGD,OAAO,QAAQ,YAAY,CAAC;IAC1B,UAAU,kBAAkB;QAC1B,CAAC,GAAG,EAAE,iBAAiB,MAAM,EAAE,GAAG,YAAY,CAAA;KAC/C;CACF"}

package/output/redis-queue/redis-queue-provider.test.js

@@ -1,149 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import { RedisQueueProvider } from "./redis-queue-provider.js";
-import { clearQueue, getQueueTasks } from "./test-helpers.js";
-const REDIS_URL = process.env.REDIS_URL || "redis://localhost:6379";
-describe("RedisQueueProvider", () => {
-    const providers = [];
-    afterEach(async () => {
-        for (const provider of providers) {
-            await clearQueue(provider);
-            provider.disconnect();
-        }
-        providers.length = 0;
-    });
-    const createProvider = (options) => {
-        const uniqueKey = `test:provider:${Date.now()}:${Math.random()}`;
-        const provider = new RedisQueueProvider(uniqueKey, {
-            redisUrl: REDIS_URL,
-            ...options,
-        });
-        providers.push(provider);
-        return provider;
-    };
-    describe("连接管理", () => {
-        it("应该成功连接到 Redis", async () => {
-            const provider = createProvider();
-            await provider.connect();
-            const health = await provider.health();
-            expect(health).toBe(true);
-        });
-    });
-    describe("任务入队", () => {
-        it("应该成功将任务推入队列", async () => {
-            const provider = createProvider();
-            await provider.connect();
-            const taskId = await provider.enqueue({ foo: "bar" });
-            expect(taskId).toBeTruthy();
-            const stats = await provider.statistics();
-            expect(stats.pending).toBe(1);
-        });
-        it("应该能够批量入队任务", async () => {
-            const provider = createProvider();
-            await provider.connect();
-            const taskIds = await provider.enqueue([
-                { value: 1 },
-                { value: 2 },
-                { value: 3 },
-            ]);
-            expect(taskIds).toHaveLength(3);
-            const stats = await provider.statistics();
-            expect(stats.pending).toBe(3);
-        });
-        it("入队的任务应该包含正确的元数据", async () => {
-            const provider = createProvider();
-            await provider.connect();
-            const taskId = await provider.enqueue({ test: "data", number: 42 });
-            const task = await provider.getTask(taskId);
-            expect(task).toBeTruthy();
-            expect(task?.id).toBe(taskId);
-            expect(task?.data).toEqual({ test: "data", number: 42 });
-            expect(task?.status).toBe("pending");
-            expect(task?.retryCount).toBe(0);
-        });
-    });
-    describe("队列操作", () => {
-        it("应该正确返回队列统计信息", async () => {
-            const provider = createProvider();
-            await provider.connect();
-            await provider.enqueue([{ test: "1" }, { test: "2" }, { test: "3" }]);
-            const stats = await provider.statistics();
-            expect(stats.pending).toBe(3);
-            expect(stats.processing).toBe(0);
-            expect(stats.completed).toBe(0);
-            expect(stats.failed).toBe(0);
-        });
-        it("应该能够清空队列", async () => {
-            const provider = createProvider();
-            await provider.connect();
-            await provider.enqueue([{ data: 1 }, { data: 2 }]);
-            await provider.clear();
-            const stats = await provider.statistics();
-            expect(stats.pending).toBe(0);
-        });
-        it("应该能够使用 getQueueTasks 获取特定状态的任务", async () => {
-            const provider = createProvider();
-            await provider.connect();
-            await provider.enqueue([
-                { name: "task1" },
-                { name: "task2" },
-                { name: "task3" },
-            ]);
-            const pendingTasks = await getQueueTasks(provider, "pending");
-            expect(pendingTasks).toHaveLength(3);
-            expect(pendingTasks.every(t => t.status === "pending")).toBe(true);
-            // 验证任务数据
-            const taskNames = pendingTasks.map(t => t.data.name);
-            expect(taskNames).toContain("task1");
-            expect(taskNames).toContain("task2");
-            expect(taskNames).toContain("task3");
-        });
-    });
-    describe("幂等性", () => {
-        it("应该支持在 data 中指定 id 来实现幂等性", async () => {
-            const provider = createProvider();
-            await provider.connect();
-            await provider.enqueue({ id: "unique-1", value: 1 });
-            await provider.enqueue({ id: "unique-1", value: 2 });
-            await provider.enqueue({ id: "unique-2", value: 3 });
-            const stats = await provider.statistics();
-            expect(stats.pending).toBe(2); // 只有 unique-1 和 unique-2
-        });
-        it("应该拒绝非 string 类型的 id 并抛出 TypeError", async () => {
-            const provider = createProvider();
-            await provider.connect();
-            // 尝试传入数字类型的 id,应该抛出 TypeError
-            await expect(async () => {
-                await provider.enqueue({ id: 123, value: "test" });
-            }).rejects.toThrow(TypeError);
-            await expect(async () => {
-                await provider.enqueue({ id: 123, value: "test" });
-            }).rejects.toThrow(/must be a string/);
-            // 尝试传入布尔类型的 id,应该抛出 TypeError
-            await expect(async () => {
-                await provider.enqueue({ id: true, value: "test" });
-            }).rejects.toThrow(TypeError);
-            // 尝试传入对象类型的 id,应该抛出 TypeError
-            await expect(async () => {
-                await provider.enqueue({
-                    id: { nested: "value" },
-                    value: "test",
-                });
-            }).rejects.toThrow(TypeError);
-            // 字符串类型的 id 应该正常工作
-            await expect(provider.enqueue({ id: "123", value: "test" })).resolves.not.toThrow();
-            // 验证只有字符串 ID 的任务被入队
-            const stats = await provider.statistics();
-            expect(stats.pending).toBe(1);
-        });
-    });
-    describe("延迟处理", () => {
-        it("应该支持延迟入队任务", async () => {
-            const provider = createProvider({ processingDelay: 2000 });
-            await provider.connect();
-            const taskId = (await provider.enqueue({ test: true }));
-            const task = await provider.getTask(taskId);
-            expect(task?.delayUntil).toBeDefined();
-            expect(task?.delayUntil).toBeGreaterThan(Date.now());
-        });
-    });
-});

package/output/redis-queue/test-helpers.d.ts

@@ -1,112 +0,0 @@
-import type { RedisQueueBatchConsumer } from './redis-queue-batch-consumer.js';
-import { RedisQueueConsumer } from './redis-queue-consumer.js';
-import type { RedisQueueProvider } from './redis-queue-provider.js';
-import type { RedisQueueRegistry, Task } from './types.js';
-/**
- * 测试辅助函数：立即派发任务到消费者
- *
- * 这个辅助函数提供了一个简洁的测试接口，让你能够立即派发任务到消费者，
- * 而不需要等待定时轮询机制。这使得测试更加快速和可控。
- *
- * @param consumer RedisQueueConsumer 或 RedisQueueBatchConsumer 实例
- * @param taskIds 要派发的任务 ID 列表
- * @returns Promise，等待所有任务处理完成
- *
- * @example
- * ```ts
- * import { dispatchQueueTask } from '@taicode/common-server/redis-queue/test-helpers'
- * import { RedisQueueProvider, RedisQueueConsumer } from '@taicode/common-server/redis-queue'
- *
- * describe('My Queue Tests', () => {
- *   it('should process tasks', async () => {
- *     const provider = new RedisQueueProvider({ ... })
- *     const consumer = new RedisQueueConsumer({ ... })
- *
- *     await provider.connect()
- *     await consumer.connect()
- *
- *     // 添加任务
- *     const taskId = await provider.enqueue({ data: 'test' })
- *
- *     // 立即派发任务进行测试
- *     await dispatchQueueTask(consumer, [taskId as string])
- *
- *     // 验证结果
- *     const stats = await consumer.statistics()
- *     expect(stats.completed).toBe(1)
- *   })
- * })
- * ```
- */
-export declare function dispatchQueueTask<R extends Record<string, any> = RedisQueueRegistry, K extends keyof R & string = keyof R & string>(consumer: RedisQueueConsumer<R, K> | RedisQueueBatchConsumer<R, K>, taskIds: string[]): Promise<void>;
-/**
- * 测试辅助函数：等待队列达到指定状态
- *
- * @param instance Provider 或 Consumer 实例
- * @param predicate 状态断言函数
- * @param options 配置选项
- * @returns Promise，在条件满足时 resolve
- *
- * @example
- * ```ts
- * // 使用 consumer 等待所有任务完成
- * await waitQueueCompletion(consumer, stats => stats.pending === 0 && stats.processing === 0)
- *
- * // 使用 provider 等待至少完成 10 个任务
- * await waitQueueCompletion(provider, stats => stats.completed >= 10, { timeout: 5000 })
- * ```
- */
-export declare function waitQueueCompletion<R extends Record<string, any> = RedisQueueRegistry, K extends keyof R & string = keyof R & string>(instance: RedisQueueProvider<R, K> | RedisQueueConsumer<R, K> | RedisQueueBatchConsumer<R, K>, predicate: (stats: {
-    pending: number;
-    processing: number;
-    completed: number;
-    failed: number;
-}) => boolean, options?: {
-    timeout?: number;
-    interval?: number;
-}): Promise<void>;
-/**
- * 测试辅助函数：清空队列所有状态
- *
- * 用于测试前后的清理工作，支持 Provider 或 Consumer 实例
- *
- * @param instance Provider 或 Consumer 实例
- * @returns Promise
- *
- * @example
- * ```ts
- * // 使用 consumer 清理
- * afterEach(async () => {
- *   await clearQueue(consumer)
- *   consumer.disconnect()
- * })
- *
- * // 使用 provider 清理
- * afterEach(async () => {
- *   await clearQueue(provider)
- *   provider.disconnect()
- * })
- * ```
- */
-export declare function clearQueue<R extends Record<string, any> = RedisQueueRegistry, K extends keyof R & string = keyof R & string>(instance: RedisQueueProvider<R, K> | RedisQueueConsumer<R, K> | RedisQueueBatchConsumer<R, K>): Promise<void>;
-/**
- * 测试辅助函数：获取队列中的所有任务详情
- *
- * 用于测试验证，可以检查任务的完整状态
- *
- * @param provider Provider 实例
- * @param status 可选，筛选特定状态的任务
- * @returns 任务列表
- *
- * @example
- * ```typescript
- * // 获取所有失败的任务
- * const failedTasks = await getQueueTasks(provider, 'failed')
- * expect(failedTasks).toHaveLength(3)
- *
- * // 验证任务数据
- * expect(failedTasks[0].data).toMatchObject({ id: 123 })
- * ```
- */
-export declare function getQueueTasks<R extends Record<string, any> = RedisQueueRegistry, K extends keyof R & string = keyof R & string>(provider: RedisQueueProvider<R, K>, status?: 'pending' | 'processing' | 'completed' | 'failed'): Promise<Task<R[K]>[]>;
-//# sourceMappingURL=test-helpers.d.ts.map

package/output/redis-queue/test-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../source/redis-queue/test-helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAA;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,iBAAiB,CACrC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,kBAAkB,EAClD,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,EAE7C,QAAQ,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,EAClE,OAAO,EAAE,MAAM,EAAE,GAChB,OAAO,CAAC,IAAI,CAAC,CA+Ff;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CACvC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,kBAAkB,EAClD,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,EAE7C,QAAQ,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC7F,SAAS,EAAE,CAAC,KAAK,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,EACzG,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,UAAU,CAC9B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,kBAAkB,EAClD,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,EAE7C,QAAQ,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,GAC5F,OAAO,CAAC,IAAI,CAAC,CAcf;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,aAAa,CACjC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,kBAAkB,EAClD,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,GAAG,MAAM,CAAC,GAAG,MAAM,EAE7C,QAAQ,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAClC,MAAM,CAAC,EAAE,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,GACzD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAmCvB"}