@taicode/common-server 3.1.0 → 3.2.0

package/output/context/index.d.ts

@@ -0,0 +1,6 @@
+import type { FastifyBaseLogger, FastifyRequest } from 'fastify';
+export interface RequestContext {
+    log: FastifyBaseLogger;
+}
+export declare function createContext(request: FastifyRequest): RequestContext;
+//# sourceMappingURL=index.d.ts.map

package/output/context/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/context/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAEhE,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,iBAAiB,CAAA;CACvB;AAcD,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,cAAc,CAErE"}

package/output/context/index.js

@@ -0,0 +1,14 @@
+const fallbackLogger = {
+    trace: () => { },
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+    fatal: () => { },
+    child: () => fallbackLogger,
+    level: 'info',
+    silent: () => { },
+};
+export function createContext(request) {
+    return { log: request.log || fallbackLogger };
+}

package/output/context/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/output/context/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../source/context/index.test.ts"],"names":[],"mappings":""}

package/output/context/index.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { createContext } from './index.js';
+describe('createContext', () => {
+    it('uses the request logger when one is available', () => {
+        const log = { info: () => { } };
+        const context = createContext({ log });
+        expect(context.log).toBe(log);
+    });
+    it('provides a fallback logger for lightweight test requests', () => {
+        const context = createContext({ log: undefined });
+        expect(context.log.level).toBe('info');
+        expect(() => context.log.info('message')).not.toThrow();
+    });
+});

package/output/index.d.ts

@@ -1,3 +1,5 @@
 export * from './schema/index.js';
 export * from './redis-queue/index.js';
+export * from './rate-limiter/index.js';
+export * from './context/index.js';
 //# sourceMappingURL=index.d.ts.map

package/output/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,yBAAyB,CAAA;AACvC,cAAc,oBAAoB,CAAA"}

package/output/index.js

@@ -1,3 +1,5 @@
 // 根 index.ts，统一导出 mock 目录下所有能力
 export * from './schema/index.js';
 export * from './redis-queue/index.js';
+export * from './rate-limiter/index.js';
+export * from './context/index.js';

package/output/rate-limiter/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './rate-limiter.js';
+export * from './memory-store.js';
+//# sourceMappingURL=index.d.ts.map

package/output/rate-limiter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/rate-limiter/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,mBAAmB,CAAA"}

package/output/rate-limiter/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './rate-limiter.js';
+export * from './memory-store.js';

package/output/rate-limiter/memory-store.d.ts

@@ -0,0 +1,12 @@
+import type { RateLimitInfo, RateLimitStore } from './types.js';
+export declare class MemoryRateLimitStore implements RateLimitStore {
+    private store;
+    private cleanupInterval;
+    constructor(cleanupIntervalMs?: number);
+    get(key: string): Promise<RateLimitInfo | null>;
+    set(key: string, info: RateLimitInfo): Promise<void>;
+    delete(key: string): Promise<void>;
+    cleanup(): Promise<void>;
+    destroy(): void;
+}
+//# sourceMappingURL=memory-store.d.ts.map

package/output/rate-limiter/memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.d.ts","sourceRoot":"","sources":["../../source/rate-limiter/memory-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAO/D,qBAAa,oBAAqB,YAAW,cAAc;IACzD,OAAO,CAAC,KAAK,CAAsC;IACnD,OAAO,CAAC,eAAe,CAA8B;gBAEzC,iBAAiB,SAAQ;IAY/B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAY/C,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAKpD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAS9B,OAAO,IAAI,IAAI;CAOhB"}

package/output/rate-limiter/memory-store.js

@@ -0,0 +1,46 @@
+export class MemoryRateLimitStore {
+    store = new Map();
+    cleanupInterval = null;
+    constructor(cleanupIntervalMs = 60000) {
+        // 定期清理过期数据
+        this.cleanupInterval = setInterval(() => {
+            this.cleanup();
+        }, cleanupIntervalMs);
+        // 防止内存泄漏
+        if (this.cleanupInterval.unref) {
+            this.cleanupInterval.unref();
+        }
+    }
+    async get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() > entry.expiresAt) {
+            this.store.delete(key);
+            return null;
+        }
+        return entry.info;
+    }
+    async set(key, info) {
+        const expiresAt = info.windowEnd.getTime();
+        this.store.set(key, { info, expiresAt });
+    }
+    async delete(key) {
+        this.store.delete(key);
+    }
+    async cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.store.entries()) {
+            if (now > entry.expiresAt) {
+                this.store.delete(key);
+            }
+        }
+    }
+    destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.store.clear();
+    }
+}

package/output/rate-limiter/rate-limiter.d.ts

@@ -0,0 +1,17 @@
+import type { RateLimitConfig, RateLimitInfo, RateLimiterOptions, RateLimitResult } from './types.js';
+export declare class RateLimiter {
+    private store;
+    constructor(options?: RateLimiterOptions);
+    checkLimit(key: string, config: RateLimitConfig): Promise<RateLimitResult>;
+    resetLimit(key: string): Promise<void>;
+    getLimitInfo(key: string): Promise<RateLimitInfo | null>;
+    /**
+     * 检查多个限流键，取最严格的限制
+     */
+    checkMultiLimit(keys: string[], config: RateLimitConfig): Promise<RateLimitResult>;
+}
+/**
+ * 创建限流键的辅助函数
+ */
+export declare function createRateLimitKey(prefix: string, ...parts: string[]): string;
+//# sourceMappingURL=rate-limiter.d.ts.map

package/output/rate-limiter/rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../source/rate-limiter/rate-limiter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,kBAAkB,EAAE,eAAe,EAAkB,MAAM,YAAY,CAAA;AAGrH,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAgB;gBAEjB,OAAO,GAAE,kBAAuB;IAItC,UAAU,CACd,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,eAAe,CAAC;IAoCrB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAItC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAI9D;;OAEG;IACG,eAAe,CACnB,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,eAAe,CAAC;CAe5B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAE7E"}

package/output/rate-limiter/rate-limiter.js

@@ -0,0 +1,64 @@
+import { MemoryRateLimitStore } from './memory-store.js';
+export class RateLimiter {
+    store;
+    constructor(options = {}) {
+        this.store = options.store || new MemoryRateLimitStore();
+    }
+    async checkLimit(key, config) {
+        const now = new Date();
+        const windowStart = new Date(now.getTime());
+        const windowEnd = new Date(now.getTime() + config.window * 1000);
+        // 获取当前计数
+        let currentInfo = await this.store.get(key);
+        // 如果没有记录，或者窗口已过期，创建新记录
+        if (!currentInfo || currentInfo.windowEnd < now) {
+            currentInfo = {
+                count: 0,
+                windowStart,
+                windowEnd,
+            };
+        }
+        // 增加计数
+        currentInfo.count += 1;
+        // 保存到存储
+        await this.store.set(key, currentInfo);
+        // 计算是否允许
+        const allowed = currentInfo.count <= config.limit;
+        const remaining = Math.max(0, config.limit - currentInfo.count);
+        return {
+            allowed,
+            remaining,
+            resetAt: currentInfo.windowEnd,
+            limit: config.limit,
+            window: config.window,
+        };
+    }
+    async resetLimit(key) {
+        await this.store.delete(key);
+    }
+    async getLimitInfo(key) {
+        return await this.store.get(key);
+    }
+    /**
+     * 检查多个限流键，取最严格的限制
+     */
+    async checkMultiLimit(keys, config) {
+        let strictestResult = null;
+        for (const key of keys) {
+            const result = await this.checkLimit(key, config);
+            if (!strictestResult || !result.allowed) {
+                strictestResult = result;
+            }
+            else if (result.remaining < strictestResult.remaining) {
+                strictestResult = result;
+            }
+        }
+        return strictestResult;
+    }
+}
+/**
+ * 创建限流键的辅助函数
+ */
+export function createRateLimitKey(prefix, ...parts) {
+    return `rate-limit:${prefix}:${parts.join(':')}`;
+}

package/output/rate-limiter/types.d.ts

@@ -0,0 +1,27 @@
+export interface RateLimitInfo {
+    count: number;
+    windowStart: Date;
+    windowEnd: Date;
+}
+export interface RateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    resetAt: Date;
+    limit: number;
+    window: number;
+}
+export interface RateLimitStore {
+    get(key: string): Promise<RateLimitInfo | null>;
+    set(key: string, info: RateLimitInfo): Promise<void>;
+    delete(key: string): Promise<void>;
+    cleanup?(): Promise<void>;
+}
+export interface RateLimitConfig {
+    limit: number;
+    window: number;
+    lockout?: number;
+}
+export interface RateLimiterOptions {
+    store?: RateLimitStore;
+}
+//# sourceMappingURL=types.d.ts.map

package/output/rate-limiter/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../source/rate-limiter/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,IAAI,CAAA;IACjB,SAAS,EAAE,IAAI,CAAA;CAChB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,IAAI,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAAA;IAC/C,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACpD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClC,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,cAAc,CAAA;CACvB"}

package/output/rate-limiter/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taicode/common-server",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "author": "Alain",
   "license": "ISC",
   "description": "",
@@ -22,9 +22,9 @@
   },
   "scripts": {
     "test": "vitest run",
-    "build": "tsc -p tsconfig.json",
+    "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",
-    "dev": "tsc -p tsconfig.json --watch"
+    "dev": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json --watch"
   },
   "files": [
     "output"
@@ -32,14 +32,14 @@
   "peerDependencies": {
     "@taicode/common-base": "^3.1.0",
     "fastify": "^5.5.0",
-    "redis": "^5.10.0",
+    "redis": "^5.11.0",
     "zod": "^4.1.0"
   },
   "devDependencies": {
-    "@types/node": "^22.10.2",
-    "fastify": "^5.5.0",
-    "redis": "^5.10.0",
+    "@types/node": "^22.19.13",
+    "fastify": "^5.7.4",
+    "redis": "^5.11.0",
     "vitest": "^3.2.4",
-    "zod": "^4.1.0"
+    "zod": "^4.3.6"
   }
 }

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

@@ -1,85 +0,0 @@
-import { RedisQueueCommon } from './redis-queue-common';
-import type { BatchConsumerConfig, QueueStats, InferTaskData } from './types';
-/**
- * Redis 批量队列消费者
- *
- * 批量消费任务,每次处理多条
- *
- * @template K 队列键名类型
- *
- * @example
- * ```ts
- * interface EmailTask {
- *   to: string
- * }
- *
- * const consumer = new RedisBatchConsumer<EmailTask>({
- *   redisUrl: 'redis://localhost:6379',
- *   queueKey: 'email-queue',
- *   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 RedisBatchConsumer<K extends string = string> extends RedisQueueCommon<InferTaskData<K>> {
-    private consumerRunning;
-    private consumerInterval;
-    private recoveryInterval;
-    private processingBatches;
-    private readonly config;
-    constructor(config: BatchConsumerConfig<K>);
-    protected getLogPrefix(): string;
-    /**
-     * 连接 Redis 并自动启动消费者
-     */
-    connect(): Promise<void>;
-    /**
-     * 断开 Redis 连接并停止消费者
-     */
-    disconnect(): void;
-    /**
-     * 恢复超时的任务
-     * 检查 processing 队列中的任务，将超时的任务直接标记为失败
-     */
-    private recoverStalledTasks;
-    /**
-     * 批量处理任务
-     */
-    private processBatch;
-    /**
-     * 启动恢复机制
-     */
-    private startRecovery;
-    /**
-     * 停止恢复机制
-     */
-    private stopRecovery;
-    /**
-     * 启动消费者
-     */
-    private startConsumer;
-    /**
-     * 停止消费者
-     */
-    private stopConsumer;
-    /**
-     * 获取队列统计信息（O(1) 时间复杂度）
-     */
-    statistics(): Promise<QueueStats>;
-    /**
-     * 健康检查
-     */
-    health(): Promise<boolean>;
-}
-//# sourceMappingURL=redis-batch-consumer.d.ts.map

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

@@ -1 +0,0 @@
-{"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,EAA4C,UAAU,EAAE,aAAa,EAAY,MAAM,SAAS,CAAA;AAEjI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,kBAAkB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,gBAAgB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;IACnG,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;;;OAGG;YACW,mBAAmB;IAwDjC;;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"}

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

@@ -1,360 +0,0 @@
-import { catchIt } from '@taicode/common-base';
-import { RedisQueueCommon } from './redis-queue-common';
-/**
- * Redis 批量队列消费者
- *
- * 批量消费任务,每次处理多条
- *
- * @template K 队列键名类型
- *
- * @example
- * ```ts
- * interface EmailTask {
- *   to: string
- * }
- *
- * const consumer = new RedisBatchConsumer<EmailTask>({
- *   redisUrl: 'redis://localhost:6379',
- *   queueKey: 'email-queue',
- *   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 RedisBatchConsumer extends RedisQueueCommon {
-    consumerRunning = false;
-    consumerInterval = null;
-    recoveryInterval = null;
-    processingBatches = 0; // 当前正在处理的批次数
-    config;
-    constructor(config) {
-        // 验证必填参数
-        if (!config.handler) {
-            throw new Error('[RedisBatchConsumer] handler is required');
-        }
-        // 调用父类构造函数
-        super({
-            redisUrl: config.redisUrl,
-            redisClient: config.redisClient,
-            queueKey: config.queueKey,
-            cleanupDelay: config.cleanupDelay ?? 86400,
-        });
-        this.config = {
-            handler: config.handler,
-            queueKey: config.queueKey,
-            redisUrl: config.redisUrl,
-            redisClient: config.redisClient,
-            batchSize: config.batchSize ?? 10,
-            maxRetries: config.maxRetries ?? 3,
-            concurrency: config.concurrency ?? 1,
-            consumerInterval: config.consumerInterval ?? 1000,
-            processingTimeout: config.processingTimeout ?? 60000, // 60 seconds
-        };
-    }
-    getLogPrefix() {
-        return 'RedisBatchConsumer';
-    }
-    /**
-     * 连接 Redis 并自动启动消费者
-     */
-    async connect() {
-        await super.connect();
-        // 连接成功后启动消费者和恢复机制
-        this.startConsumer();
-        this.startRecovery();
-    }
-    /**
-     * 断开 Redis 连接并停止消费者
-     */
-    disconnect() {
-        this.stopConsumer();
-        this.stopRecovery();
-        super.disconnect();
-    }
-    /**
-     * 恢复超时的任务
-     * 检查 processing 队列中的任务，将超时的任务直接标记为失败
-     */
-    async recoverStalledTasks() {
-        if (!this.redis)
-            return;
-        try {
-            const processingTaskIds = await this.redis.lRange(this.processingQueue, 0, -1);
-            if (processingTaskIds.length === 0) {
-                return;
-            }
-            const now = Date.now();
-            let recoveredCount = 0;
-            for (const taskId of processingTaskIds) {
-                const task = await this.getTask(taskId);
-                if (!task) {
-                    // 任务不存在，从队列中移除
-                    await this.redis.lRem(this.processingQueue, 0, taskId);
-                    continue;
-                }
-                // 检查是否超时
-                const processingTime = now - (task.processingStartTime || now);
-                if (processingTime > this.config.processingTimeout) {
-                    console.log(`[RedisBatchConsumer] Task timeout: ${taskId} (processing time: ${processingTime}ms)`);
-                    const taskKey = `${this.queueKey}:task:${taskId}`;
-                    // 超时直接标记为失败
-                    task.status = 'failed';
-                    task.processingStartTime = undefined;
-                    // 使用 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.cleanupDelay.toString(), JSON.stringify(task), taskId],
-                    });
-                    console.error(`[RedisBatchConsumer] Task ${taskId} failed after timeout`);
-                    recoveredCount++;
-                }
-            }
-            if (recoveredCount > 0) {
-                console.log(`[RedisBatchConsumer] Recovered ${recoveredCount} timeout tasks`);
-            }
-        }
-        catch (error) {
-            console.error('[RedisBatchConsumer] Failed to recover stalled tasks:', error);
-        }
-    }
-    /**
-     * 批量处理任务
-     */
-    async processBatch(taskIds) {
-        this.processingBatches++;
-        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(`[RedisBatchConsumer] No valid tasks found in batch`);
-                return;
-            }
-            // 过滤出有效的待处理任务
-            const tasksToProcess = [];
-            for (const task of validTasks) {
-                // 检查状态
-                if (task.status !== 'pending') {
-                    console.log(`[RedisBatchConsumer] 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(`[RedisBatchConsumer] Batch completed: ${updatedCount} tasks`);
-            }
-            catch (error) {
-                console.error(`[RedisBatchConsumer] 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(`[RedisBatchConsumer] 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(`[RedisBatchConsumer] Task ${task.id} failed after ${task.maxRetries} retries`);
-                    }
-                }
-            }
-        }
-        finally {
-            this.processingBatches--;
-        }
-    }
-    /**
-     * 启动恢复机制
-     */
-    startRecovery() {
-        if (this.recoveryInterval || !this.redis) {
-            return;
-        }
-        // 立即执行一次恢复
-        this.recoverStalledTasks().catch(error => {
-            console.error('[RedisBatchConsumer] Initial recovery error:', error);
-        });
-        // 定期检查（每 10 秒检查一次）
-        this.recoveryInterval = setInterval(() => {
-            this.recoverStalledTasks().catch(error => {
-                console.error('[RedisBatchConsumer] Recovery error:', error);
-            });
-        }, 10000);
-        console.log('[RedisBatchConsumer] Recovery mechanism started');
-    }
-    /**
-     * 停止恢复机制
-     */
-    stopRecovery() {
-        if (this.recoveryInterval) {
-            clearInterval(this.recoveryInterval);
-            this.recoveryInterval = null;
-            console.log('[RedisBatchConsumer] Recovery mechanism stopped');
-        }
-    }
-    /**
-     * 启动消费者
-     */
-    startConsumer() {
-        if (this.consumerRunning || !this.redis) {
-            return;
-        }
-        this.consumerRunning = true;
-        console.log(`[RedisBatchConsumer] 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(`[RedisBatchConsumer] Unhandled error in processBatch:`, error);
-                    });
-                }
-            }
-            catch (error) {
-                console.error('[RedisBatchConsumer] Consumer error:', error);
-            }
-        }, this.config.consumerInterval);
-    }
-    /**
-     * 停止消费者
-     */
-    stopConsumer() {
-        if (this.consumerInterval) {
-            clearInterval(this.consumerInterval);
-            this.consumerInterval = null;
-        }
-        this.consumerRunning = false;
-        console.log('[RedisBatchConsumer] 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-batch-consumer.test.d.ts

@@ -1,7 +0,0 @@
-declare module './types' {
-    interface RedisQueueRegistry {
-        'test-queue': Record<string, any>;
-    }
-}
-export {};
-//# sourceMappingURL=redis-batch-consumer.test.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"redis-batch-consumer.test.d.ts","sourceRoot":"","sources":["../../source/redis-queue/redis-batch-consumer.test.ts"],"names":[],"mappings":"AAMA,OAAO,QAAQ,SAAS,CAAC;IACvB,UAAU,kBAAkB;QAC1B,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KAClC;CACF"}

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

@@ -1,265 +0,0 @@
-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/registry.d.ts

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