@taicode/common-server 1.0.12 → 1.0.13

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

@@ -1,234 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { catchIt } from '@taicode/common-base';
-import { RedisQueue } from './redis-queue';
-const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
-describe('RedisQueue', () => {
-    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:queue:${Date.now()}:${Math.random()}`;
-        const queue = new RedisQueue({
-            redisUrl: REDIS_URL,
-            queueKey: uniqueKey,
-            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);
-        });
-        it('连接后应该自动启动消费者', async () => {
-            let processed = false;
-            const queue = createQueue(async () => {
-                processed = true;
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ test: true });
-            await new Promise(resolve => setTimeout(resolve, 300));
-            expect(processed).toBe(true);
-        });
-    });
-    describe('任务入队', () => {
-        it('应该成功将任务推入队列', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            const taskId = await queue.enqueue({ foo: 'bar' });
-            expect(taskId).toBeTruthy();
-            const stats = await queue.statistics();
-            expect(stats.pending).toBeGreaterThan(0);
-        });
-        it('应该能够批量入队任务', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            const taskIds = await queue.enqueue([
-                { value: 1 },
-                { value: 2 },
-                { value: 3 },
-            ]);
-            expect(taskIds).toHaveLength(3);
-            const stats = await queue.statistics();
-            expect(stats.pending + stats.processing).toBe(3);
-        });
-        it('入队的任务应该包含正确的元数据', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            const taskId = await queue.enqueue({ test: 'data', number: 42 });
-            const task = await queue.getTask(taskId);
-            expect(task).toBeTruthy();
-            expect(task?.id).toBe(taskId);
-            expect(task?.data).toEqual({ test: 'data', number: 42 });
-            expect(task?.status).toBe('pending');
-            expect(task?.retryCount).toBe(0);
-            expect(task?.maxRetries).toBe(2);
-        });
-    });
-    describe('任务处理', () => {
-        it('应该成功处理任务', async () => {
-            const processedData = [];
-            const queue = createQueue(async (data) => {
-                processedData.push(data);
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ value: 'test' });
-            await new Promise(resolve => setTimeout(resolve, 500));
-            expect(processedData).toHaveLength(1);
-            expect(processedData[0]).toEqual({ value: 'test' });
-        });
-        it('应该按 FIFO 顺序处理任务', async () => {
-            const processOrder = [];
-            const queue = createQueue(async (data) => {
-                processOrder.push(data.order);
-                await new Promise(resolve => setTimeout(resolve, 50));
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ order: 1 });
-            await new Promise(resolve => setTimeout(resolve, 10));
-            await queue.enqueue({ order: 2 });
-            await new Promise(resolve => setTimeout(resolve, 10));
-            await queue.enqueue({ order: 3 });
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            expect(processOrder).toEqual([1, 2, 3]);
-        });
-    });
-    describe('错误处理和重试', () => {
-        it('失败的任务应该自动重试', async () => {
-            let attemptCount = 0;
-            const queue = createQueue(async () => {
-                attemptCount++;
-                if (attemptCount < 2) {
-                    throw new Error('Simulated failure');
-                }
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ test: 'retry' });
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            expect(attemptCount).toBe(2);
-        });
-        it('超过最大重试次数应该标记为失败', async () => {
-            let attemptCount = 0;
-            const queue = createQueue(async () => {
-                attemptCount++;
-                throw new Error('Always fails');
-            });
-            await queue.connect();
-            const taskId = await queue.enqueue({ test: 'fail' });
-            await new Promise(resolve => setTimeout(resolve, 1500));
-            expect(attemptCount).toBe(3); // 初始 + 2 次重试
-            const task = await queue.getTask(taskId);
-            expect(task?.status).toBe('failed');
-        });
-    });
-    describe('消费者管理', () => {
-        it('断开连接后消费者应该停止', async () => {
-            let processCount = 0;
-            const queue = createQueue(async () => {
-                processCount++;
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue({ test: 1 });
-            await new Promise(resolve => setTimeout(resolve, 300));
-            expect(processCount).toBe(1);
-            queue.disconnect();
-            await queue.connect();
-            await queue.enqueue({ test: 2 });
-            await new Promise(resolve => setTimeout(resolve, 300));
-            expect(processCount).toBe(2);
-        });
-    });
-    describe('队列操作', () => {
-        it('应该正确返回队列统计信息', async () => {
-            const queue = createQueue(async () => {
-                await new Promise(resolve => setTimeout(resolve, 100));
-                return catchIt(() => { });
-            });
-            await queue.connect();
-            await queue.enqueue([{ data: 1 }, { data: 2 }, { data: 3 }]);
-            await new Promise(resolve => setTimeout(resolve, 50));
-            const stats = await queue.statistics();
-            expect(stats.pending + stats.processing).toBeGreaterThan(0);
-        });
-        it('应该能够清空队列', async () => {
-            const queue = createQueue(async () => catchIt(() => { }));
-            await queue.connect();
-            await queue.enqueue([{ data: 1 }, { data: 2 }]);
-            await queue.clear();
-            const stats = await queue.statistics();
-            expect(stats.pending).toBe(0);
-        });
-    });
-    describe('并发处理', () => {
-        it('应该支持并发处理多个任务', async () => {
-            const processing = [];
-            const completed = [];
-            const queue = createQueue(async (data) => {
-                processing.push(data.taskId);
-                await new Promise(resolve => setTimeout(resolve, 200));
-                completed.push(data.taskId);
-                return catchIt(() => { });
-            }, { concurrency: 3 });
-            await queue.connect();
-            await queue.enqueue([
-                { taskId: 1 }, { taskId: 2 }, { taskId: 3 }, { taskId: 4 }, { taskId: 5 },
-            ]);
-            await new Promise(resolve => setTimeout(resolve, 250));
-            expect(processing.length).toBeGreaterThanOrEqual(2);
-            await new Promise(resolve => setTimeout(resolve, 1500));
-            expect(completed.length).toBe(5);
-        });
-    });
-    describe('幂等性', () => {
-        it('应该支持在 data 中指定 id 来实现幂等性', async () => {
-            let processCount = 0;
-            const queue = createQueue(async () => {
-                processCount++;
-                return catchIt(() => { });
-            });
-            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, 1000));
-            expect(processCount).toBe(2); // 只处理 unique-1 和 unique-2
-        });
-    });
-    describe('延迟处理', () => {
-        it('应该支持延迟处理任务', async () => {
-            const startTime = Date.now();
-            let processTime = 0;
-            const queue = createQueue(async () => {
-                processTime = Date.now() - startTime;
-                return catchIt(() => { });
-            }, { processingDelay: 2000 });
-            await queue.connect();
-            await queue.enqueue({ test: true });
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            expect(processTime).toBe(0); // 还未处理
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            expect(processTime).toBeGreaterThanOrEqual(1900);
-        });
-    });
-});

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

@@ -1,57 +0,0 @@
-/**
- * 全局队列注册表
- *
- * 使用 interface 合并模式来定义队列键和对应的任务数据类型
- *
- * @example
- * ```ts
- * // 在项目中声明队列类型
- * declare module '@taicode/common-server' {
- *   interface QueueRegistry {
- *     'email-queue': { to: string; subject: string; body: string }
- *     'sms-queue': { phone: string; message: string }
- *     'payment-queue': { orderId: string; amount: number }
- *   }
- * }
- *
- * // 使用时会有完整的类型提示和检查
- * const provider = new RedisQueueProvider<'email-queue'>({
- *   redisUrl: 'redis://localhost:6379',
- *   queueKey: 'email-queue', // 类型安全
- * })
- *
- * await provider.enqueue({
- *   to: 'user@example.com', // 类型检查
- *   subject: 'Hello',
- *   body: 'World'
- * })
- * ```
- */
-/**
- * 队列注册表接口
- *
- * 通过 interface 合并机制，允许在项目中扩展队列定义
- */
-export interface RedisQueueRegistry {
-}
-/**
- * 从注册表中提取队列键类型
- */
-export type RegisteredRedisQueueKey = keyof RedisQueueRegistry;
-/**
- * 根据队列键获取对应的任务数据类型
- */
-export type RedisQueueTaskData<K extends RegisteredRedisQueueKey> = RedisQueueRegistry[K];
-/**
- * 类型安全的队列键
- * 如果注册表为空，允许使用任意字符串；否则只允许注册的键
- */
-export type SafeRedisQueueKey<K extends string = string> = RegisteredRedisQueueKey extends never ? K : K extends RegisteredRedisQueueKey ? K : never;
-/**
- * 根据队列键推断任务数据类型
- *
- * - 如果键在注册表中，使用注册表中的类型
- * - 否则使用泛型参数 T
- */
-export type InferRedisQueueTaskData<K extends string, T extends Record<string, unknown> = Record<string, unknown>> = K extends RegisteredRedisQueueKey ? RedisQueueTaskData<K> : T;
-//# sourceMappingURL=registry.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../source/redis-queue/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;;;GAIG;AAEH,MAAM,WAAW,kBAAkB;CAKlC;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,kBAAkB,CAAA;AAE9D;;GAEG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,SAAS,uBAAuB,IAAI,kBAAkB,CAAC,CAAC,CAAC,CAAA;AAEzF;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IACrD,uBAAuB,SAAS,KAAK,GACjC,CAAC,GACD,CAAC,SAAS,uBAAuB,GAC/B,CAAC,GACD,KAAK,CAAA;AAEb;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,CACjC,CAAC,SAAS,MAAM,EAChB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IACzD,CAAC,SAAS,uBAAuB,GACjC,kBAAkB,CAAC,CAAC,CAAC,GACrB,CAAC,CAAA"}

package/output/redis-queue/registry.js

@@ -1,30 +0,0 @@
-/**
- * 全局队列注册表
- *
- * 使用 interface 合并模式来定义队列键和对应的任务数据类型
- *
- * @example
- * ```ts
- * // 在项目中声明队列类型
- * declare module '@taicode/common-server' {
- *   interface QueueRegistry {
- *     'email-queue': { to: string; subject: string; body: string }
- *     'sms-queue': { phone: string; message: string }
- *     'payment-queue': { orderId: string; amount: number }
- *   }
- * }
- *
- * // 使用时会有完整的类型提示和检查
- * const provider = new RedisQueueProvider<'email-queue'>({
- *   redisUrl: 'redis://localhost:6379',
- *   queueKey: 'email-queue', // 类型安全
- * })
- *
- * await provider.enqueue({
- *   to: 'user@example.com', // 类型检查
- *   subject: 'Hello',
- *   body: 'World'
- * })
- * ```
- */
-export {};