@taicode/common-server 1.0.11 → 1.0.13

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

@@ -0,0 +1,265 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { catchIt } from '@taicode/common-base';
+import { RedisQueueProvider } from './redis-queue-provider';
+import { RedisBatchConsumer } from './redis-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);
+        });
+    });
+    describe('超时恢复', () => {
+        it('超时的任务应该直接标记为失败', { timeout: 15000 }, async () => {
+            let processCount = 0;
+            const { provider, consumer } = createQueue(async (dataList) => {
+                processCount++;
+                // 模拟处理卡住，永远不完成 (但超时机制会检测到)
+                await new Promise(resolve => setTimeout(resolve, 20000));
+                return catchIt(() => { });
+            }, {
+                batchSize: 1,
+                processingTimeout: 500, // 500ms 超时
+                consumerInterval: 100,
+            });
+            await provider.connect();
+            await consumer.connect();
+            await provider.enqueue([{ value: 1 }]);
+            // 等待任务被处理和超时恢复 (需要等待至少2个恢复周期: 10秒)
+            await new Promise(resolve => setTimeout(resolve, 12000));
+            const stats = await consumer.statistics();
+            // 超时后直接标记为失败,不应该重试
+            expect(stats.failed).toBe(1);
+            expect(stats.pending).toBe(0);
+            expect(stats.processing).toBe(0);
+            expect(stats.completed).toBe(0);
+            // 应该只处理一次,不会重试
+            expect(processCount).toBe(1);
+        });
+        it('未超时的失败任务应该正常重试', async () => {
+            let attemptCount = 0;
+            const { provider, consumer } = createQueue(async () => {
+                attemptCount++;
+                throw new Error('Task failed');
+            }, {
+                batchSize: 1,
+                maxRetries: 3,
+                processingTimeout: 5000, // 5秒超时,足够长不会触发
+                consumerInterval: 100,
+            });
+            await provider.connect();
+            await consumer.connect();
+            await provider.enqueue([{ value: 1 }]);
+            // 等待所有重试完成
+            await new Promise(resolve => setTimeout(resolve, 3000));
+            const stats = await consumer.statistics();
+            // 应该重试 3 次后失败
+            expect(stats.failed).toBe(1);
+            expect(attemptCount).toBe(4); // 初始 1 次 + 3 次重试
+        });
+    });
+});

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

@@ -0,0 +1,73 @@
+import { RedisClientType } from 'redis';
+import type { Status, Task, RedisQueueCommonConfig } from './types';
+/**
+ * Redis 队列基础类
+ * 封装 Provider 和 Consumer 的公共逻辑
+ */
+export declare abstract class RedisQueueCommon {
+    protected redis: RedisClientType | null;
+    protected isExternalRedis: boolean;
+    protected readonly queueKey: string;
+    protected readonly redisUrl?: string;
+    protected readonly cleanupDelay: number;
+    protected readonly failedQueue: string;
+    protected readonly pendingQueue: string;
+    protected readonly processingQueue: string;
+    protected readonly completedQueue: string;
+    constructor(config: RedisQueueCommonConfig);
+    /**
+     * 获取日志前缀(子类实现)
+     */
+    protected abstract getLogPrefix(): string;
+    /**
+     * 连接 Redis
+     */
+    connect(): Promise<void>;
+    /**
+     * 断开 Redis 连接
+     */
+    disconnect(): void;
+    /**
+     * 获取任务详情
+     */
+    protected getTask(taskId: string): Promise<Task | null>;
+    /**
+     * 根据状态获取对应的队列键
+     */
+    protected getQueueByStatus(status: Status): string;
+    /**
+     * 更新任务状态并移动到对应队列（原子操作）
+     */
+    protected applyStatus(taskId: string, oldStatus: Status, newStatus: Status): Promise<void>;
+    /**
+     * 批量更新任务状态（使用 Lua 脚本保证原子性）
+     * 注意: 此方法会在 Lua 脚本中读取任务数据,不需要提前获取
+     */
+    protected applyStatusBatch(taskIds: string[], oldStatus: Status, newStatus: Status): Promise<number>;
+    /**
+     * 获取队列统计信息（O(1) 时间复杂度）
+     */
+    statistics(): Promise<{
+        pending: number;
+        processing: number;
+        completed: number;
+        failed: number;
+    }>;
+    /**
+     * 健康检查
+     */
+    health(): Promise<boolean>;
+    /**
+     * 恢复超时的任务
+     * 检查 processing 队列中的任务，将超时的任务直接标记为失败
+     * 使用 Lua 脚本批量处理以提高性能和原子性
+     *
+     * @param processingTimeout 处理超时时间（毫秒）
+     * @returns 恢复的任务统计 {timeoutFailed: number, cleaned: number}
+     */
+    protected recoverStalled(processingTimeout: number): Promise<{
+        timeoutFailed: number;
+        cleaned: number;
+    }>;
+}
+//# sourceMappingURL=redis-queue-common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-queue-common.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,eAAe,EAAE,MAAM,OAAO,CAAA;AACrD,OAAO,KAAK,EAAE,MAAM,EAAY,IAAI,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAE7E;;;GAGG;AACH,8BAAsB,gBAAgB;IACpC,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAO;IAC9C,SAAS,CAAC,eAAe,EAAE,OAAO,CAAQ;IAE1C,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACnC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACpC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAGvC,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IACtC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IACvC,SAAS,CAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAC1C,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;gBAE7B,MAAM,EAAE,sBAAsB;IAwC1C;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,YAAY,IAAI,MAAM;IAEzC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B;;OAEG;IACH,UAAU,IAAI,IAAI;IAalB;;OAEG;cACa,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAW7D;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAUlD;;OAEG;cACa,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqChG;;;OAGG;cACa,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAqD1G;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAevG;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC;IAUhC;;;;;;;OAOG;cACa,cAAc,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CA4E/G"}

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

@@ -0,0 +1,302 @@
+import { createClient } from 'redis';
+/**
+ * Redis 队列基础类
+ * 封装 Provider 和 Consumer 的公共逻辑
+ */
+export class RedisQueueCommon {
+    redis = null;
+    isExternalRedis = false; // 是否使用外部传入的 Redis 客户端
+    queueKey;
+    redisUrl;
+    cleanupDelay;
+    // 不同状态队列的键名
+    failedQueue;
+    pendingQueue;
+    processingQueue;
+    completedQueue;
+    constructor(config) {
+        // 验证必填参数
+        if (!config.redisUrl && !config.redisClient) {
+            throw new Error('[RedisQueue] Either redisUrl or redisClient is required');
+        }
+        if (config.redisUrl && config.redisClient) {
+            throw new Error('[RedisQueue] Cannot specify both redisUrl and redisClient');
+        }
+        if (!config.queueKey) {
+            throw new Error('[RedisQueue] queueKey is required');
+        }
+        if (config.queueKey.length < 6) {
+            throw new Error('[RedisQueue] queueKey must be at least 6 characters long');
+        }
+        this.redisUrl = config.redisUrl;
+        this.queueKey = config.queueKey;
+        this.cleanupDelay = config.cleanupDelay ?? 86400; // 24 hours
+        // 初始化不同状态队列的键名
+        this.failedQueue = `${config.queueKey}:failed`;
+        this.pendingQueue = `${config.queueKey}:pending`;
+        this.completedQueue = `${config.queueKey}:completed`;
+        this.processingQueue = `${config.queueKey}:processing`;
+        // 使用外部客户端或创建新客户端
+        if (config.redisClient) {
+            this.redis = config.redisClient;
+            this.isExternalRedis = true;
+        }
+        else {
+            this.redis = createClient({ url: this.redisUrl });
+            this.isExternalRedis = false;
+            // 添加错误处理
+            this.redis.on('error', (err) => {
+                console.error(`[${this.getLogPrefix()}] Redis Client Error:`, err);
+            });
+        }
+    }
+    /**
+     * 连接 Redis
+     */
+    async connect() {
+        if (this.redis && !this.redis.isOpen) {
+            await this.redis.connect().catch((error) => {
+                console.error(`[${this.getLogPrefix()}] Failed to connect to Redis:`, error);
+                throw error;
+            });
+        }
+    }
+    /**
+     * 断开 Redis 连接
+     */
+    disconnect() {
+        // 如果是外部传入的客户端,不主动断开连接
+        if (this.isExternalRedis) {
+            return;
+        }
+        if (this.redis && this.redis.isOpen) {
+            this.redis.disconnect().catch((error) => {
+                console.error(`[${this.getLogPrefix()}] Failed to disconnect:`, error);
+            });
+        }
+    }
+    /**
+     * 获取任务详情
+     */
+    async getTask(taskId) {
+        if (!this.redis || !this.redis.isOpen)
+            return null;
+        const taskKey = `${this.queueKey}:task:${taskId}`;
+        const taskData = await this.redis.get(taskKey);
+        if (!taskData)
+            return null;
+        return JSON.parse(taskData);
+    }
+    /**
+     * 根据状态获取对应的队列键
+     */
+    getQueueByStatus(status) {
+        switch (status) {
+            case 'pending': return this.pendingQueue;
+            case 'processing': return this.processingQueue;
+            case 'completed': return this.completedQueue;
+            case 'failed': return this.failedQueue;
+            default: return this.pendingQueue;
+        }
+    }
+    /**
+     * 更新任务状态并移动到对应队列（原子操作）
+     */
+    async applyStatus(taskId, oldStatus, newStatus) {
+        if (!this.redis || !this.redis.isOpen)
+            return;
+        const task = await this.getTask(taskId);
+        if (!task)
+            return;
+        task.status = newStatus;
+        const taskKey = `${this.queueKey}:task:${taskId}`;
+        const oldQueue = this.getQueueByStatus(oldStatus);
+        const newQueue = this.getQueueByStatus(newStatus);
+        if (oldQueue !== newQueue) {
+            // 使用 Lua 脚本确保原子性：更新任务 + 移动队列
+            const script = `
+        local taskKey = KEYS[1]
+        local oldQueue = KEYS[2]
+        local newQueue = KEYS[3]
+        local ttl = tonumber(ARGV[1])
+        local taskData = ARGV[2]
+        local taskId = ARGV[3]
+        
+        redis.call('SETEX', taskKey, ttl, taskData)
+        redis.call('LREM', oldQueue, 0, taskId)
+        redis.call('RPUSH', newQueue, taskId)
+        return 1
+      `;
+            await this.redis.eval(script, {
+                keys: [taskKey, oldQueue, newQueue],
+                arguments: [this.cleanupDelay.toString(), JSON.stringify(task), taskId],
+            });
+        }
+        else {
+            // 只更新任务数据
+            await this.redis.setEx(taskKey, this.cleanupDelay, JSON.stringify(task));
+        }
+    }
+    /**
+     * 批量更新任务状态（使用 Lua 脚本保证原子性）
+     * 注意: 此方法会在 Lua 脚本中读取任务数据,不需要提前获取
+     */
+    async applyStatusBatch(taskIds, oldStatus, newStatus) {
+        if (!this.redis || !this.redis.isOpen || taskIds.length === 0)
+            return 0;
+        const oldQueue = this.getQueueByStatus(oldStatus);
+        const newQueue = this.getQueueByStatus(newStatus);
+        // 使用 Lua 脚本批量更新状态并移动队列
+        const batchUpdateScript = `
+      local oldQueue = KEYS[1]
+      local newQueue = KEYS[2]
+      local queueKeyPrefix = ARGV[1]
+      local ttl = tonumber(ARGV[2])
+      local newStatus = ARGV[3]
+      local updatedCount = 0
+      
+      -- ARGV[4], ARGV[5], ARGV[6]... 是 taskId
+      for i = 4, #ARGV do
+        local taskId = ARGV[i]
+        local taskKey = queueKeyPrefix .. ':task:' .. taskId
+        local existingData = redis.call('GET', taskKey)
+        
+        if existingData then
+          -- 读取现有任务并更新状态
+          local task = cjson.decode(existingData)
+          task.status = newStatus
+          redis.call('SETEX', taskKey, ttl, cjson.encode(task))
+          
+          -- 如果队列不同,移动任务
+          if oldQueue ~= newQueue then
+            redis.call('LREM', oldQueue, 0, taskId)
+            redis.call('RPUSH', newQueue, taskId)
+          end
+          
+          updatedCount = updatedCount + 1
+        end
+      end
+      
+      return updatedCount
+    `;
+        const result = await this.redis.eval(batchUpdateScript, {
+            keys: [oldQueue, newQueue],
+            arguments: [
+                this.queueKey,
+                this.cleanupDelay.toString(),
+                newStatus,
+                ...taskIds,
+            ],
+        });
+        return result;
+    }
+    /**
+     * 获取队列统计信息（O(1) 时间复杂度）
+     */
+    async statistics() {
+        if (!this.redis || !this.redis.isOpen) {
+            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 || !this.redis.isOpen)
+            return false;
+        try {
+            await this.redis.ping();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 恢复超时的任务
+     * 检查 processing 队列中的任务，将超时的任务直接标记为失败
+     * 使用 Lua 脚本批量处理以提高性能和原子性
+     *
+     * @param processingTimeout 处理超时时间（毫秒）
+     * @returns 恢复的任务统计 {timeoutFailed: number, cleaned: number}
+     */
+    async recoverStalled(processingTimeout) {
+        if (!this.redis || !this.redis.isOpen) {
+            return { timeoutFailed: 0, cleaned: 0 };
+        }
+        try {
+            const processingTaskIds = await this.redis.lRange(this.processingQueue, 0, -1);
+            if (processingTaskIds.length === 0) {
+                return { timeoutFailed: 0, cleaned: 0 };
+            }
+            // 使用 Lua 脚本批量恢复超时任务
+            const batchRecoveryScript = `
+        local processingQueue = KEYS[1]
+        local pendingQueue = KEYS[2]
+        local failedQueue = KEYS[3]
+        local queueKeyPrefix = ARGV[1]
+        local ttl = tonumber(ARGV[2])
+        local processingTimeout = tonumber(ARGV[3])
+        local now = tonumber(ARGV[4])
+        
+        local retryCount = 0
+        local failedCount = 0
+        local cleanupCount = 0
+        
+        -- ARGV[5], ARGV[6], ARGV[7]... 是 taskId
+        for i = 5, #ARGV do
+          local taskId = ARGV[i]
+          local taskKey = queueKeyPrefix .. ':task:' .. taskId
+          local taskData = redis.call('GET', taskKey)
+          
+          if not taskData then
+            -- 任务不存在，从队列中清理
+            redis.call('LREM', processingQueue, 0, taskId)
+            cleanupCount = cleanupCount + 1
+          else
+            local task = cjson.decode(taskData)
+            local processingTime = now - (task.processingStartTime or now)
+            
+            -- 检查是否超时
+            if processingTime > processingTimeout then
+              -- 超时直接标记为失败
+              task.status = 'failed'
+              task.processingStartTime = nil
+              
+              redis.call('SETEX', taskKey, ttl, cjson.encode(task))
+              redis.call('LREM', processingQueue, 0, taskId)
+              redis.call('RPUSH', failedQueue, taskId)
+              failedCount = failedCount + 1
+            end
+          end
+        end
+        
+        return {retryCount, failedCount, cleanupCount}
+      `;
+            const result = await this.redis.eval(batchRecoveryScript, {
+                keys: [this.processingQueue, this.pendingQueue, this.failedQueue],
+                arguments: [
+                    this.queueKey,
+                    this.cleanupDelay.toString(),
+                    processingTimeout.toString(),
+                    Date.now().toString(),
+                    ...processingTaskIds,
+                ],
+            });
+            const [, failedCount, cleanupCount] = result;
+            return { timeoutFailed: failedCount, cleaned: cleanupCount };
+        }
+        catch (error) {
+            const logPrefix = this.getLogPrefix();
+            console.error(`[${logPrefix}] Failed to recover stalled tasks:`, error);
+            return { timeoutFailed: 0, cleaned: 0 };
+        }
+    }
+}

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

@@ -0,0 +1,19 @@
+declare module './types' {
+    interface RedisQueueRegistry {
+        'test-queue': Record<string, any>;
+        'test-queue-error': Record<string, any>;
+        'short': Record<string, any>;
+        'valid-key': Record<string, any>;
+        'test-default': Record<string, any>;
+        'test-custom': Record<string, any>;
+        '': Record<string, any>;
+        'my-queue': Record<string, any>;
+        'test-error': Record<string, any>;
+        'test-bad': Record<string, any>;
+        'queue-one': Record<string, any>;
+        'queue-two': Record<string, any>;
+        [key: `test:reconnect:${number}`]: Record<string, any>;
+    }
+}
+export {};
+//# sourceMappingURL=redis-queue-common.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-queue-common.test.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue-common.test.ts"],"names":[],"mappings":"AAOA,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAU,kBAAkB;QAC1B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACjC,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACvC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QAC5B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QAChC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACnC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QAClC,EAAE,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACvB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QAC/B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QACjC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QAChC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;QAChC,CAAC,GAAG,EAAE,kBAAkB,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KACvD;CACF"}