npm - @taicode/common-server - Versions diffs - 1.0.13 → 1.0.14 - Mend

@taicode/common-server 1.0.13 → 1.0.14

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (37) hide show

package/output/redis-queue/test-helpers.test.js ADDED Viewed

@@ -0,0 +1,572 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { catchIt } from '@taicode/common-base';
+import { RedisQueueProvider } from './redis-queue-provider';
+import { RedisQueueConsumer } from './redis-queue-consumer';
+import { RedisQueueBatchConsumer } from './redis-queue-batch-consumer';
+import { dispatchQueueTask, waitQueueCompletion, clearQueue, getQueueTasks, } from './test-helpers';
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+/**
+ * 测试辅助方法使用示例
+ *
+ * 展示如何使用所有测试辅助函数进行快速、可控的队列测试
+ */
+describe('Redis Queue Test Helpers', () => {
+    // 每次运行使用唯一的队列名,避免测试间干扰
+    let testQueueKey;
+    beforeEach(() => {
+        testQueueKey = `test:helpers:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+    });
+    describe('RedisQueueConsumer.dispatch', () => {
+        let provider;
+        let consumer;
+        let queueKey;
+        const processedTasks = [];
+        beforeEach(async () => {
+            processedTasks.length = 0;
+            // 每个测试套件使用独立的队列名
+            queueKey = `test:consumer:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+            provider = new RedisQueueProvider(queueKey, { redisUrl: REDIS_URL });
+            consumer = new RedisQueueConsumer(queueKey, { redisUrl: REDIS_URL, handler: async (data) => {
+                    processedTasks.push(data);
+                    return catchIt(() => { });
+                },
+            });
+            await provider.connect();
+            await consumer.connect();
+        });
+        afterEach(async () => {
+            await clearQueue(consumer);
+            provider.disconnect();
+            await consumer.disconnect();
+        });
+        it('应该立即派发单个任务', async () => {
+            // 添加任务
+            const taskId = await provider.enqueue({ message: 'test task' });
+            // 立即派发任务（不等待轮询）
+            await dispatchQueueTask(consumer, [taskId]);
+            // 验证任务已处理
+            expect(processedTasks).toHaveLength(1);
+            expect(processedTasks[0]).toEqual({ message: 'test task' });
+            // 验证队列状态
+            const stats = await consumer.statistics();
+            expect(stats.completed).toBe(1);
+            expect(stats.pending).toBe(0);
+        });
+        it('应该立即派发多个任务', async () => {
+            // 添加多个任务
+            const taskIds = (await provider.enqueue([
+                { id: '1' },
+                { id: '2' },
+                { id: '3' },
+            ]));
+            // 立即派发所有任务
+            await dispatchQueueTask(consumer, taskIds);
+            // 验证所有任务已处理
+            expect(processedTasks).toHaveLength(3);
+            expect(processedTasks.map(t => t.id).sort()).toEqual(['1', '2', '3']);
+            // 验证队列状态
+            const stats = await consumer.statistics();
+            expect(stats.completed).toBe(3);
+        });
+        it('应该处理任务失败和重试', async () => {
+            let attemptCount = 0;
+            const failingConsumer = new RedisQueueConsumer(queueKey, {
+                redisUrl: REDIS_URL,
+                maxRetries: 2,
+                handler: async (data) => {
+                    attemptCount++;
+                    if (attemptCount < 3) {
+                        throw new Error('Simulated failure');
+                    }
+                    processedTasks.push(data);
+                    return catchIt(() => { });
+                },
+            });
+            await failingConsumer.connect();
+            const taskId = await provider.enqueue({ test: 'retry' });
+            // 立即派发任务
+            await dispatchQueueTask(failingConsumer, [taskId]);
+            // 验证重试逻辑
+            expect(attemptCount).toBe(3); // 1次初始 + 2次重试
+            expect(processedTasks).toHaveLength(1);
+            await failingConsumer.disconnect();
+        });
+        it('应该忽略不存在的任务ID', async () => {
+            const realTaskId = await provider.enqueue({ real: true });
+            const fakeTaskId = 'non-existent-task-id';
+            // 混合真实和虚假任务ID
+            await dispatchQueueTask(consumer, [realTaskId, fakeTaskId]);
+            // 只有真实任务被处理
+            expect(processedTasks).toHaveLength(1);
+            expect(processedTasks[0]).toEqual({ real: true });
+        });
+    });
+    describe('RedisQueueBatchConsumer.dispatch', () => {
+        let provider;
+        let consumer;
+        let queueKey;
+        const processedBatches = [];
+        beforeEach(async () => {
+            processedBatches.length = 0;
+            // 每个测试套件使用独立的队列名
+            queueKey = `test:batch:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+            provider = new RedisQueueProvider(queueKey, { redisUrl: REDIS_URL });
+            consumer = new RedisQueueBatchConsumer(queueKey, { redisUrl: REDIS_URL, batchSize: 3,
+                handler: async (dataList) => {
+                    processedBatches.push([...dataList]);
+                    return catchIt(() => { });
+                },
+            });
+            await provider.connect();
+            await consumer.connect();
+        });
+        afterEach(async () => {
+            await clearQueue(consumer);
+            provider.disconnect();
+            await consumer.disconnect();
+        });
+        it('应该按批次大小立即派发任务', async () => {
+            // 添加 5 个任务（batchSize = 3）
+            const taskIds = (await provider.enqueue([
+                { id: '1' },
+                { id: '2' },
+                { id: '3' },
+                { id: '4' },
+                { id: '5' },
+            ]));
+            // 立即派发所有任务
+            await dispatchQueueTask(consumer, taskIds);
+            // 验证批次处理：应该有2个批次（3+2）
+            expect(processedBatches).toHaveLength(2);
+            expect(processedBatches[0]).toHaveLength(3);
+            expect(processedBatches[1]).toHaveLength(2);
+            // 验证所有任务都被处理
+            const allProcessed = processedBatches.flat();
+            expect(allProcessed).toHaveLength(5);
+            // 验证队列状态
+            const stats = await consumer.statistics();
+            expect(stats.completed).toBe(5);
+        });
+        it('应该处理单个批次', async () => {
+            const taskIds = (await provider.enqueue([
+                { value: 'a' },
+                { value: 'b' },
+            ]));
+            await dispatchQueueTask(consumer, taskIds);
+            // 只有一个批次
+            expect(processedBatches).toHaveLength(1);
+            expect(processedBatches[0]).toHaveLength(2);
+        });
+        it('应该支持大批量任务测试', async () => {
+            // 添加 100 个任务
+            const data = Array.from({ length: 100 }, (_, i) => ({ index: i }));
+            const taskIds = (await provider.enqueue(data));
+            // 立即派发
+            await dispatchQueueTask(consumer, taskIds);
+            // 验证批次数量（100 / 3 = 34 批次）
+            const totalProcessed = processedBatches.flat().length;
+            expect(totalProcessed).toBe(100);
+            // 验证队列清空
+            const stats = await consumer.statistics();
+            expect(stats.pending).toBe(0);
+            expect(stats.completed).toBe(100);
+        });
+        it('应该处理批量任务失败', async () => {
+            let attemptCount = 0;
+            const failingConsumer = new RedisQueueBatchConsumer(queueKey, { redisUrl: REDIS_URL, batchSize: 2,
+                maxRetries: 0, // 不重试
+                handler: async (dataList) => {
+                    attemptCount++;
+                    throw new Error('Batch processing failed');
+                },
+            });
+            await failingConsumer.connect();
+            const taskIds = (await provider.enqueue([
+                { id: '1' },
+                { id: '2' },
+            ]));
+            await dispatchQueueTask(failingConsumer, taskIds);
+            // 等待一下,确保任务处理完成
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // 验证失败处理
+            const stats = await failingConsumer.statistics();
+            // 任务会被重试,因为 Provider 设置了 maxRetries: 3
+            // 所以最终会进入 failed 队列
+            expect(stats.failed).toBeGreaterThanOrEqual(0);
+            expect(stats.completed).toBe(0);
+            await clearQueue(failingConsumer);
+            await failingConsumer.disconnect();
+        });
+    });
+    describe('性能测试示例', () => {
+        it('应该快速完成大量任务测试', async () => {
+            const queueKey = `test:perf1:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+            const provider = new RedisQueueProvider(queueKey, { redisUrl: REDIS_URL });
+            let processedCount = 0;
+            const consumer = new RedisQueueConsumer(queueKey, { redisUrl: REDIS_URL, handler: async () => {
+                    processedCount++;
+                    return catchIt(() => { });
+                },
+            });
+            await provider.connect();
+            await consumer.connect();
+            // 添加 1000 个任务
+            const startAdd = Date.now();
+            const data = Array.from({ length: 1000 }, (_, i) => ({ index: i }));
+            const taskIds = (await provider.enqueue(data));
+            const addTime = Date.now() - startAdd;
+            // 立即派发所有任务
+            const startDispatch = Date.now();
+            await dispatchQueueTask(consumer, taskIds);
+            const dispatchTime = Date.now() - startDispatch;
+            // 验证处理完成
+            expect(processedCount).toBe(1000);
+            console.log(`Performance test: Add ${addTime}ms, Dispatch ${dispatchTime}ms`);
+            provider.disconnect();
+            await consumer.disconnect();
+        }, 30000); // 30秒超时
+    });
+    describe('waitQueueCompletion', () => {
+        let provider;
+        let consumer;
+        beforeEach(async () => {
+            const queueKey = `test:wait:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+            provider = new RedisQueueProvider(queueKey, { redisUrl: REDIS_URL });
+            consumer = new RedisQueueConsumer(queueKey, { redisUrl: REDIS_URL, handler: async (data) => catchIt(() => { }),
+            });
+            await provider.connect();
+            await consumer.connect();
+        });
+        afterEach(async () => {
+            await clearQueue(consumer);
+            provider.disconnect();
+            await consumer.disconnect();
+        });
+        it('应该等待队列完成所有任务', async () => {
+            // 添加任务
+            const taskIds = (await provider.enqueue([
+                { id: '1' },
+                { id: '2' },
+                { id: '3' },
+            ]));
+            // consumer.connect() 已经启动了轮询，等待所有任务完成
+            await waitQueueCompletion(consumer, stats => stats.pending === 0 && stats.processing === 0 && stats.completed === 3);
+            const stats = await consumer.statistics();
+            expect(stats.completed).toBe(3);
+            expect(stats.pending).toBe(0);
+        });
+        it('应该支持自定义超时时间', async () => {
+            // 添加一个任务但不启动消费
+            await provider.enqueue({ id: '1' });
+            // 使用短超时，预期会超时失败
+            await expect(waitQueueCompletion(consumer, stats => stats.completed === 1, { timeout: 100, interval: 10 })).rejects.toThrow(/timeout/);
+        });
+        it('应该支持自定义检查间隔', async () => {
+            const taskIds = (await provider.enqueue([
+                { id: '1' },
+                { id: '2' },
+            ]));
+            const startTime = Date.now();
+            // 使用较长的检查间隔
+            await waitQueueCompletion(consumer, stats => stats.completed === 2, { interval: 500 });
+            // 验证使用了指定的间隔（至少等待了一些时间）
+            const elapsed = Date.now() - startTime;
+            expect(elapsed).toBeGreaterThan(0);
+        });
+        it('应该在条件立即满足时快速返回', async () => {
+            const startTime = Date.now();
+            // 条件已经满足（没有任务）
+            await waitQueueCompletion(consumer, stats => stats.pending === 0);
+            const elapsed = Date.now() - startTime;
+            expect(elapsed).toBeLessThan(200); // 应该很快返回
+        });
+    });
+    describe('clearQueue', () => {
+        let provider;
+        let consumer;
+        beforeEach(async () => {
+            const queueKey = `test:clear:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+            provider = new RedisQueueProvider(queueKey, { redisUrl: REDIS_URL });
+            consumer = new RedisQueueConsumer(queueKey, { redisUrl: REDIS_URL, handler: async (data) => catchIt(() => { }),
+            });
+            await provider.connect();
+            await consumer.connect();
+        });
+        afterEach(async () => {
+            provider.disconnect();
+            await consumer.disconnect();
+        });
+        it('应该清空队列中的所有任务', async () => {
+            // 添加多个任务
+            await provider.enqueue([
+                { id: '1' },
+                { id: '2' },
+                { id: '3' },
+            ]);
+            let stats = await consumer.statistics();
+            expect(stats.pending).toBe(3);
+            // 清空队列
+            await clearQueue(consumer);
+            stats = await consumer.statistics();
+            expect(stats.pending).toBe(0);
+            expect(stats.completed).toBe(0);
+            expect(stats.failed).toBe(0);
+        });
+        it('应该清空已完成的任务', async () => {
+            const taskIds = (await provider.enqueue([
+                { id: '1' },
+                { id: '2' },
+            ]));
+            // 处理任务
+            await dispatchQueueTask(consumer, taskIds);
+            let stats = await consumer.statistics();
+            expect(stats.completed).toBe(2);
+            // 清空队列
+            await clearQueue(consumer);
+            stats = await consumer.statistics();
+            expect(stats.completed).toBe(0);
+        });
+        it('应该处理空队列的情况', async () => {
+            // 队列本身就是空的
+            await expect(clearQueue(consumer)).resolves.not.toThrow();
+            const stats = await consumer.statistics();
+            expect(stats.pending).toBe(0);
+        });
+        it('应该处理断开连接的情况', async () => {
+            await consumer.disconnect();
+            // 断开连接后清空应该不报错
+            await expect(clearQueue(consumer)).resolves.not.toThrow();
+        });
+    });
+    describe('getQueueTasks', () => {
+        let provider;
+        let consumer;
+        beforeEach(async () => {
+            const queueKey = `test:get:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+            provider = new RedisQueueProvider(queueKey, { redisUrl: REDIS_URL });
+            consumer = new RedisQueueConsumer(queueKey, { redisUrl: REDIS_URL, maxRetries: 0,
+                handler: async (data) => {
+                    if (data.shouldFail) {
+                        throw new Error('Task failed');
+                    }
+                    return catchIt(() => { });
+                },
+            });
+            await provider.connect();
+            await consumer.connect();
+        });
+        afterEach(async () => {
+            await clearQueue(consumer);
+            provider.disconnect();
+            await consumer.disconnect();
+        });
+        it('应该获取所有待处理的任务', async () => {
+            await provider.enqueue([
+                { id: '1', name: 'task1' },
+                { id: '2', name: 'task2' },
+                { id: '3', name: 'task3' },
+            ]);
+            const tasks = await getQueueTasks(provider, 'pending');
+            expect(tasks).toHaveLength(3);
+            expect(tasks.map(t => t.data.id).sort()).toEqual(['1', '2', '3']);
+        });
+        it('应该获取已完成的任务', async () => {
+            const taskIds = (await provider.enqueue([
+                { id: '1' },
+                { id: '2' },
+            ]));
+            await dispatchQueueTask(consumer, taskIds);
+            const tasks = await getQueueTasks(provider, 'completed');
+            expect(tasks).toHaveLength(2);
+            expect(tasks.every(t => t.status === 'completed')).toBe(true);
+        });
+        it('应该获取失败的任务', async () => {
+            const taskIds = (await provider.enqueue([
+                { id: '1', shouldFail: true },
+                { id: '2', shouldFail: true },
+            ]));
+            await dispatchQueueTask(consumer, taskIds);
+            const tasks = await getQueueTasks(provider, 'failed');
+            expect(tasks).toHaveLength(2);
+            expect(tasks.every(t => t.status === 'failed')).toBe(true);
+        });
+        it('应该获取所有任务（不指定状态）', async () => {
+            // 添加待处理任务
+            await provider.enqueue([{ id: '1' }, { id: '2' }]);
+            // 添加并完成一些任务
+            const taskIds = (await provider.enqueue([
+                { id: '3' },
+                { id: '4' },
+            ]));
+            await dispatchQueueTask(consumer, taskIds);
+            // 获取所有任务
+            const allTasks = await getQueueTasks(provider);
+            expect(allTasks.length).toBeGreaterThanOrEqual(4);
+        });
+        it('应该验证任务数据完整性', async () => {
+            const testData = { id: '999', message: 'test', nested: { value: 42 } };
+            await provider.enqueue([testData]);
+            const tasks = await getQueueTasks(provider, 'pending');
+            expect(tasks).toHaveLength(1);
+            expect(tasks[0].data).toEqual(testData);
+            expect(tasks[0].id).toBeTruthy();
+            expect(tasks[0].retryCount).toBe(0);
+        });
+        it('应该处理空队列', async () => {
+            const tasks = await getQueueTasks(provider, 'pending');
+            expect(tasks).toEqual([]);
+        });
+        it('应该处理断开连接的情况', async () => {
+            provider.disconnect();
+            const tasks = await getQueueTasks(provider, 'pending');
+            expect(tasks).toEqual([]);
+        });
+    });
+    describe('dispatchQueueTask', () => {
+        let provider;
+        let consumer;
+        let queueKey;
+        const processedTasks = [];
+        beforeEach(async () => {
+            processedTasks.length = 0;
+            queueKey = `test:dispatch:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+            provider = new RedisQueueProvider(queueKey, { redisUrl: REDIS_URL });
+            consumer = new RedisQueueConsumer(queueKey, { redisUrl: REDIS_URL, handler: async (data) => {
+                    processedTasks.push(data);
+                    return catchIt(() => { });
+                },
+            });
+            await provider.connect();
+            await consumer.connect();
+        });
+        afterEach(async () => {
+            await clearQueue(consumer);
+            provider.disconnect();
+            await consumer.disconnect();
+        });
+        it('应该立即派发单个任务', async () => {
+            const taskId = await provider.enqueue({ message: 'test task' });
+            await dispatchQueueTask(consumer, [taskId]);
+            expect(processedTasks).toHaveLength(1);
+            expect(processedTasks[0]).toEqual({ message: 'test task' });
+            const stats = await consumer.statistics();
+            expect(stats.completed).toBe(1);
+            expect(stats.pending).toBe(0);
+        });
+        it('应该立即派发多个任务', async () => {
+            const taskIds = (await provider.enqueue([
+                { id: '1' },
+                { id: '2' },
+                { id: '3' },
+            ]));
+            await dispatchQueueTask(consumer, taskIds);
+            expect(processedTasks).toHaveLength(3);
+            expect(processedTasks.map(t => t.id).sort()).toEqual(['1', '2', '3']);
+            const stats = await consumer.statistics();
+            expect(stats.completed).toBe(3);
+        });
+        it('应该处理任务失败和重试', async () => {
+            let attemptCount = 0;
+            const failingConsumer = new RedisQueueConsumer(queueKey, { redisUrl: REDIS_URL, maxRetries: 2,
+                handler: async (data) => {
+                    attemptCount++;
+                    // 前2次失败,第3次成功
+                    if (attemptCount < 3) {
+                        throw new Error('Simulated failure');
+                    }
+                    processedTasks.push(data);
+                    return catchIt(() => { });
+                },
+            });
+            await failingConsumer.connect();
+            const taskId = await provider.enqueue({ test: 'retry' });
+            await dispatchQueueTask(failingConsumer, [taskId]);
+            // maxRetries=2 意味着: 1次初始尝试 + 最多2次重试 = 最多3次尝试
+            // 第3次成功,所以 attemptCount 应该是 3
+            expect(attemptCount).toBe(3);
+            expect(processedTasks).toHaveLength(1);
+            await clearQueue(failingConsumer);
+            await failingConsumer.disconnect();
+        });
+        it('应该忽略不存在的任务ID', async () => {
+            const realTaskId = await provider.enqueue({ real: true });
+            const fakeTaskId = 'non-existent-task-id';
+            await dispatchQueueTask(consumer, [realTaskId, fakeTaskId]);
+            expect(processedTasks).toHaveLength(1);
+            expect(processedTasks[0]).toEqual({ real: true });
+        });
+        it('应该处理空任务列表', async () => {
+            await expect(dispatchQueueTask(consumer, [])).resolves.not.toThrow();
+            expect(processedTasks).toHaveLength(0);
+        });
+    });
+    describe('Integration: 组合使用测试工具', () => {
+        it('应该支持完整的测试工作流', async () => {
+            // 1. 创建唯一队列名
+            const testQueue = `test:integration:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+            // 2. 初始化 provider 和 consumer
+            const provider = new RedisQueueProvider(testQueue, { redisUrl: REDIS_URL });
+            const processedData = [];
+            const consumer = new RedisQueueConsumer(testQueue, { redisUrl: REDIS_URL, handler: async (data) => {
+                    processedData.push(data);
+                    return catchIt(() => { });
+                },
+            });
+            await provider.connect();
+            await consumer.connect();
+            try {
+                // 3. 添加任务
+                const taskIds = (await provider.enqueue([
+                    { step: 1 },
+                    { step: 2 },
+                    { step: 3 },
+                ]));
+                // 4. 验证待处理任务
+                const pendingTasks = await getQueueTasks(provider, 'pending');
+                expect(pendingTasks).toHaveLength(3);
+                // 5. 立即派发任务
+                await dispatchQueueTask(consumer, taskIds);
+                // 6. 验证完成任务
+                const completedTasks = await getQueueTasks(provider, 'completed');
+                expect(completedTasks).toHaveLength(3);
+                expect(processedData).toHaveLength(3);
+                // 7. 清理队列
+                await clearQueue(consumer);
+                // 8. 验证清理结果
+                const stats = await consumer.statistics();
+                expect(stats.pending).toBe(0);
+                expect(stats.completed).toBe(0);
+            }
+            finally {
+                provider.disconnect();
+                await consumer.disconnect();
+            }
+        });
+    });
+    describe('性能测试示例', () => {
+        it('应该快速完成大量任务测试', async () => {
+            const queueKey = `test:perf2:${Date.now()}:${Math.random().toString(36).slice(2, 9)}`;
+            const provider = new RedisQueueProvider(queueKey, { redisUrl: REDIS_URL });
+            let processedCount = 0;
+            const consumer = new RedisQueueConsumer(queueKey, { redisUrl: REDIS_URL, handler: async () => {
+                    processedCount++;
+                    return catchIt(() => { });
+                },
+            });
+            await provider.connect();
+            await consumer.connect();
+            const startAdd = Date.now();
+            const data = Array.from({ length: 1000 }, (_, i) => ({ index: i }));
+            const taskIds = (await provider.enqueue(data));
+            const addTime = Date.now() - startAdd;
+            const startDispatch = Date.now();
+            await dispatchQueueTask(consumer, taskIds);
+            const dispatchTime = Date.now() - startDispatch;
+            expect(processedCount).toBe(1000);
+            console.log(`Performance test: Add ${addTime}ms, Dispatch ${dispatchTime}ms`);
+            await clearQueue(consumer);
+            provider.disconnect();
+            await consumer.disconnect();
+        }, 30000);
+    });
+});

package/output/redis-queue/types.d.ts CHANGED Viewed

@@ -32,9 +32,6 @@ import type { RedisClientType } from 'redis';
  * ```
  */
 export interface RedisQueueRegistry {
-    'test': {
-        example: string;
-    };
 }
 /**
  * 任务状态
@@ -75,7 +72,6 @@ export interface QueueStats {
 export interface RedisQueueCommonConfig {
     redisUrl?: string;
     redisClient?: RedisClientType;
-    queueKey: keyof RedisQueueRegistry;
     cleanupDelay?: number;
 }
 /**
@@ -84,7 +80,6 @@ export interface RedisQueueCommonConfig {
 export interface RedisQueueProviderConfig<K extends keyof RedisQueueRegistry = keyof RedisQueueRegistry> {
     redisUrl?: string;
     redisClient?: RedisClientType;
-    queueKey: K;
     cleanupDelay?: number;
     processingDelay?: number;
 }
@@ -94,7 +89,6 @@ export interface RedisQueueProviderConfig<K extends keyof RedisQueueRegistry = k
 export interface RedisQueueConsumerConfig<K extends keyof RedisQueueRegistry> {
     redisUrl?: string;
     redisClient?: RedisClientType;
-    queueKey: K;
     handler: TaskHandler<RedisQueueRegistry[K]>;
     maxRetries?: number;
     concurrency?: number;
@@ -112,7 +106,6 @@ export type TaskHandler<T extends TaskData = TaskData> = (data: T) => Promise<Ca
 export interface BatchConsumerConfig<K extends keyof RedisQueueRegistry> {
     redisUrl?: string;
     redisClient?: RedisClientType;
-    queueKey: K;
     handler: BatchTaskHandler<RedisQueueRegistry[K]>;
     batchSize?: number;
     maxRetries?: number;

package/output/redis-queue/types.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/redis-queue/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,OAAO,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,MAAM,WAAW,kBAAkB;~~IAEjC,MAAM,EAAE~~;~~QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CAC5B;~~AAED;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,QAAQ,CAAA;AAEtE;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IAAE,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,CAAA;AAE1D;;GAEG;AACH,MAAM,WAAW,IAAI,CAAC,CAAC,GAAG,QAAQ;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,CAAC,CAAA;IACP,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B,~~QAAQ,EAAE,MAAM,kBAAkB,CAAA;IAClC,~~YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB,CAAC,CAAC,SAAS,MAAM,kBAAkB,GAAG,MAAM,kBAAkB;IACrG,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B,~~QAAQ,EAAE,CAAC,CAAA;IACX,~~YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB,CAAC,CAAC,SAAS,MAAM,kBAAkB;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B,~~QAAQ,EAAE,CAAC,CAAA;IACX,~~OAAO,EAAE,WAAW,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAA;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAA;AAE3G;;GAEG;AACH,MAAM,WAAW,mBAAmB,CAAE,CAAC,SAAS,MAAM,kBAAkB;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B,~~QAAQ,EAAE,CAAC,CAAA;IACX,~~OAAO,EAAE,gBAAgB,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAA;IAChD,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAAA"}
1	+ {"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/redis-queue/types.ts"],"names":[],"mappings":"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"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@taicode/common-server",
-  "version": "1.0.13",
+  "version": "1.0.14",
   "author": "Alain",
   "license": "ISC",
   "description": "",
@@ -29,14 +29,16 @@
   ],
   "peerDependencies": {
     "@taicode/common-base": "^1.7.0",
+    "bullmq": "^5.34.0",
     "fastify": "^5.5.0",
-    "redis": "^4.7.0",
+    "ioredis": "^5.4.2",
     "zod": "^4.1.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
+    "bullmq": "^5.65.0",
     "fastify": "^5.5.0",
-    "redis": "^4.7.1",
+    "ioredis": "^5.8.2",
     "vitest": "^3.2.4",
     "zod": "^4.1.0"
   }