@taicode/common-server 1.0.12 → 1.0.13

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

@@ -1,243 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { catchIt } from '@taicode/common-base';
-import { BatchRedisQueue } from './batch-redis-queue';
-const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
-describe('BatchRedisQueue', () => {
-    const queues = [];
-    afterEach(async () => {
-        for (const queue of queues) {
-            try {
-                await queue.clear();
-            }
-            catch (error) {
-                // 忽略清理错误
-            }
-            queue.disconnect();
-        }
-        queues.length = 0;
-    });
-    const createQueue = (handler, options) => {
-        const uniqueKey = `test:batch:${Date.now()}:${Math.random()}`;
-        const queue = new BatchRedisQueue({
-            redisUrl: REDIS_URL,
-            queueKey: uniqueKey,
-            batchSize: 5,
-            consumerInterval: 100,
-            maxRetries: 2,
-            ...options,
-            handler,
-        });
-        queues.push(queue);
-        return queue;
-    };
-    describe('连接管理', () => {
-        it('应该能够成功连接和断开 Redis', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            const health = await queue.health();
-            expect(health).toBe(true);
-            queue.disconnect();
-        });
-    });
-    describe('批量任务处理', () => {
-        it('应该批量处理任务', async () => {
-            const processedBatches = [];
-            const queue = createQueue(async (dataList) => {
-                processedBatches.push(dataList.map(d => d.value));
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue(Array.from({ length: 10 }, (_, i) => ({ value: i })));
-            await new Promise(resolve => setTimeout(resolve, 2500));
-            expect(processedBatches.length).toBe(2); // 2 批，每批 5 个
-            expect(processedBatches[0].length).toBe(5);
-            expect(processedBatches[1].length).toBe(5);
-        });
-        it('应该能够处理大量任务', async () => {
-            let processedCount = 0;
-            const queue = createQueue(async (dataList) => {
-                processedCount += dataList.length;
-                return catchIt(() => { });
-            }, { batchSize: 50 });
-            await queue.connect();
-            await queue.enqueue(Array.from({ length: 200 }, (_, i) => ({ value: i })));
-            await new Promise(resolve => setTimeout(resolve, 6000));
-            expect(processedCount).toBe(200);
-        }, 10000);
-    });
-    describe('错误处理和重试', () => {
-        it('失败的批次应该自动重试', async () => {
-            let attemptCount = 0;
-            const queue = createQueue(async () => {
-                attemptCount++;
-                if (attemptCount < 2) {
-                    throw new Error('Simulated batch failure');
-                }
-                return catchIt(() => { });
-            }, { batchSize: 3 });
-            await queue.connect();
-            await queue.enqueue([{ value: 1 }, { value: 2 }]);
-            await new Promise(resolve => setTimeout(resolve, 3000));
-            expect(attemptCount).toBe(2);
-        });
-        it('超过最大重试次数应该标记为失败', async () => {
-            const queue = createQueue(async () => {
-                throw new Error('Always fails');
-            }, { batchSize: 2, maxRetries: 1 });
-            await queue.connect();
-            await queue.enqueue([{ value: 1 }, { value: 2 }]);
-            await new Promise(resolve => setTimeout(resolve, 2500));
-            const stats = await queue.statistics();
-            expect(stats.failed).toBe(2);
-        });
-    });
-    describe('幂等性', () => {
-        it('应该支持在 data 中指定 id 来实现幂等性', async () => {
-            let processCount = 0;
-            const queue = createQueue(async (dataList) => {
-                processCount += dataList.length;
-                return catchIt(() => { });
-            }, { batchSize: 10 });
-            await queue.connect();
-            await queue.enqueue({ id: 'unique-1', value: 1 });
-            await queue.enqueue({ id: 'unique-1', value: 2 });
-            await queue.enqueue({ id: 'unique-2', value: 3 });
-            await new Promise(resolve => setTimeout(resolve, 1500));
-            expect(processCount).toBe(2); // 只处理 unique-1 和 unique-2
-        });
-    });
-    describe('延迟处理', () => {
-        it('应该支持延迟批量处理', async () => {
-            const startTime = Date.now();
-            let processTime = 0;
-            const queue = createQueue(async (dataList) => {
-                processTime = Date.now() - startTime;
-                return catchIt(() => { });
-            }, { batchSize: 3, processingDelay: 2000 });
-            await queue.connect();
-            await queue.enqueue([{ value: 1 }, { value: 2 }, { value: 3 }]);
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            expect(processTime).toBe(0);
-            await new Promise(resolve => setTimeout(resolve, 2500));
-            expect(processTime).toBeGreaterThanOrEqual(1900);
-        });
-    });
-    describe('队列操作', () => {
-        it('应该正确返回队列统计信息', async () => {
-            const queue = createQueue(async () => {
-                await new Promise(resolve => setTimeout(resolve, 100));
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue(Array.from({ length: 10 }, (_, i) => ({ value: i })));
-            await new Promise(resolve => setTimeout(resolve, 50));
-            const stats1 = await queue.statistics();
-            expect(stats1.pending).toBeGreaterThan(0);
-            await new Promise(resolve => setTimeout(resolve, 3000));
-            const stats2 = await queue.statistics();
-            expect(stats2.completed).toBe(10);
-        });
-        it('应该能够清空队列', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            await queue.enqueue([{ value: 1 }, { value: 2 }]);
-            await queue.clear();
-            const stats = await queue.statistics();
-            expect(stats.pending).toBe(0);
-        });
-    });
-    describe('并发安全性', () => {
-        it('多个批量队列实例应该能安全地处理任务', async () => {
-            const queueKey = `test-batch-concurrent-${Date.now()}`;
-            let totalProcessed = 0;
-            const handler = async (dataList) => {
-                totalProcessed += dataList.length;
-                await new Promise(resolve => setTimeout(resolve, 100));
-                return catchIt(() => { });
-            };
-            const queue1 = new BatchRedisQueue({
-                redisUrl: REDIS_URL,
-                queueKey,
-                batchSize: 5,
-                handler,
-            });
-            const queue2 = new BatchRedisQueue({
-                redisUrl: REDIS_URL,
-                queueKey,
-                batchSize: 5,
-                handler,
-            });
-            queues.push(queue1, queue2);
-            await queue1.connect();
-            await queue2.connect();
-            await queue1.enqueue(Array.from({ length: 20 }, (_, i) => ({ value: i })));
-            await new Promise(resolve => setTimeout(resolve, 3000));
-            expect(totalProcessed).toBe(20);
-        });
-    });
-    describe('批量数据边界测试', () => {
-        it('应该能够处理包含大量数据的批次', async () => {
-            let receivedBatch = false;
-            const queue = createQueue(async (dataList) => {
-                expect(dataList.length).toBe(10);
-                dataList.forEach(data => {
-                    expect(data.content.length).toBe(1000);
-                });
-                receivedBatch = true;
-                return catchIt(() => { });
-            }, { batchSize: 10 });
-            await queue.connect();
-            await queue.enqueue(Array.from({ length: 10 }, () => ({
-                content: 'x'.repeat(1000)
-            })));
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            expect(receivedBatch).toBe(true);
-        });
-    });
-    describe('批量错误处理边界测试', () => {
-        it('批量处理失败应该重试所有任务', async () => {
-            let attemptCount = 0;
-            const queue = createQueue(async () => {
-                attemptCount++;
-                if (attemptCount < 2) {
-                    throw new Error('Batch processing failed');
-                }
-                return catchIt(() => { });
-            }, { batchSize: 3, maxRetries: 2 });
-            await queue.connect();
-            await queue.enqueue([{ value: 1 }, { value: 2 }, { value: 3 }]);
-            await new Promise(resolve => setTimeout(resolve, 3000));
-            expect(attemptCount).toBe(2);
-            const stats = await queue.statistics();
-            expect(stats.completed).toBe(3);
-        });
-        it('批量处理超过最大重试次数应该标记为失败', async () => {
-            let attemptCount = 0;
-            const queue = createQueue(async () => {
-                attemptCount++;
-                throw new Error('Always fails');
-            }, { batchSize: 3, maxRetries: 1 });
-            await queue.connect();
-            await queue.enqueue([{ value: 1 }, { value: 2 }, { value: 3 }]);
-            await new Promise(resolve => setTimeout(resolve, 3000));
-            expect(attemptCount).toBe(2); // 初始 + 1 次重试
-            const stats = await queue.statistics();
-            expect(stats.failed).toBe(3);
-        });
-    });
-    describe('批量延迟处理边界测试', () => {
-        it('延迟时间为 0 的批量任务应该立即处理', async () => {
-            const startTime = Date.now();
-            let processTime = 0;
-            const queue = createQueue(async () => {
-                processTime = Date.now() - startTime;
-                return catchIt(() => { });
-            }, { batchSize: 5, processingDelay: 0 });
-            await queue.connect();
-            await queue.enqueue(Array.from({ length: 5 }, (_, i) => ({ value: i })));
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            expect(processTime).toBeGreaterThan(0);
-            expect(processTime).toBeLessThan(2000);
-        });
-    });
-});

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

@@ -1,129 +0,0 @@
-import type { TaskQueueConfig, TaskData, Task, QueueStats } from './types';
-/**
- * 通用任务队列类（泛型）
- *
- * 提供基于 Redis 的任务队列功能，支持：
- * - 任务入队和持久化
- * - 自动重试机制
- * - 任务状态追踪
- * - 分布式消费
- *
- * @template T 任务数据类型
- *
- * @example
- * ```ts
- * interface EmailTask {
- *   to: string
- *   subject: string
- * }
- *
- * const queue = new RedisQueue<EmailTask>({
- *   redisUrl: 'redis://localhost:6379',
- *   queueKey: 'email-queue',
- *   concurrency: 5,
- *   handler: async (data) => {
- *     await sendEmail(data.to, data.subject)
- *     return catchIt(() => {})
- *   }
- * })
- *
- * // 连接 Redis（自动启动消费者）
- * await queue.connect()
- *
- * // 入队任务（自动开始处理）
- * await queue.enqueue({ to: 'user@example.com', subject: 'Hello' })
- *
- * // 获取队列统计信息（O(1) 时间复杂度）
- * const stats = await queue.statistics()
- * console.log(stats) // { pending: 5, processing: 2, completed: 2, failed: 1 }
- * ```
- */
-export declare class RedisQueue<T extends TaskData = TaskData> {
-    private consumerRunning;
-    private redis;
-    private consumerInterval;
-    private recoveryInterval;
-    private processingTasks;
-    private readonly config;
-    private readonly handler;
-    private readonly failedQueue;
-    private readonly pendingQueue;
-    private readonly processingQueue;
-    private readonly completedQueue;
-    constructor(config: TaskQueueConfig<string, T>);
-    /**
-     * 连接 Redis 并自动启动消费者
-     */
-    connect(): Promise<void>;
-    /**
-     * 断开 Redis 连接并停止消费者
-     */
-    disconnect(): void;
-    /**
-     * 将任务推入队列(支持单个或批量)
-     * @param data 任务数据(单个或数组)。可以在 data 中包含 `id` 字段来实现幂等性
-     *
-     * @example
-     * // 普通任务,自动生成 ID
-     * await queue.enqueue({ to: 'user@example.com' })
-     *
-     * // 幂等任务,手动指定 ID,重复提交会被忽略
-     * await queue.enqueue({ id: 'email-123', to: 'user@example.com' })
-     * await queue.enqueue({ id: 'email-123', to: 'user@example.com' }) // 会被跳过
-     */
-    enqueue(data: T[]): Promise<string[]>;
-    enqueue(data: T): Promise<string>;
-    /**
-     * 获取任务详情
-     */
-    getTask(taskId: string): Promise<Task<T> | null>;
-    /**
-     * 更新任务状态并移动到对应队列（原子操作）
-     */
-    private applyStatus;
-    /**
-     * 根据状态获取对应的队列键
-     */
-    private getQueueByStatus;
-    /**
-     * 恢复超时的任务
-     * 检查 processing 队列中的任务，将超时的任务重试或标记为失败
-     */
-    private recoverStalledTasks;
-    /**
-     * 处理单个任务
-     */
-    private processTask;
-    /**
-     * 启动恢复机制（内部方法，自动调用）
-     */
-    private startRecovery;
-    /**
-     * 停止恢复机制（内部方法，自动调用）
-     */
-    private stopRecovery;
-    /**
-     * 启动消费者（内部方法，自动调用）
-     */
-    private startConsumer;
-    /**
-     * 停止消费者（内部方法，自动调用）
-     */
-    private stopConsumer;
-    /**
-     * 获取队列统计信息
-     * 返回队列中各种状态任务的详细数量
-     *
-     * 使用分离队列设计，O(1) 时间复杂度
-     */
-    statistics(): Promise<QueueStats>;
-    /**
-     * 清空所有队列
-     */
-    clear(): Promise<void>;
-    /**
-     * 健康检查
-     */
-    health(): Promise<boolean>;
-}
-//# sourceMappingURL=redis-queue.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"redis-queue.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-queue.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAU,QAAQ,EAAE,IAAI,EAAe,UAAU,EAAE,MAAM,SAAS,CAAA;AAE/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,qBAAa,UAAU,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACnD,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,CAOtB;IACD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;IAGxC,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,eAAe,CAAC,MAAM,EAAE,CAAC,CAAC;IAiD9C;;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;IACH,OAAO,CAAC,gBAAgB;IAUxB;;;OAGG;YACW,mBAAmB;IA6EjC;;OAEG;YACW,WAAW;IA4EzB;;OAEG;IACH,OAAO,CAAC,aAAa;IAoBrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAQpB;;OAEG;IACH,OAAO,CAAC,aAAa;IA4ErB;;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"}