@taicode/common-server 1.0.13 → 1.0.14

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

@@ -9,14 +9,8 @@ import { RedisQueueCommon } from './redis-queue-common';
  *
  * @example
  * ```ts
- * interface EmailTask {
- *   to: string
- *   subject: string
- * }
- *
- * const consumer = new RedisQueueConsumer<EmailTask>({
+ * const consumer = new RedisQueueConsumer('email-queue', {
  *   redisUrl: 'redis://localhost:6379',
- *   queueKey: 'email-queue',
  *   concurrency: 5,
  *   handler: async (data) => {
  *     await sendEmail(data.to, data.subject)
@@ -38,24 +32,21 @@ export class RedisQueueConsumer extends RedisQueueCommon {
     consumerInterval = null;
     recoveryInterval = null;
     processingTasks = 0; // 当前正在处理的任务数
+    processingPromises = new Set(); // 跟踪所有正在处理的任务
     config;
-    constructor(config) {
+    constructor(queueKey, config) {
         // 验证必填参数
         if (!config.handler) {
             throw new Error('[RedisQueueConsumer] handler is required');
         }
         // 调用父类构造函数
-        super({
+        super(queueKey, {
             redisUrl: config.redisUrl,
             redisClient: config.redisClient,
-            queueKey: config.queueKey,
             cleanupDelay: config.cleanupDelay ?? 86400,
         });
         this.config = {
             handler: config.handler,
-            queueKey: config.queueKey,
-            redisUrl: config.redisUrl,
-            redisClient: config.redisClient,
             maxRetries: config.maxRetries ?? 3,
             concurrency: config.concurrency ?? 1,
             consumerInterval: config.consumerInterval ?? 1000,
@@ -77,10 +68,19 @@ export class RedisQueueConsumer extends RedisQueueCommon {
     }
     /**
      * 断开 Redis 连接并停止消费者
+     * 会等待所有正在处理的任务完成后再断开连接
      */
-    disconnect() {
+    async disconnect() {
+        // 先停止消费者和恢复机制，不再接受新任务
         this.stopConsumer();
         this.stopRecovery();
+        // 等待所有正在处理的任务完成
+        if (this.processingPromises.size > 0) {
+            console.log(`[RedisQueueConsumer] Waiting for ${this.processingPromises.size} tasks to complete...`);
+            await Promise.allSettled(this.processingPromises);
+            console.log(`[RedisQueueConsumer] All tasks completed`);
+        }
+        // 最后断开 Redis 连接
         super.disconnect();
     }
     /**
@@ -88,73 +88,84 @@ export class RedisQueueConsumer extends RedisQueueCommon {
      */
     async processTask(taskId) {
         this.processingTasks++;
-        try {
-            const task = await this.getTask(taskId);
-            if (!task) {
-                console.warn(`[RedisQueueConsumer] Task not found: ${taskId}`);
-                return;
-            }
-            // 任务应该是 pending 状态(Lua 脚本已确保延迟检查)
-            if (task.status !== 'pending') {
-                console.log(`[RedisQueueConsumer] Task ${taskId} has invalid status (${task.status}), marking as failed`);
-                await this.applyStatus(taskId, task.status, 'failed');
-                return;
-            }
+        // 创建一个 Promise 来跟踪这个任务的处理过程
+        const taskPromise = (async () => {
             try {
-                // 任务已在 processing 队列中(由 Lua 脚本完成),只需更新状态和开始时间
-                task.status = 'processing';
-                task.processingStartTime = Date.now();
-                const taskKey = `${this.config.queueKey}:task:${taskId}`;
-                await this.redis.setEx(taskKey, this.config.cleanupDelay, JSON.stringify(task));
-                // 执行任务处理器
-                await this.config.handler(task.data);
-                // 更新状态为完成
-                await this.applyStatus(taskId, 'processing', 'completed');
-                console.log(`[RedisQueueConsumer] Task completed: ${taskId}`);
-            }
-            catch (error) {
-                console.error(`[RedisQueueConsumer] Task failed: ${taskId}`, error);
-                // 检查是否需要重试
-                if (task.retryCount < task.maxRetries) {
-                    task.retryCount++;
-                    task.status = 'pending';
-                    task.processingStartTime = undefined;
-                    const taskKey = `${this.config.queueKey}:task:${taskId}`;
-                    // 使用 Lua 脚本确保原子性
-                    const script = `
+                const task = await this.getTask(taskId);
+                if (!task) {
+                    console.warn(`[RedisQueueConsumer] Task not found: ${taskId}`);
+                    return;
+                }
+                // 任务应该是 pending 状态(Lua 脚本已确保延迟检查)
+                if (task.status !== 'pending') {
+                    console.log(`[RedisQueueConsumer] Task ${taskId} has invalid status (${task.status}), marking as failed`);
+                    await this.applyStatus(taskId, task.status, 'failed');
+                    return;
+                }
+                try {
+                    // 任务已在 processing 队列中(由 Lua 脚本完成),只需更新状态和开始时间
+                    task.status = 'processing';
+                    task.processingStartTime = Date.now();
+                    const taskKey = `${this.queueKey}:task:${taskId}`;
+                    await this.redis.setEx(taskKey, this.config.cleanupDelay, JSON.stringify(task));
+                    // 执行任务处理器
+                    await this.config.handler(task.data);
+                    // 更新状态为完成
+                    await this.applyStatus(taskId, 'processing', 'completed');
+                    console.log(`[RedisQueueConsumer] Task completed: ${taskId}`);
+                }
+                catch (error) {
+                    console.error(`[RedisQueueConsumer] Task failed: ${taskId}`, error);
+                    // 检查是否需要重试
+                    if (task.retryCount < task.maxRetries) {
+                        task.retryCount++;
+                        task.status = 'pending';
+                        task.processingStartTime = undefined;
+                        const taskKey = `${this.queueKey}:task:${taskId}`;
+                        // 使用 Lua 脚本确保原子性
+                        const script = `
             redis.call('SETEX', KEYS[1], ARGV[1], ARGV[2])
             redis.call('LREM', KEYS[2], 0, ARGV[3])
             redis.call('RPUSH', KEYS[3], ARGV[3])
             return 1
           `;
-                    await this.redis.eval(script, {
-                        keys: [taskKey, this.processingQueue, this.pendingQueue],
-                        arguments: [this.config.cleanupDelay.toString(), JSON.stringify(task), taskId],
-                    });
-                    console.log(`[RedisQueueConsumer] Task ${taskId} will retry (${task.retryCount}/${task.maxRetries})`);
-                }
-                else {
-                    task.status = 'failed';
-                    task.processingStartTime = undefined;
-                    const taskKey = `${this.config.queueKey}:task:${taskId}`;
-                    // 使用 Lua 脚本确保原子性
-                    const script = `
+                        await this.redis.eval(script, {
+                            keys: [taskKey, this.processingQueue, this.pendingQueue],
+                            arguments: [this.config.cleanupDelay.toString(), JSON.stringify(task), taskId],
+                        });
+                        console.log(`[RedisQueueConsumer] Task ${taskId} will retry (${task.retryCount}/${task.maxRetries})`);
+                    }
+                    else {
+                        task.status = 'failed';
+                        task.processingStartTime = undefined;
+                        const taskKey = `${this.queueKey}:task:${taskId}`;
+                        // 使用 Lua 脚本确保原子性
+                        const script = `
             redis.call('SETEX', KEYS[1], ARGV[1], ARGV[2])
             redis.call('LREM', KEYS[2], 0, ARGV[3])
             redis.call('RPUSH', KEYS[3], ARGV[3])
             return 1
           `;
-                    await this.redis.eval(script, {
-                        keys: [taskKey, this.processingQueue, this.failedQueue],
-                        arguments: [this.config.cleanupDelay.toString(), JSON.stringify(task), taskId],
-                    });
-                    console.error(`[RedisQueueConsumer] Task ${taskId} failed after ${task.maxRetries} retries`);
+                        await this.redis.eval(script, {
+                            keys: [taskKey, this.processingQueue, this.failedQueue],
+                            arguments: [this.config.cleanupDelay.toString(), JSON.stringify(task), taskId],
+                        });
+                        console.error(`[RedisQueueConsumer] Task ${taskId} failed after ${task.maxRetries} retries`);
+                    }
                 }
             }
-        }
-        finally {
-            this.processingTasks--;
-        }
+            finally {
+                this.processingTasks--;
+            }
+        })();
+        // 将任务 Promise 添加到集合中
+        this.processingPromises.add(taskPromise);
+        // 任务完成后从集合中移除
+        taskPromise.finally(() => {
+            this.processingPromises.delete(taskPromise);
+        });
+        // 返回任务 Promise
+        return taskPromise;
     }
     /**
      * 启动恢复机制（内部方法，自动调用）
@@ -244,7 +255,7 @@ export class RedisQueueConsumer extends RedisQueueCommon {
                 }
                 // 使用 Lua 脚本原子化取出任务并移到 processing 队列
                 const taskIds = await this.redis.eval(popAndMoveScript, {
-                    keys: [this.pendingQueue, this.processingQueue, this.config.queueKey],
+                    keys: [this.pendingQueue, this.processingQueue, this.queueKey],
                     arguments: [availableSlots.toString(), Date.now().toString()],
                 });
                 // 并发处理所有任务（不等待完成）

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

@@ -1,6 +1,25 @@
+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;
+    data?: any;
+};
 declare module './types' {
     interface RedisQueueRegistry {
-        'test-queue': Record<string, any>;
+        [key: `test:queue:${string}`]: TestTaskData;
     }
 }
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"redis-queue-consumer.test.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-consumer.test.ts"],"names":[],"mappings":"AAOA,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAU,kBAAkB;QAC1B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAClC;CACF"}
+{"version":3,"file":"redis-queue-consumer.test.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-consumer.test.ts"],"names":[],"mappings":"AAQA,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,IAAI,CAAC,EAAE,GAAG,CAAA;CACX,CAAA;AAGD,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAU,kBAAkB;QAC1B,CAAC,GAAG,EAAE,cAAc,MAAM,EAAE,GAAG,YAAY,CAAA;KAC5C;CACF"}

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

@@ -2,21 +2,17 @@ import { describe, it, expect, afterEach } from 'vitest';
 import { catchIt } from '@taicode/common-base';
 import { RedisQueueProvider } from './redis-queue-provider';
 import { RedisQueueConsumer } from './redis-queue-consumer';
+import { dispatchQueueTask, waitQueueCompletion, clearQueue, getQueueTasks } from './test-helpers';
 const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
 describe('RedisQueueConsumer', () => {
     const providers = [];
     const consumers = [];
     afterEach(async () => {
         for (const consumer of consumers) {
-            consumer.disconnect();
+            await clearQueue(consumer);
+            await consumer.disconnect();
         }
         for (const provider of providers) {
-            try {
-                await provider.clear();
-            }
-            catch (error) {
-                // 忽略清理错误
-            }
             provider.disconnect();
         }
         providers.length = 0;
@@ -24,13 +20,11 @@ describe('RedisQueueConsumer', () => {
     });
     const createQueue = (handler, options) => {
         const uniqueKey = `test:queue:${Date.now()}:${Math.random()}`;
-        const provider = new RedisQueueProvider({
+        const provider = new RedisQueueProvider(uniqueKey, {
             redisUrl: REDIS_URL,
-            queueKey: uniqueKey,
         });
-        const consumer = new RedisQueueConsumer({
+        const consumer = new RedisQueueConsumer(uniqueKey, {
             redisUrl: REDIS_URL,
-            queueKey: uniqueKey,
             consumerInterval: 100,
             maxRetries: 2,
             ...options,
@@ -76,10 +70,28 @@ describe('RedisQueueConsumer', () => {
             const stats = await consumer.statistics();
             expect(stats.completed).toBe(1);
         });
+        it('应该能够使用 dispatchQueueTask 立即处理任务', async () => {
+            const processedData = [];
+            const { provider, consumer } = createQueue(async (data) => {
+                processedData.push(data);
+                return catchIt(() => { });
+            });
+            await provider.connect();
+            await consumer.connect();
+            const taskIds = await provider.enqueue([{ value: 1 }, { value: 2 }, { value: 3 }]);
+            // 使用 dispatchQueueTask 立即处理任务
+            await dispatchQueueTask(consumer, taskIds);
+            expect(processedData).toHaveLength(3);
+            expect(processedData.map(d => d.value)).toEqual([1, 2, 3]);
+            const stats = await consumer.statistics();
+            expect(stats.completed).toBe(3);
+        });
         it('应该按 FIFO 顺序处理任务', async () => {
             const processOrder = [];
             const { provider, consumer } = createQueue(async (data) => {
-                processOrder.push(data.order);
+                if (data.order !== undefined) {
+                    processOrder.push(data.order);
+                }
                 return catchIt(() => { });
             });
             await provider.connect();
@@ -88,6 +100,35 @@ describe('RedisQueueConsumer', () => {
             await new Promise(resolve => setTimeout(resolve, 1000));
             expect(processOrder).toEqual([1, 2, 3]);
         });
+        it('应该能够使用 waitQueueCompletion 等待队列完成', async () => {
+            const { provider, consumer } = createQueue(async () => {
+                await new Promise(resolve => setTimeout(resolve, 100));
+                return catchIt(() => { });
+            });
+            await provider.connect();
+            await consumer.connect();
+            await provider.enqueue([{ test: 1 }, { test: 2 }, { test: 3 }]);
+            // 等待所有任务完成
+            await waitQueueCompletion(consumer, stats => stats.pending === 0 && stats.processing === 0 && stats.completed === 3);
+            const stats = await consumer.statistics();
+            expect(stats.completed).toBe(3);
+        });
+        it('应该能够使用 getQueueTasks 获取任务详情', async () => {
+            const { provider, consumer } = createQueue(async () => catchIt(() => { }));
+            await provider.connect();
+            await consumer.connect();
+            await provider.enqueue([{ name: 'task1' }, { name: 'task2' }]);
+            // 获取待处理任务
+            const pendingTasks = await getQueueTasks(provider, 'pending');
+            expect(pendingTasks).toHaveLength(2);
+            expect(pendingTasks.map(t => t.data.name).sort()).toEqual(['task1', 'task2']);
+            // 等待任务完成
+            await waitQueueCompletion(consumer, stats => stats.completed === 2);
+            // 获取已完成任务
+            const completedTasks = await getQueueTasks(provider, 'completed');
+            expect(completedTasks).toHaveLength(2);
+            expect(completedTasks.every(t => t.status === 'completed')).toBe(true);
+        });
     });
     describe('重试机制', () => {
         it('失败的任务应该自动重试', async () => {
@@ -119,12 +160,41 @@ describe('RedisQueueConsumer', () => {
             await provider.enqueue({ test: 1 });
             await new Promise(resolve => setTimeout(resolve, 300));
             expect(processCount).toBe(1);
-            consumer.disconnect();
+            await consumer.disconnect();
             await provider.connect();
             await provider.enqueue({ test: 2 });
             await new Promise(resolve => setTimeout(resolve, 300));
             expect(processCount).toBe(1); // 没有增加
         });
+        it('disconnect 应该等待正在处理的任务完成', async () => {
+            const processedTasks = [];
+            let processingTask = null;
+            const { provider, consumer } = createQueue(async (data) => {
+                processingTask = data.taskId || 0;
+                await new Promise(resolve => setTimeout(resolve, 500)); // 模拟长时间处理
+                processedTasks.push(data.taskId || 0);
+                processingTask = null;
+                return catchIt(() => { });
+            });
+            await provider.connect();
+            await consumer.connect();
+            // 添加一个任务
+            await provider.enqueue({ taskId: 1 });
+            // 等待任务开始处理
+            await new Promise(resolve => setTimeout(resolve, 200));
+            expect(processingTask).toBe(1);
+            expect(processedTasks).toHaveLength(0);
+            // 调用 disconnect，应该等待任务完成
+            const disconnectPromise = consumer.disconnect();
+            // 此时任务应该还在处理中
+            expect(processingTask).toBe(1);
+            // 等待 disconnect 完成
+            await disconnectPromise;
+            // disconnect 完成后，任务应该已经处理完成
+            expect(processingTask).toBe(null);
+            expect(processedTasks).toHaveLength(1);
+            expect(processedTasks[0]).toBe(1);
+        });
     });
     describe('队列统计', () => {
         it('应该正确返回队列统计信息', async () => {
@@ -145,9 +215,13 @@ describe('RedisQueueConsumer', () => {
             const processing = [];
             const completed = [];
             const { provider, consumer } = createQueue(async (data) => {
-                processing.push(data.taskId);
+                if (data.taskId !== undefined) {
+                    processing.push(data.taskId);
+                }
                 await new Promise(resolve => setTimeout(resolve, 200));
-                completed.push(data.taskId);
+                if (data.taskId !== undefined) {
+                    completed.push(data.taskId);
+                }
                 return catchIt(() => { });
             }, { concurrency: 3 });
             await provider.connect();

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

@@ -10,8 +10,8 @@ import type { RedisQueueRegistry, RedisQueueProviderConfig, Task, QueueStats } f
  * @example
  * ```ts
  * // 注册类型后使用
- * const provider = new RedisQueueProvider({
- *   queueKey: 'email-queue', // 只能使用注册的键
+ * const provider = new RedisQueueProvider('email-queue', {
+ *   redisUrl: 'redis://localhost:6379'
  * })
  *
  * await provider.enqueue({
@@ -23,7 +23,7 @@ import type { RedisQueueRegistry, RedisQueueProviderConfig, Task, QueueStats } f
  */
 export declare class RedisQueueProvider<K extends keyof RedisQueueRegistry> extends RedisQueueCommon {
     private readonly processingDelay;
-    constructor(config: RedisQueueProviderConfig<K>);
+    constructor(queueKey: K, config?: RedisQueueProviderConfig<K>);
     protected getLogPrefix(): string;
     /**
      * 将任务推入队列(支持单个或批量)
@@ -37,8 +37,8 @@ export declare class RedisQueueProvider<K extends keyof RedisQueueRegistry> exte
      * await provider.enqueue({ id: 'email-123', to: 'user@example.com' })
      * await provider.enqueue({ id: 'email-123', to: 'user@example.com' }) // 会被跳过
      */
+    enqueue(data: RedisQueueRegistry[K][]): Promise<string[]>;
     enqueue(data: RedisQueueRegistry[K]): Promise<string>;
-    enqueue(data: RedisQueueRegistry[K]): Promise<string[]>;
     /**
      * 获取任务详情
      */

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

@@ -1 +1 @@
-{"version":3,"file":"redis-queue-provider.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-provider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAE7F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,kBAAkB,CAAC,CAAC,SAAS,MAAM,kBAAkB,CAAE,SAAQ,gBAAgB;IAC1F,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAQ;gBAE5B,MAAM,EAAE,wBAAwB,CAAC,CAAC,CAAC;IAW/C,SAAS,CAAC,YAAY,IAAI,MAAM;IAMhC;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IACrD,OAAO,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAiF7D;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAW1E;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAevC;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAmD7B"}
+{"version":3,"file":"redis-queue-provider.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-provider.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,wBAAwB,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAE7F;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qBAAa,kBAAkB,CAAC,CAAC,SAAS,MAAM,kBAAkB,CAAE,SAAQ,gBAAgB;IAC1F,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAQ;gBAE5B,QAAQ,EAAE,CAAC,EAAE,MAAM,GAAE,wBAAwB,CAAC,CAAC,CAAM;IAUjE,SAAS,CAAC,YAAY,IAAI,MAAM;IAMhC;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IACzD,OAAO,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IA0F3D;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAW1E;;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

@@ -10,8 +10,8 @@ import { RedisQueueCommon } from './redis-queue-common';
  * @example
  * ```ts
  * // 注册类型后使用
- * const provider = new RedisQueueProvider({
- *   queueKey: 'email-queue', // 只能使用注册的键
+ * const provider = new RedisQueueProvider('email-queue', {
+ *   redisUrl: 'redis://localhost:6379'
  * })
  *
  * await provider.enqueue({
@@ -23,11 +23,10 @@ import { RedisQueueCommon } from './redis-queue-common';
  */
 export class RedisQueueProvider extends RedisQueueCommon {
     processingDelay;
-    constructor(config) {
-        super({
+    constructor(queueKey, config = {}) {
+        super(queueKey, {
             redisUrl: config.redisUrl,
             redisClient: config.redisClient,
-            queueKey: config.queueKey,
             cleanupDelay: config.cleanupDelay,
         });
         this.processingDelay = config.processingDelay ?? 0; // 默认立即执行
@@ -47,6 +46,11 @@ export class RedisQueueProvider extends RedisQueueCommon {
         // 准备任务数据
         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,
@@ -86,7 +90,7 @@ export class RedisQueueProvider extends RedisQueueCommon {
       
       return successCount
     `;
-        // 构建参数数组
+        // 构建参数数组 - Redis 要求所有参数都是字符串
         const args = [this.cleanupDelay.toString(), this.queueKey];
         for (let i = 0; i < tasks.length; i++) {
             args.push(taskIds[i]);

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

@@ -1,6 +1,27 @@
-declare module './types' {
+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" {
     interface RedisQueueRegistry {
-        'test-queue': Record<string, any>;
+        [key: `test:provider:${string}`]: TestTaskData;
     }
 }
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"redis-queue-provider.test.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-provider.test.ts"],"names":[],"mappings":"AAKA,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAU,kBAAkB;QAC1B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAClC;CACF"}
+{"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,SAAS,CAAC;IACvB,UAAU,kBAAkB;QAC1B,CAAC,GAAG,EAAE,iBAAiB,MAAM,EAAE,GAAG,YAAY,CAAA;KAC/C;CACF"}