@taicode/common-server 1.0.13 → 1.0.15

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

@@ -1,7 +1,8 @@
 export { RedisQueueProvider } from './redis-queue-provider';
 export { RedisQueueConsumer } from './redis-queue-consumer';
-export { RedisBatchConsumer } from './redis-batch-consumer';
+export { RedisQueueBatchConsumer } from './redis-queue-batch-consumer';
 export type { RedisQueueProviderConfig, RedisQueueConsumerConfig, BatchConsumerConfig } from './types';
 export type { TaskData } from './types';
 export type { RedisQueueRegistry } from './types';
+export * as test from './test-helpers';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/redis-queue/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAG3D,YAAY,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAGtG,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAGvC,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/redis-queue/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAC3D,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAA;AAGtE,YAAY,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAGtG,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAGvC,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAGjD,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA"}

package/output/redis-queue/index.js

@@ -1,4 +1,6 @@
 // 核心类导出
 export { RedisQueueProvider } from './redis-queue-provider';
 export { RedisQueueConsumer } from './redis-queue-consumer';
-export { RedisBatchConsumer } from './redis-batch-consumer';
+export { RedisQueueBatchConsumer } from './redis-queue-batch-consumer';
+// 测试辅助函数导出
+export * as test from './test-helpers';

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

@@ -76,5 +76,14 @@ export declare class RedisBatchConsumer<K extends keyof RedisQueueRegistry> exte
      * 健康检查
      */
     health(): Promise<boolean>;
+    /**
+     * 立即派发批量任务进行处理(仅供测试工具调用)
+     *
+     * ⚠️ 此方法为 private,仅通过 test-helpers 暴露给测试代码使用
+     *
+     * @param taskIds 要立即处理的任务 ID 列表
+     * @returns Promise,等待所有任务批次处理完成
+     */
+    private dispatch;
 }
 //# sourceMappingURL=redis-batch-consumer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"redis-batch-consumer.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-batch-consumer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAA0B,UAAU,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,kBAAkB,CAAC,CAAC,SAAS,MAAM,kBAAkB,CAAE,SAAQ,gBAAgB;IAC1F,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,iBAAiB,CAAI;IAE7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAOtB;gBAEW,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;IA2B1C,SAAS,CAAC,YAAY,IAAI,MAAM;IAIhC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;OAEG;YACW,YAAY;IA4F1B;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyErB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAevC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;CAMjC"}
+{"version":3,"file":"redis-batch-consumer.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-batch-consumer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAA0B,UAAU,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,kBAAkB,CAAC,CAAC,SAAS,MAAM,kBAAkB,CAAE,SAAQ,gBAAgB;IAC1F,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,iBAAiB,CAAI;IAE7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAOtB;gBAEW,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;IA2B1C,SAAS,CAAC,YAAY,IAAI,MAAM;IAIhC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B;;OAEG;IACH,UAAU,IAAI,IAAI;IAMlB;;OAEG;YACW,YAAY;IA4F1B;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyErB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAevC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IAOhC;;;;;;;OAOG;YACW,QAAQ;CA+DvB"}

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

@@ -305,4 +305,67 @@ export class RedisBatchConsumer extends RedisQueueCommon {
         const result = await catchIt(() => this.redis.ping());
         return !result.isError() && result.value === 'PONG';
     }
+    /**
+     * 立即派发批量任务进行处理(仅供测试工具调用)
+     *
+     * ⚠️ 此方法为 private,仅通过 test-helpers 暴露给测试代码使用
+     *
+     * @param taskIds 要立即处理的任务 ID 列表
+     * @returns Promise,等待所有任务批次处理完成
+     */
+    async dispatch(taskIds) {
+        if (!this.redis || !this.redis.isOpen) {
+            throw new Error('[RedisBatchConsumer] Redis is not connected');
+        }
+        if (taskIds.length === 0) {
+            return;
+        }
+        // 使用 Lua 脚本将任务从 pending 移到 processing(忽略延迟时间)
+        const moveToProcessingScript = `
+      local pendingQueue = KEYS[1]
+      local processingQueue = KEYS[2]
+      local movedIds = {}
+      
+      -- ARGV[1], ARGV[2], ... 是 taskId
+      for i = 1, #ARGV do
+        local taskId = ARGV[i]
+        local removed = redis.call('LREM', pendingQueue, 0, taskId)
+        if removed > 0 then
+          redis.call('RPUSH', processingQueue, taskId)
+          table.insert(movedIds, taskId)
+        end
+      end
+      
+      return movedIds
+    `;
+        const movedIds = await this.redis.eval(moveToProcessingScript, {
+            keys: [this.pendingQueue, this.processingQueue],
+            arguments: taskIds,
+        });
+        if (movedIds.length === 0) {
+            console.warn('[RedisBatchConsumer] No tasks were moved to processing queue');
+            return;
+        }
+        // 按照 batchSize 分批处理并等待完成
+        const batches = [];
+        for (let i = 0; i < movedIds.length; i += this.config.batchSize) {
+            batches.push(movedIds.slice(i, i + this.config.batchSize));
+        }
+        // 串行处理每个批次(遵循批量消费语义)
+        for (const batch of batches) {
+            await this.processBatch(batch);
+        }
+        // 检查是否有任务需要重试(已放回 pending 队列)
+        const retryIds = [];
+        for (const taskId of movedIds) {
+            const task = await this.getTask(taskId);
+            if (task && task.status === 'pending' && task.retryCount > 0) {
+                retryIds.push(taskId);
+            }
+        }
+        // 递归处理重试任务
+        if (retryIds.length > 0) {
+            await this.dispatch(retryIds);
+        }
+    }
 }

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

@@ -0,0 +1,77 @@
+import { RedisQueueCommon } from './redis-queue-common';
+import type { BatchConsumerConfig, QueueStats, RedisQueueRegistry } from './types';
+/**
+ * Redis 批量队列消费者
+ *
+ * 批量消费任务,每次处理多条
+ *
+ * @template K 队列键名类型
+ *
+ * @example
+ * ```ts
+ * const consumer = new RedisQueueBatchConsumer('email-queue', {
+ *   redisUrl: 'redis://localhost:6379',
+ *   batchSize: 50,
+ *   handler: async (dataList) => {
+ *     await sendEmailsBatch(dataList.map(d => d.to))
+ *     return catchIt(() => {})
+ *   }
+ * })
+ *
+ * await consumer.connect() // 自动开始消费
+ *
+ * // 获取统计信息
+ * const stats = await consumer.statistics()
+ *
+ * // 停止消费
+ * consumer.disconnect()
+ * ```
+ */
+export declare class RedisQueueBatchConsumer<K extends keyof RedisQueueRegistry> extends RedisQueueCommon {
+    private consumerRunning;
+    private consumerInterval;
+    private recoveryInterval;
+    private processingBatches;
+    private processingPromises;
+    private readonly config;
+    constructor(queueKey: K, config: BatchConsumerConfig<K>);
+    protected getLogPrefix(): string;
+    /**
+     * 连接 Redis 并自动启动消费者
+     */
+    connect(): Promise<void>;
+    /**
+     * 断开 Redis 连接并停止消费者
+     * 会等待所有正在处理的批次完成后再断开连接
+     */
+    disconnect(): Promise<void>;
+    /**
+     * 批量处理任务
+     */
+    private processBatch;
+    /**
+     * 启动恢复机制
+     */
+    private startRecovery;
+    /**
+     * 停止恢复机制
+     */
+    private stopRecovery;
+    /**
+     * 启动消费者
+     */
+    private startConsumer;
+    /**
+     * 停止消费者
+     */
+    private stopConsumer;
+    /**
+     * 获取队列统计信息（O(1) 时间复杂度）
+     */
+    statistics(): Promise<QueueStats>;
+    /**
+     * 健康检查
+     */
+    health(): Promise<boolean>;
+}
+//# sourceMappingURL=redis-queue-batch-consumer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-queue-batch-consumer.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-batch-consumer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAA0B,UAAU,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE1G;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,uBAAuB,CAAC,CAAC,SAAS,MAAM,kBAAkB,CAAE,SAAQ,gBAAgB;IAC/F,OAAO,CAAC,eAAe,CAAQ;IAC/B,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,gBAAgB,CAA8B;IACtD,OAAO,CAAC,iBAAiB,CAAI;IAC7B,OAAO,CAAC,kBAAkB,CAA2B;IAErD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAOtB;gBAEW,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAuBvD,SAAS,CAAC,YAAY,IAAI,MAAM;IAIhC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAO9B;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAgBjC;;OAEG;YACW,YAAY;IA2G1B;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyErB;;OAEG;IACH,OAAO,CAAC,YAAY;IASpB;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,CAAC;IAevC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;CAMjC"}

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

@@ -0,0 +1,320 @@
+import { catchIt } from '@taicode/common-base';
+import { RedisQueueCommon } from './redis-queue-common';
+/**
+ * Redis 批量队列消费者
+ *
+ * 批量消费任务,每次处理多条
+ *
+ * @template K 队列键名类型
+ *
+ * @example
+ * ```ts
+ * const consumer = new RedisQueueBatchConsumer('email-queue', {
+ *   redisUrl: 'redis://localhost:6379',
+ *   batchSize: 50,
+ *   handler: async (dataList) => {
+ *     await sendEmailsBatch(dataList.map(d => d.to))
+ *     return catchIt(() => {})
+ *   }
+ * })
+ *
+ * await consumer.connect() // 自动开始消费
+ *
+ * // 获取统计信息
+ * const stats = await consumer.statistics()
+ *
+ * // 停止消费
+ * consumer.disconnect()
+ * ```
+ */
+export class RedisQueueBatchConsumer extends RedisQueueCommon {
+    consumerRunning = false;
+    consumerInterval = null;
+    recoveryInterval = null;
+    processingBatches = 0; // 当前正在处理的批次数
+    processingPromises = new Set(); // 跟踪所有正在处理的批次
+    config;
+    constructor(queueKey, config) {
+        // 验证必填参数
+        if (!config.handler) {
+            throw new Error('[RedisQueueBatchConsumer] handler is required');
+        }
+        // 调用父类构造函数
+        super(queueKey, {
+            redisUrl: config.redisUrl,
+            redisClient: config.redisClient,
+            cleanupDelay: config.cleanupDelay ?? 86400,
+        });
+        this.config = {
+            handler: config.handler,
+            batchSize: config.batchSize ?? 10,
+            maxRetries: config.maxRetries ?? 3,
+            concurrency: config.concurrency ?? 1,
+            consumerInterval: config.consumerInterval ?? 1000,
+            processingTimeout: config.processingTimeout ?? 60000, // 60 seconds
+        };
+    }
+    getLogPrefix() {
+        return 'RedisQueueBatchConsumer';
+    }
+    /**
+     * 连接 Redis 并自动启动消费者
+     */
+    async connect() {
+        await super.connect();
+        // 连接成功后启动消费者和恢复机制
+        this.startConsumer();
+        this.startRecovery();
+    }
+    /**
+     * 断开 Redis 连接并停止消费者
+     * 会等待所有正在处理的批次完成后再断开连接
+     */
+    async disconnect() {
+        // 先停止消费者和恢复机制，不再接受新任务
+        this.stopConsumer();
+        this.stopRecovery();
+        // 等待所有正在处理的批次完成
+        if (this.processingPromises.size > 0) {
+            console.log(`[RedisQueueBatchConsumer] Waiting for ${this.processingPromises.size} batches to complete...`);
+            await Promise.allSettled(this.processingPromises);
+            console.log(`[RedisQueueBatchConsumer] All batches completed`);
+        }
+        // 最后断开 Redis 连接
+        super.disconnect();
+    }
+    /**
+     * 批量处理任务
+     */
+    async processBatch(taskIds) {
+        this.processingBatches++;
+        // 创建一个 Promise 来跟踪这个批次的处理过程
+        const batchPromise = (async () => {
+            try {
+                // 获取所有任务
+                const tasks = await Promise.all(taskIds.map(id => this.getTask(id)));
+                const validTasks = tasks.filter((task) => task !== null);
+                if (validTasks.length === 0) {
+                    console.warn(`[RedisQueueBatchConsumer] No valid tasks found in batch`);
+                    return;
+                }
+                // 过滤出有效的待处理任务
+                const tasksToProcess = [];
+                for (const task of validTasks) {
+                    // 检查状态
+                    if (task.status !== 'pending') {
+                        console.log(`[RedisQueueBatchConsumer] Task ${task.id} has invalid status (${task.status}), marking as failed`);
+                        await this.applyStatus(task.id, task.status, 'failed');
+                        continue;
+                    }
+                    tasksToProcess.push(task);
+                }
+                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.queueKey}:task:${task.id}`;
+                        return this.redis.setEx(taskKey, this.cleanupDelay, JSON.stringify(task));
+                    }));
+                    // 批量处理所有任务
+                    const dataList = tasksToProcess.map(t => t.data);
+                    await this.config.handler(dataList);
+                    // 批量更新状态为完成
+                    const updatedCount = await this.applyStatusBatch(taskIdList, 'processing', 'completed');
+                    console.log(`[RedisQueueBatchConsumer] Batch completed: ${updatedCount} tasks`);
+                }
+                catch (error) {
+                    console.error(`[RedisQueueBatchConsumer] Batch failed:`, error);
+                    // 批量重试或失败
+                    for (const task of tasksToProcess) {
+                        if (task.retryCount < task.maxRetries) {
+                            task.retryCount++;
+                            task.status = 'pending';
+                            task.processingStartTime = undefined;
+                            const taskKey = `${this.queueKey}:task:${task.id}`;
+                            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.cleanupDelay.toString(), JSON.stringify(task), task.id],
+                            });
+                            console.log(`[RedisQueueBatchConsumer] Task ${task.id} will retry (${task.retryCount}/${task.maxRetries})`);
+                        }
+                        else {
+                            task.status = 'failed';
+                            task.processingStartTime = undefined;
+                            const taskKey = `${this.queueKey}:task:${task.id}`;
+                            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.cleanupDelay.toString(), JSON.stringify(task), task.id],
+                            });
+                            console.error(`[RedisQueueBatchConsumer] Task ${task.id} failed after ${task.maxRetries} retries`);
+                        }
+                    }
+                }
+            }
+            finally {
+                this.processingBatches--;
+            }
+        })();
+        // 将批次 Promise 添加到集合中
+        this.processingPromises.add(batchPromise);
+        // 批次完成后从集合中移除
+        batchPromise.finally(() => {
+            this.processingPromises.delete(batchPromise);
+        });
+        // 返回批次 Promise
+        return batchPromise;
+    }
+    /**
+     * 启动恢复机制
+     */
+    startRecovery() {
+        if (this.recoveryInterval || !this.redis) {
+            return;
+        }
+        // 立即执行一次恢复
+        this.recoverStalled(this.config.processingTimeout).catch(error => {
+            console.error('[RedisQueueBatchConsumer] Initial recovery error:', error);
+        });
+        // 定期检查（每 10 秒检查一次）
+        this.recoveryInterval = setInterval(() => {
+            this.recoverStalled(this.config.processingTimeout).catch(error => {
+                console.error('[RedisQueueBatchConsumer] Recovery error:', error);
+            });
+        }, 10000);
+        console.log('[RedisQueueBatchConsumer] Recovery mechanism started');
+    }
+    /**
+     * 停止恢复机制
+     */
+    stopRecovery() {
+        if (this.recoveryInterval) {
+            clearInterval(this.recoveryInterval);
+            this.recoveryInterval = null;
+            console.log('[RedisQueueBatchConsumer] Recovery mechanism stopped');
+        }
+    }
+    /**
+     * 启动消费者
+     */
+    startConsumer() {
+        if (this.consumerRunning || !this.redis) {
+            return;
+        }
+        this.consumerRunning = true;
+        console.log(`[RedisQueueBatchConsumer] Consumer started with batchSize: ${this.config.batchSize}, concurrency: ${this.config.concurrency}`);
+        // Lua 脚本: 批量原子化从 pending 取出任务并移到 processing
+        const popAndMoveBatchScript = `
+      local pendingQueue = KEYS[1]
+      local processingQueue = KEYS[2]
+      local queueKeyPrefix = KEYS[3]
+      local count = tonumber(ARGV[1])
+      local currentTime = tonumber(ARGV[2])
+      
+      local taskIds = {}
+      local checkedCount = 0
+      local maxCheck = count * 3
+      
+      while #taskIds < count and checkedCount < maxCheck do
+        local taskId = redis.call('LPOP', pendingQueue)
+        if not taskId then
+          break
+        end
+        
+        checkedCount = checkedCount + 1
+        
+        local taskKey = queueKeyPrefix .. ':task:' .. taskId
+        local taskData = redis.call('GET', taskKey)
+        
+        if taskData then
+          local task = cjson.decode(taskData)
+          local delayUntil = task.delayUntil
+          
+          if not delayUntil or delayUntil <= currentTime then
+            redis.call('RPUSH', processingQueue, taskId)
+            table.insert(taskIds, taskId)
+          else
+            redis.call('RPUSH', pendingQueue, taskId)
+          end
+        end
+      end
+      
+      return taskIds
+    `;
+        this.consumerInterval = setInterval(async () => {
+            try {
+                // 检查当前是否有可用的并发槽位
+                const availableSlots = this.config.concurrency - this.processingBatches;
+                if (availableSlots <= 0) {
+                    return; // 已达到并发限制
+                }
+                // 批量取出任务
+                const taskIds = await this.redis.eval(popAndMoveBatchScript, {
+                    keys: [this.pendingQueue, this.processingQueue, this.queueKey],
+                    arguments: [this.config.batchSize.toString(), Date.now().toString()],
+                });
+                if (taskIds.length > 0) {
+                    // 处理这批任务（不等待完成）
+                    this.processBatch(taskIds).catch(error => {
+                        console.error(`[RedisQueueBatchConsumer] Unhandled error in processBatch:`, error);
+                    });
+                }
+            }
+            catch (error) {
+                console.error('[RedisQueueBatchConsumer] Consumer error:', error);
+            }
+        }, this.config.consumerInterval);
+    }
+    /**
+     * 停止消费者
+     */
+    stopConsumer() {
+        if (this.consumerInterval) {
+            clearInterval(this.consumerInterval);
+            this.consumerInterval = null;
+        }
+        this.consumerRunning = false;
+        console.log('[RedisQueueBatchConsumer] Consumer stopped');
+    }
+    /**
+     * 获取队列统计信息（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 };
+    }
+    /**
+     * 健康检查
+     */
+    async health() {
+        if (!this.redis)
+            return false;
+        const result = await catchIt(() => this.redis.ping());
+        return !result.isError() && result.value === 'PONG';
+    }
+}

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

@@ -0,0 +1,26 @@
+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 {
+        [key: `test:batch:${string}`]: TestTaskData;
+    }
+}
+export {};
+//# sourceMappingURL=redis-queue-batch-consumer.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-queue-batch-consumer.test.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-batch-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"}