@taicode/common-server 1.0.10 → 1.0.12

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

@@ -0,0 +1,216 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { catchIt } from '@taicode/common-base';
+import { RedisQueueProvider } from './redis-queue-provider';
+import { RedisBatchConsumer } from './batch-consumer';
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+describe('RedisBatchConsumer', () => {
+    const providers = [];
+    const consumers = [];
+    afterEach(async () => {
+        for (const consumer of consumers) {
+            consumer.disconnect();
+        }
+        for (const provider of providers) {
+            try {
+                await provider.clear();
+            }
+            catch (error) {
+                // 忽略清理错误
+            }
+            provider.disconnect();
+        }
+        providers.length = 0;
+        consumers.length = 0;
+    });
+    const createQueue = (handler, options) => {
+        const uniqueKey = `test:batch:${Date.now()}:${Math.random()}`;
+        const provider = new RedisQueueProvider({
+            redisUrl: REDIS_URL,
+            queueKey: uniqueKey,
+        });
+        const consumer = new RedisBatchConsumer({
+            redisUrl: REDIS_URL,
+            queueKey: uniqueKey,
+            consumerInterval: 100,
+            maxRetries: 2,
+            batchSize: 10,
+            ...options,
+            handler,
+        });
+        providers.push(provider);
+        consumers.push(consumer);
+        return { provider, consumer };
+    };
+    describe('连接管理', () => {
+        it('应该成功连接到 Redis', async () => {
+            const { consumer } = createQueue(async () => catchIt(() => { }));
+            await consumer.connect();
+            const health = await consumer.health();
+            expect(health).toBe(true);
+        });
+        it('连接后应该自动启动消费者', async () => {
+            let processed = false;
+            const { provider, consumer } = createQueue(async () => {
+                processed = true;
+                return catchIt(() => { });
+            });
+            await provider.connect();
+            await consumer.connect();
+            await provider.enqueue({ test: true });
+            await new Promise(resolve => setTimeout(resolve, 300));
+            expect(processed).toBe(true);
+        });
+    });
+    describe('批量处理', () => {
+        it('应该批量处理任务', async () => {
+            let batchSize = 0;
+            const { provider, consumer } = createQueue(async (dataList) => {
+                batchSize = dataList.length;
+                return catchIt(() => { });
+            }, { batchSize: 5 });
+            await provider.connect();
+            await consumer.connect();
+            await provider.enqueue([
+                { value: 1 }, { value: 2 }, { value: 3 },
+                { value: 4 }, { value: 5 },
+            ]);
+            await new Promise(resolve => setTimeout(resolve, 500));
+            expect(batchSize).toBe(5);
+            const stats = await consumer.statistics();
+            expect(stats.completed).toBe(5);
+        });
+        it('应该能处理大批量任务', async () => {
+            let totalProcessed = 0;
+            const { provider, consumer } = createQueue(async (dataList) => {
+                totalProcessed += dataList.length;
+                return catchIt(() => { });
+            }, { batchSize: 50 });
+            await provider.connect();
+            await consumer.connect();
+            const tasks = Array.from({ length: 200 }, (_, i) => ({ value: i }));
+            await provider.enqueue(tasks);
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            expect(totalProcessed).toBe(200);
+        });
+    });
+    describe('重试机制', () => {
+        it('失败的批次应该重试', async () => {
+            let attemptCount = 0;
+            const { provider, consumer } = createQueue(async () => {
+                attemptCount++;
+                throw new Error('Batch failed');
+            }, { batchSize: 2, maxRetries: 1 });
+            await provider.connect();
+            await consumer.connect();
+            await provider.enqueue([{ value: 1 }, { value: 2 }]);
+            await new Promise(resolve => setTimeout(resolve, 2500));
+            const stats = await consumer.statistics();
+            expect(stats.failed).toBe(2);
+        });
+    });
+    describe('幂等性', () => {
+        it('应该支持在 data 中指定 id 来实现幂等性', async () => {
+            let processCount = 0;
+            const { provider, consumer } = createQueue(async (dataList) => {
+                processCount += dataList.length;
+                return catchIt(() => { });
+            }, { batchSize: 10 });
+            await provider.connect();
+            await consumer.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 });
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            expect(processCount).toBe(2); // 只处理 unique-1 和 unique-2
+        });
+    });
+    describe('延迟处理', () => {
+        it('应该支持延迟处理任务', async () => {
+            const startTime = Date.now();
+            let processTime = 0;
+            const { provider, consumer } = createQueue(async () => {
+                processTime = Date.now() - startTime;
+                return catchIt(() => { });
+            });
+            await provider.connect();
+            await consumer.connect();
+            await provider.enqueue({ test: true });
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            expect(processTime).toBeGreaterThan(0);
+        });
+    });
+    describe('并发安全', () => {
+        it('多个消费者实例应该能协同工作', async () => {
+            let consumer1Count = 0;
+            let consumer2Count = 0;
+            const uniqueKey = `test:batch:concurrent:${Date.now()}:${Math.random()}`;
+            const provider = new RedisQueueProvider({
+                redisUrl: REDIS_URL,
+                queueKey: uniqueKey,
+            });
+            const consumer1 = new RedisBatchConsumer({
+                redisUrl: REDIS_URL,
+                queueKey: uniqueKey,
+                batchSize: 5,
+                handler: async (dataList) => {
+                    consumer1Count += dataList.length;
+                    return catchIt(() => { });
+                },
+            });
+            const consumer2 = new RedisBatchConsumer({
+                redisUrl: REDIS_URL,
+                queueKey: uniqueKey,
+                batchSize: 5,
+                handler: async (dataList) => {
+                    consumer2Count += dataList.length;
+                    return catchIt(() => { });
+                },
+            });
+            providers.push(provider);
+            consumers.push(consumer1, consumer2);
+            await provider.connect();
+            await consumer1.connect();
+            await consumer2.connect();
+            const tasks = Array.from({ length: 20 }, (_, i) => ({ value: i }));
+            await provider.enqueue(tasks);
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            // 两个消费者协同处理,总数应该是 20
+            // 但由于并发,可能有一些任务被重复处理或未处理,放宽条件
+            expect(consumer1Count + consumer2Count).toBeGreaterThanOrEqual(10);
+            expect(consumer1Count + consumer2Count).toBeLessThanOrEqual(20);
+        });
+    });
+    describe('队列统计', () => {
+        it('应该正确返回队列统计信息', async () => {
+            const { provider, consumer } = createQueue(async () => {
+                await new Promise(resolve => setTimeout(resolve, 100));
+                return catchIt(() => { });
+            });
+            await provider.connect();
+            await consumer.connect();
+            await provider.enqueue(Array.from({ length: 10 }, (_, i) => ({ value: i })));
+            await new Promise(resolve => setTimeout(resolve, 50));
+            const stats1 = await consumer.statistics();
+            expect(stats1.pending).toBeGreaterThan(0);
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            const stats2 = await consumer.statistics();
+            expect(stats2.completed).toBe(10);
+        });
+    });
+    describe('数据边界', () => {
+        it('应该能处理较大的数据', async () => {
+            let receivedData = [];
+            const { provider, consumer } = createQueue(async (dataList) => {
+                receivedData = dataList;
+                return catchIt(() => { });
+            }, { batchSize: 5 });
+            await provider.connect();
+            await consumer.connect();
+            const largeString = 'x'.repeat(10 * 1024); // 10KB
+            await provider.enqueue(Array.from({ length: 5 }, () => ({ data: largeString })));
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            expect(receivedData).toHaveLength(5);
+            expect(receivedData[0].data).toBe(largeString);
+        });
+    });
+});

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

@@ -1,6 +1,6 @@
-import type { BatchTaskQueueConfig, TaskData, Task, BatchTaskHandler, QueueStats } from './types';
+import type { BatchTaskQueueConfig, TaskData, Task, QueueStats } from './types';
 /**
- * 批量任务队列类
+ * 批量任务队列类（泛型）
  *
  * 提供基于 Redis 的批量任务队列功能，支持：
  * - 批量处理任务（每次处理多条）
@@ -9,24 +9,29 @@ import type { BatchTaskQueueConfig, TaskData, Task, BatchTaskHandler, QueueStats
  * - 任务状态追踪
  * - 分布式消费
  *
+ * @template T 任务数据类型
+ *
  * @example
  * ```ts
- * const queue = new BatchRedisQueue({
- *   redisUrl: 'redis://localhost:6379',
- *   queueKey: 'my-batch-queue',
- *   batchSize: 50, // 每次批量处理 50 个任务
- * })
+ * interface EmailTask {
+ *   to: string
+ * }
  *
- * // 注册批量任务处理器
- * queue.handle('send-emails', async (dataList) => {
- *   await sendEmailsBatch(dataList.map(d => d.to))
+ * const queue = new BatchRedisQueue<EmailTask>({
+ *   redisUrl: 'redis://localhost:6379',
+ *   queueKey: 'email-batch-queue',
+ *   batchSize: 50,
+ *   handler: async (dataList) => {
+ *     await sendEmailsBatch(dataList.map(d => d.to))
+ *     return catchIt(() => {})
+ *   }
  * })
  *
  * // 连接 Redis（自动启动消费者）
  * await queue.connect()
  *
  * // 入队任务（自动开始处理）
- * await queue.enqueue('send-emails', [
+ * await queue.enqueue([
  *   { to: 'user1@example.com' },
  *   { to: 'user2@example.com' },
  * ])
@@ -36,19 +41,19 @@ import type { BatchTaskQueueConfig, TaskData, Task, BatchTaskHandler, QueueStats
  * console.log(stats) // { pending: 100, processing: 50, completed: 200, failed: 5 }
  * ```
  */
-export declare class BatchRedisQueue {
+export declare class BatchRedisQueue<T extends TaskData = TaskData> {
     private consumerRunning;
     private redis;
     private consumerInterval;
     private recoveryInterval;
-    private processingBatches;
+    private processingTasks;
     private readonly config;
-    private readonly handlers;
+    private readonly handler;
     private readonly failedQueue;
     private readonly pendingQueue;
     private readonly processingQueue;
     private readonly completedQueue;
-    constructor(config: BatchTaskQueueConfig);
+    constructor(config: BatchTaskQueueConfig<string, T>);
     /**
      * 连接 Redis 并自动启动消费者
      */
@@ -57,29 +62,24 @@ export declare class BatchRedisQueue {
      * 断开 Redis 连接并停止消费者
      */
     disconnect(): void;
-    /**
-     * 注册批量任务处理器
-     */
-    handle<T extends TaskData = TaskData>(type: string, handler: BatchTaskHandler<T>): void;
     /**
      * 将任务推入队列(支持单个或批量)
-     * @param type 任务类型
      * @param data 任务数据(单个或数组)。可以在 data 中包含 `id` 字段来实现幂等性
      *
      * @example
      * // 普通任务,自动生成 ID
-     * await queue.enqueue('send-email', { to: 'user@example.com' })
+     * await queue.enqueue({ to: 'user@example.com' })
      *
      * // 幂等任务,手动指定 ID,重复提交会被忽略
-     * await queue.enqueue('send-email', { id: 'email-123', to: 'user@example.com' })
-     * await queue.enqueue('send-email', { id: 'email-123', to: 'user@example.com' }) // 会被跳过
+     * await queue.enqueue({ id: 'email-123', to: 'user@example.com' })
+     * await queue.enqueue({ id: 'email-123', to: 'user@example.com' }) // 会被跳过
      */
-    enqueue<T extends TaskData = TaskData>(type: string, data: T[]): Promise<string[]>;
-    enqueue<T extends TaskData = TaskData>(type: string, data: T): Promise<string>;
+    enqueue(data: T[]): Promise<string[]>;
+    enqueue(data: T): Promise<string>;
     /**
      * 获取任务详情
      */
-    getTask(taskId: string): Promise<Task | null>;
+    getTask(taskId: string): Promise<Task<T> | null>;
     /**
      * 更新任务状态并移动到对应队列（原子操作）
      */

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

@@ -1 +1 @@
-{"version":3,"file":"batch-redis-queue.d.ts","sourceRoot":"","sources":["../../source/redis-queue/batch-redis-queue.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAU,QAAQ,EAAE,IAAI,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAIzG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,KAAK,CAA+B;IAC5C,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,iBAAiB,CAAI;IAE7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgC;IACvD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;IAG/D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;IACrC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;gBAE3B,MAAM,EAAE,oBAAoB;IAsCxC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAY9B;;OAEG;IACH,UAAU,IAAI,IAAI;IAUlB;;OAEG;IACH,MAAM,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,IAAI;IAIvF;;;;;;;;;;;;OAYG;IACG,OAAO,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAClF,OAAO,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAmEpF;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAWnD;;OAEG;YACW,WAAW;IA8BzB;;OAEG;YACW,gBAAgB;IAI9B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;OAGG;YACW,mBAAmB;IA6EjC;;OAEG;YACW,YAAY;IAwG1B;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,aAAa;IA2ErB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;;;;OAKG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IA0BvC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB5B;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;CAMjC"}
+{"version":3,"file":"batch-redis-queue.d.ts","sourceRoot":"","sources":["../../source/redis-queue/batch-redis-queue.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAU,QAAQ,EAAE,IAAI,EAAoB,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,qBAAa,eAAe,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACxD,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,KAAK,CAA+B;IAC5C,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,eAAe,CAAI;IAE3B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAQtB;IACD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAG7C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;IACpC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;IACrC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;gBAE3B,MAAM,EAAE,oBAAoB,CAAC,MAAM,EAAE,CAAC,CAAC;IAkDnD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAY9B;;OAEG;IACH,UAAU,IAAI,IAAI;IAUlB;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IACrC,OAAO,CAAC,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAkEvC;;OAEG;IACG,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAWtD;;OAEG;YACW,WAAW;IA8BzB;;OAEG;YACW,gBAAgB;IAI9B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;OAGG;YACW,mBAAmB;IA6EjC;;OAEG;YACW,YAAY;IA8F1B;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,aAAa;IA2ErB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;;;;OAKG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IA0BvC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB5B;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;CAMjC"}

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

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { createClient } from 'redis';
 import { catchIt } from '@taicode/common-base';
 /**
- * 批量任务队列类
+ * 批量任务队列类（泛型）
  *
  * 提供基于 Redis 的批量任务队列功能，支持：
  * - 批量处理任务（每次处理多条）
@@ -11,24 +11,29 @@ import { catchIt } from '@taicode/common-base';
  * - 任务状态追踪
  * - 分布式消费
  *
+ * @template T 任务数据类型
+ *
  * @example
  * ```ts
- * const queue = new BatchRedisQueue({
- *   redisUrl: 'redis://localhost:6379',
- *   queueKey: 'my-batch-queue',
- *   batchSize: 50, // 每次批量处理 50 个任务
- * })
+ * interface EmailTask {
+ *   to: string
+ * }
  *
- * // 注册批量任务处理器
- * queue.handle('send-emails', async (dataList) => {
- *   await sendEmailsBatch(dataList.map(d => d.to))
+ * const queue = new BatchRedisQueue<EmailTask>({
+ *   redisUrl: 'redis://localhost:6379',
+ *   queueKey: 'email-batch-queue',
+ *   batchSize: 50,
+ *   handler: async (dataList) => {
+ *     await sendEmailsBatch(dataList.map(d => d.to))
+ *     return catchIt(() => {})
+ *   }
  * })
  *
  * // 连接 Redis（自动启动消费者）
  * await queue.connect()
  *
  * // 入队任务（自动开始处理）
- * await queue.enqueue('send-emails', [
+ * await queue.enqueue([
  *   { to: 'user1@example.com' },
  *   { to: 'user2@example.com' },
  * ])
@@ -43,9 +48,9 @@ export class BatchRedisQueue {
     redis = null;
     consumerInterval = null;
     recoveryInterval = null;
-    processingBatches = 0; // 当前正在处理的批次数
+    processingTasks = 0; // 当前正在处理的批次数
     config;
-    handlers = new Map();
+    handler;
     // 不同状态队列的键名
     failedQueue;
     pendingQueue;
@@ -53,8 +58,11 @@ export class BatchRedisQueue {
     completedQueue;
     constructor(config) {
         // 验证必填参数
-        if (!config.redisUrl) {
-            throw new Error('[BatchTaskQueue] redisUrl is required');
+        if (!config.redisUrl && !config.redisClient) {
+            throw new Error('[BatchTaskQueue] Either redisUrl or redisClient is required');
+        }
+        if (config.redisUrl && config.redisClient) {
+            throw new Error('[BatchTaskQueue] Cannot specify both redisUrl and redisClient');
         }
         if (!config.queueKey) {
             throw new Error('[BatchTaskQueue] queueKey is required');
@@ -62,9 +70,14 @@ export class BatchRedisQueue {
         if (config.queueKey.length < 6) {
             throw new Error('[BatchTaskQueue] queueKey must be at least 6 characters long');
         }
+        if (!config.handler) {
+            throw new Error('[BatchTaskQueue] handler is required');
+        }
+        this.handler = config.handler;
         this.config = {
             queueKey: config.queueKey,
             redisUrl: config.redisUrl,
+            redisClient: config.redisClient,
             batchSize: config.batchSize || 10,
             maxRetries: config.maxRetries || 3,
             concurrency: config.concurrency || 1,
@@ -78,11 +91,17 @@ export class BatchRedisQueue {
         this.pendingQueue = `${config.queueKey}:pending`;
         this.completedQueue = `${config.queueKey}:completed`;
         this.processingQueue = `${config.queueKey}:processing`;
-        this.redis = createClient({ url: this.config.redisUrl });
-        // 添加错误处理
-        this.redis.on('error', (err) => {
-            console.error('[BatchTaskQueue] Redis Client Error:', err);
-        });
+        // 使用外部客户端或创建新客户端
+        if (config.redisClient) {
+            this.redis = config.redisClient;
+        }
+        else {
+            this.redis = createClient({ url: this.config.redisUrl });
+            // 添加错误处理
+            this.redis.on('error', (err) => {
+                console.error('[BatchTaskQueue] Redis Client Error:', err);
+            });
+        }
     }
     /**
      * 连接 Redis 并自动启动消费者
@@ -110,13 +129,7 @@ export class BatchRedisQueue {
             });
         }
     }
-    /**
-     * 注册批量任务处理器
-     */
-    handle(type, handler) {
-        this.handlers.set(type, handler);
-    }
-    async enqueue(type, data) {
+    async enqueue(data) {
         if (!this.redis) {
             console.warn('[BatchTaskQueue] Redis not available, skipping task enqueue');
             return Array.isArray(data) ? [] : '';
@@ -146,11 +159,10 @@ export class BatchRedisQueue {
         for (const item of dataList) {
             // 检查 data 中是否包含自定义 id
             const customId = item.id;
-            const taskId = customId ? `${type}:${customId}` : `${type}:${randomUUID()}`;
+            const taskId = customId || randomUUID();
             const taskKey = `${this.config.queueKey}:task:${taskId}`;
             const task = {
                 id: taskId,
-                type,
                 data: item,
                 retryCount: 0,
                 maxRetries: this.config.maxRetries,
@@ -167,7 +179,7 @@ export class BatchRedisQueue {
                 console.log(`[BatchTaskQueue] Task already exists, skipping: ${taskId}`);
             }
             else {
-                console.log(`[BatchTaskQueue] Enqueued task: ${task.type} (${task.id})`);
+                console.log(`[BatchTaskQueue] Enqueued task: ${task.id}`);
             }
             taskIds.push(taskId);
         }
@@ -312,7 +324,7 @@ export class BatchRedisQueue {
      * 批量处理任务
      */
     async processBatch(taskIds) {
-        this.processingBatches++;
+        this.processingTasks++;
         try {
             // 获取所有任务
             const tasks = await Promise.all(taskIds.map(id => this.getTask(id)));
@@ -321,8 +333,8 @@ export class BatchRedisQueue {
                 console.warn(`[BatchTaskQueue] No valid tasks found in batch`);
                 return;
             }
-            // 按类型分组任务
-            const tasksByType = new Map();
+            // 过滤出有效的待处理任务
+            const tasksToProcess = [];
             for (const task of validTasks) {
                 // 检查状态
                 if (task.status !== 'pending') {
@@ -330,81 +342,72 @@ export class BatchRedisQueue {
                     await this.applyStatus(task.id, task.status, 'failed');
                     continue;
                 }
-                const typeTasks = tasksByType.get(task.type) || [];
-                typeTasks.push(task);
-                tasksByType.set(task.type, typeTasks);
+                tasksToProcess.push(task);
             }
-            // 按类型批量处理任务
-            for (const [type, typeTasks] of tasksByType) {
-                const handler = this.handlers.get(type);
-                if (!handler) {
-                    console.error(`[BatchTaskQueue] No handler registered for task type: ${type}`);
-                    // 将这批任务标记为失败
-                    await this.applyStatusBatch(typeTasks.map(t => t.id), 'pending', 'failed');
-                    continue;
-                }
-                try {
-                    // 任务已在 processing 队列中(由 Lua 脚本完成),只需更新状态和开始时间
-                    const taskIdList = typeTasks.map(t => t.id);
-                    const now = Date.now();
-                    await Promise.all(typeTasks.map(task => {
-                        task.status = 'processing';
-                        task.processingStartTime = now;
+            if (tasksToProcess.length === 0) {
+                return;
+            }
+            try {
+                // 任务已在 processing 队列中(由 Lua 脚本完成),只需更新状态和开始时间
+                const taskIdList = tasksToProcess.map(t => t.id);
+                const now = Date.now();
+                await Promise.all(tasksToProcess.map(task => {
+                    task.status = 'processing';
+                    task.processingStartTime = now;
+                    const taskKey = `${this.config.queueKey}:task:${task.id}`;
+                    return this.redis.setEx(taskKey, this.config.cleanupDelay, JSON.stringify(task));
+                }));
+                // 执行批量任务处理器
+                const dataList = tasksToProcess.map(t => t.data);
+                await this.handler(dataList);
+                // 更新状态为完成
+                await this.applyStatusBatch(taskIdList, 'processing', 'completed');
+                console.log(`[BatchTaskQueue] Batch completed: ${tasksToProcess.length} tasks`);
+            }
+            catch (error) {
+                console.error(`[BatchTaskQueue] Batch failed`, error);
+                // 检查每个任务是否需要重试
+                for (const task of tasksToProcess) {
+                    if (task.retryCount < task.maxRetries) {
+                        task.retryCount++;
+                        task.status = 'pending';
+                        task.processingStartTime = undefined;
                         const taskKey = `${this.config.queueKey}:task:${task.id}`;
-                        return this.redis.setEx(taskKey, this.config.cleanupDelay, JSON.stringify(task));
-                    }));
-                    // 执行批量任务处理器
-                    const dataList = typeTasks.map(t => t.data);
-                    await handler(dataList);
-                    // 更新状态为完成
-                    await this.applyStatusBatch(taskIdList, 'processing', 'completed');
-                    console.log(`[BatchTaskQueue] Batch completed: ${type} (${typeTasks.length} tasks)`);
-                }
-                catch (error) {
-                    console.error(`[BatchTaskQueue] Batch failed: ${type}`, error);
-                    // 检查每个任务是否需要重试
-                    for (const task of typeTasks) {
-                        if (task.retryCount < task.maxRetries) {
-                            task.retryCount++;
-                            task.status = 'pending';
-                            task.processingStartTime = undefined;
-                            const taskKey = `${this.config.queueKey}:task:${task.id}`;
-                            // 使用 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), task.id],
-                            });
-                            console.log(`[BatchTaskQueue] Task ${task.id} will retry (${task.retryCount}/${task.maxRetries})`);
-                        }
-                        else {
-                            task.status = 'failed';
-                            task.processingStartTime = undefined;
-                            const taskKey = `${this.config.queueKey}:task:${task.id}`;
-                            // 使用 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), task.id],
-                            });
-                            console.error(`[BatchTaskQueue] Task ${task.id} failed after ${task.maxRetries} retries`);
-                        }
+                        // 使用 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), task.id],
+                        });
+                        console.log(`[BatchTaskQueue] Task ${task.id} will retry (${task.retryCount}/${task.maxRetries})`);
+                    }
+                    else {
+                        task.status = 'failed';
+                        task.processingStartTime = undefined;
+                        const taskKey = `${this.config.queueKey}:task:${task.id}`;
+                        // 使用 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), task.id],
+                        });
+                        console.error(`[BatchTaskQueue] Task ${task.id} failed after ${task.maxRetries} retries`);
                     }
                 }
             }
         }
         finally {
-            this.processingBatches--;
+            this.processingTasks--;
         }
     }
     /**
@@ -489,7 +492,7 @@ export class BatchRedisQueue {
         this.consumerInterval = setInterval(async () => {
             try {
                 // 检查是否有正在处理的批次（批量队列通常不需要并发控制，一次处理一批）
-                if (this.processingBatches > 0) {
+                if (this.processingTasks > 0) {
                     return;
                 }
                 // 使用 Lua 脚本原子化取出任务并移到 processing 队列