@taicode/common-server 3.7.11 → 3.7.13

package/output/index.d.ts

@@ -1,5 +1,6 @@
 export * from './schema/index.js';
 export * from './redis-queue/index.js';
+export * from './redis-cache/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;AACtC,cAAc,yBAAyB,CAAA;AACvC,cAAc,oBAAoB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../source/index.ts"],"names":[],"mappings":"AACA,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,wBAAwB,CAAA;AACtC,cAAc,yBAAyB,CAAA;AACvC,cAAc,oBAAoB,CAAA"}

package/output/index.js

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

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

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

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

@@ -1 +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"}
+{"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;AACjC,cAAc,kBAAkB,CAAA"}

package/output/rate-limiter/index.js

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

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

@@ -1 +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"}
+{"version":3,"file":"rate-limiter.d.ts","sourceRoot":"","sources":["../../source/rate-limiter/rate-limiter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,kBAAkB,EAAE,eAAe,EAAkB,MAAM,YAAY,CAAA;AAErH,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAgB;gBAEjB,OAAO,GAAE,kBAAuB;IAItC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;IAoC1E,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,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC;CAezF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAE7E"}

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

@@ -0,0 +1,45 @@
+import { type RedisClientType } from 'redis';
+import type { RateLimitInfo, RateLimitStore } from './types.js';
+export interface RedisRateLimitStoreOptions {
+    /** 键前缀，避免与其他用途的键混在一起 */
+    prefix?: string;
+    /** Redis 连接串；与 redisClient 二选一 */
+    redisUrl?: string;
+    /** 外部 Redis 客户端；与 redisUrl 二选一 */
+    redisClient?: RedisClientType;
+    /**
+     * Redis 不可用时的降级存储，默认使用进程内 MemoryRateLimitStore。
+     * 刻意不降级为「不限流」：多实例之间不再共享计数已经是能力损失，
+     * 但单实例内仍然能挡住突发，比彻底放行安全得多。
+     */
+    fallback?: RateLimitStore;
+}
+/**
+ * 基于 Redis 的限流存储。
+ *
+ * 与 MemoryRateLimitStore 保持完全相同的「固定窗口」语义：
+ * 窗口在第一次请求时开启，窗口结束时间写入存储并随窗口一起过期。
+ * 区别只在于计数放在 Redis 里，因此多副本部署下 limit 是全局生效的
+ * （进程内计数在 N 个副本下等于把 limit 放大了 N 倍）。
+ *
+ * 读改写之间存在极小的竞态窗口（并发请求可能少计一次），
+ * 对限流来说这种近似完全可接受，换来的是无需 Lua 脚本的简单实现。
+ */
+export declare class RedisRateLimitStore implements RateLimitStore {
+    private readonly prefix;
+    private readonly redis;
+    private readonly isExternalRedis;
+    private readonly fallback;
+    private lastErrorLogTime;
+    constructor(options?: RedisRateLimitStoreOptions);
+    connect(): Promise<void>;
+    disconnect(): void;
+    get(key: string): Promise<RateLimitInfo | null>;
+    set(key: string, info: RateLimitInfo): Promise<void>;
+    delete(key: string): Promise<void>;
+    /** Redis 的键自带过期时间，无需额外清理 */
+    cleanup(): Promise<void>;
+    private buildKey;
+    private logError;
+}
+//# sourceMappingURL=redis-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-store.d.ts","sourceRoot":"","sources":["../../source/rate-limiter/redis-store.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,OAAO,CAAA;AAG1D,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAE/D,MAAM,WAAW,0BAA0B;IACzC,wBAAwB;IACxB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,kCAAkC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,kCAAkC;IAClC,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAA;CAC1B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,mBAAoB,YAAW,cAAc;IACxD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+B;IACrD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiB;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAgB;IAEzC,OAAO,CAAC,gBAAgB,CAAI;gBAEhB,OAAO,GAAE,0BAA+B;IAyBvC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAK9B,UAAU,IAAI,IAAI;IAKZ,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAqB/C,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBpD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAY/C,4BAA4B;IACf,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrC,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,QAAQ;CAOjB"}

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

@@ -0,0 +1,114 @@
+import { createClient } from 'redis';
+import { logger } from '@taicode/common-base';
+import { MemoryRateLimitStore } from './memory-store.js';
+/**
+ * 基于 Redis 的限流存储。
+ *
+ * 与 MemoryRateLimitStore 保持完全相同的「固定窗口」语义：
+ * 窗口在第一次请求时开启，窗口结束时间写入存储并随窗口一起过期。
+ * 区别只在于计数放在 Redis 里，因此多副本部署下 limit 是全局生效的
+ * （进程内计数在 N 个副本下等于把 limit 放大了 N 倍）。
+ *
+ * 读改写之间存在极小的竞态窗口（并发请求可能少计一次），
+ * 对限流来说这种近似完全可接受，换来的是无需 Lua 脚本的简单实现。
+ */
+export class RedisRateLimitStore {
+    prefix;
+    redis = null;
+    isExternalRedis = false;
+    fallback;
+    lastErrorLogTime = 0;
+    constructor(options = {}) {
+        if (options.redisUrl && options.redisClient) {
+            throw new Error('[RedisRateLimitStore] Cannot specify both redisUrl and redisClient');
+        }
+        this.prefix = options.prefix ?? 'rate-limit:';
+        this.fallback = options.fallback ?? new MemoryRateLimitStore();
+        if (options.redisClient) {
+            this.redis = options.redisClient;
+            this.isExternalRedis = true;
+        }
+        else if (options.redisUrl) {
+            this.redis = createClient({
+                url: options.redisUrl,
+                socket: {
+                    connectTimeout: 5_000,
+                    reconnectStrategy: (retries) => Math.min(retries * 200, 3_000),
+                },
+            });
+            this.redis.on('error', (error) => {
+                logger.error('[RedisRateLimitStore] Redis Client Error:', error);
+            });
+        }
+    }
+    async connect() {
+        if (this.redis === null || this.isExternalRedis || this.redis.isOpen)
+            return;
+        await this.redis.connect();
+    }
+    disconnect() {
+        if (this.redis === null || this.isExternalRedis || !this.redis.isOpen)
+            return;
+        this.redis.disconnect();
+    }
+    async get(key) {
+        if (!this.redis?.isReady) {
+            return this.fallback.get(key);
+        }
+        try {
+            const raw = await this.redis.get(this.buildKey(key));
+            if (raw === null)
+                return null;
+            const info = JSON.parse(raw);
+            return {
+                count: info.count,
+                windowStart: new Date(info.windowStart),
+                windowEnd: new Date(info.windowEnd),
+            };
+        }
+        catch (error) {
+            this.logError('get', error);
+            return this.fallback.get(key);
+        }
+    }
+    async set(key, info) {
+        if (!this.redis?.isReady) {
+            return this.fallback.set(key, info);
+        }
+        const ttlSeconds = Math.ceil((info.windowEnd.getTime() - Date.now()) / 1000);
+        if (ttlSeconds <= 0)
+            return;
+        try {
+            await this.redis.set(this.buildKey(key), JSON.stringify(info), { EX: ttlSeconds });
+        }
+        catch (error) {
+            this.logError('set', error);
+            await this.fallback.set(key, info);
+        }
+    }
+    async delete(key) {
+        await this.fallback.delete(key);
+        if (!this.redis?.isReady)
+            return;
+        try {
+            await this.redis.del(this.buildKey(key));
+        }
+        catch (error) {
+            this.logError('delete', error);
+        }
+    }
+    /** Redis 的键自带过期时间，无需额外清理 */
+    async cleanup() {
+        await this.fallback.cleanup?.();
+    }
+    buildKey(key) {
+        return `${this.prefix}${key}`;
+    }
+    logError(operation, error) {
+        const now = Date.now();
+        if (now - this.lastErrorLogTime < 30_000)
+            return;
+        this.lastErrorLogTime = now;
+        logger.error(`[RedisRateLimitStore] ${operation} failed, fallback to memory store:`, error);
+    }
+}

package/output/rate-limiter/redis-store.test.d.ts

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

package/output/rate-limiter/redis-store.test.d.ts.map

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

package/output/rate-limiter/redis-store.test.js

@@ -0,0 +1,70 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { createRedisClient } from '../redis-cache/redis-cache.js';
+import { RateLimiter } from './rate-limiter.js';
+import { RedisRateLimitStore } from './redis-store.js';
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+describe('RedisRateLimitStore', () => {
+    let redis;
+    let store;
+    beforeEach(async () => {
+        redis = createRedisClient({ url: REDIS_URL });
+        await redis.connect();
+        store = new RedisRateLimitStore({ prefix: 'test:rate-limit:', redisClient: redis });
+        await store.delete('ip:1.2.3.4');
+    });
+    afterEach(async () => {
+        await store.delete('ip:1.2.3.4');
+        if (redis.isOpen)
+            redis.disconnect();
+    });
+    it('应该在窗口内累计计数', async () => {
+        await store.set('ip:1.2.3.4', {
+            count: 1,
+            windowStart: new Date(),
+            windowEnd: new Date(Date.now() + 60_000),
+        });
+        const info = await store.get('ip:1.2.3.4');
+        expect(info?.count).toBe(1);
+    });
+    it('应该让 RateLimiter 在多实例间共享计数', async () => {
+        const anotherStore = new RedisRateLimitStore({ prefix: 'test:rate-limit:', redisClient: redis });
+        const limiterA = new RateLimiter({ store });
+        const limiterB = new RateLimiter({ store: anotherStore });
+        const config = { limit: 2, window: 60 };
+        expect((await limiterA.checkLimit('ip:1.2.3.4', config)).allowed).toBe(true);
+        // 另一个「实例」能看到前一个实例的计数，因此第三次就被拦下
+        expect((await limiterB.checkLimit('ip:1.2.3.4', config)).allowed).toBe(true);
+        const third = await limiterA.checkLimit('ip:1.2.3.4', config);
+        expect(third.allowed).toBe(false);
+        expect(third.remaining).toBe(0);
+    });
+    it('应该为限流键设置与窗口一致的过期时间', async () => {
+        await store.set('ip:1.2.3.4', {
+            count: 1,
+            windowStart: new Date(),
+            windowEnd: new Date(Date.now() + 30_000),
+        });
+        const ttl = await redis.ttl('test:rate-limit:ip:1.2.3.4');
+        expect(ttl).toBeGreaterThan(0);
+        expect(ttl).toBeLessThanOrEqual(30);
+    });
+    it('窗口已过期时不应写入', async () => {
+        await store.set('ip:1.2.3.4', {
+            count: 1,
+            windowStart: new Date(Date.now() - 120_000),
+            windowEnd: new Date(Date.now() - 60_000),
+        });
+        expect(await redis.get('test:rate-limit:ip:1.2.3.4')).toBeNull();
+    });
+    it('Redis 不可用时应降级到进程内存储而不是放行', async () => {
+        redis.disconnect();
+        const result = await store.get('ip:1.2.3.4');
+        expect(result).toBeNull();
+        await store.set('ip:1.2.3.4', {
+            count: 3,
+            windowStart: new Date(),
+            windowEnd: new Date(Date.now() + 60_000),
+        });
+        expect((await store.get('ip:1.2.3.4'))?.count).toBe(3);
+    });
+});

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

@@ -0,0 +1,4 @@
+export { RedisCache, createRedisClient } from './redis-cache.js';
+export type { RedisCacheL1Options, RedisCacheOptions } from './redis-cache.js';
+export type { RedisClientType } from 'redis';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/redis-cache/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAChE,YAAY,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAE9E,YAAY,EAAE,eAAe,EAAE,MAAM,OAAO,CAAA"}

package/output/redis-cache/index.js

@@ -0,0 +1 @@
+export { RedisCache, createRedisClient } from './redis-cache.js';

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

@@ -0,0 +1,139 @@
+import { type RedisClientType } from 'redis';
+/**
+ * 进程内一级缓存配置。
+ *
+ * 一级缓存的意义是把「同一个进程内的高频重复读取」压缩到零网络开销：
+ * Redis 的一次 GET 大约 0.2~1ms，而进程内查表是纳秒级。
+ * 鉴权这类每请求都要走的路径，一级缓存带来的收益非常可观。
+ */
+export interface RedisCacheL1Options {
+    /**
+     * 一级缓存容量（条目数），默认 500。
+     * 达到容量后按 LRU 淘汰，因此只需保证「热点」能装下即可。
+     */
+    maxSize?: number;
+    /**
+     * 一级缓存存活时间（毫秒），默认 5000。
+     *
+     * 刻意比二级缓存短一个数量级：跨实例的失效通知依赖 Redis 的键删除，
+     * 一级缓存无法被其他实例感知，只能靠短 TTL 自然过期来收敛。
+     * 这也意味着一级缓存越短，权限变更生效越快。
+     */
+    ttlMs?: number;
+}
+export interface RedisCacheOptions {
+    /**
+     * 键前缀，通常形如 `account:`。
+     * 服务名 + 环境一起放进来可以避免不同服务、不同环境互相污染。
+     */
+    prefix: string;
+    /** Redis 连接串；与 redisClient 二选一 */
+    redisUrl?: string;
+    /** 外部 Redis 客户端（多个缓存共享同一条连接时使用）；与 redisUrl 二选一 */
+    redisClient?: RedisClientType;
+    /** 默认过期时间（秒），默认 300 */
+    defaultTtlSeconds?: number;
+    /**
+     * 空值（null / undefined）的过期时间（秒），默认 10。
+     * 空值必须缓存但必须短，否则「删除后立刻重建」的语义会被缓存彻底挡住（缓存穿透）。
+     */
+    nullTtlSeconds?: number;
+    /** 一级缓存配置；传 false 关闭一级缓存，默认为开启 */
+    l1?: RedisCacheL1Options | false;
+}
+/**
+ * Redis 缓存（可选带进程内一级缓存）。
+ *
+ * 设计原则：
+ * 1. **缓存故障绝不影响业务**：所有方法都不会抛出异常，Redis 不可用时
+ *    自动退化为「不带缓存的直读」或「仅一级缓存」，调用方无需 try/catch。
+ * 2. **一级缓存是可选加速层**：`l1` 关闭时退化为纯 Redis 缓存；
+ *    不传 `redisUrl`/`redisClient` 时退化为纯一级缓存（单测里就这么用）。
+ * 3. **空值也缓存**：防止不存在的 key 每次穿透到数据库。
+ * 4. **TTL 带抖动**：避免同一时刻写入的大量键同时过期，形成瞬时数据库尖峰。
+ */
+export declare class RedisCache {
+    private readonly prefix;
+    private readonly redis;
+    private readonly isExternalRedis;
+    private readonly defaultTtlSeconds;
+    private readonly nullTtlSeconds;
+    private readonly l1;
+    private readonly l1TtlMs;
+    /** 请求合并：同一个 key 的并发 miss 只触发一次 loader，防止缓存击穿 */
+    private readonly inFlight;
+    private lastErrorLogTime;
+    constructor(options: RedisCacheOptions);
+    /** 一级缓存条目数（未开启时为 0） */
+    get size(): number;
+    /** 一级缓存容量（未开启时为 0） */
+    get capacity(): number;
+    /** 二级缓存是否可用。不可用时所有操作都会安静地退化为直读，不会抛错。 */
+    get remoteReady(): boolean;
+    /**
+     * 建立连接。
+     * 外部传入的客户端由持有者负责连接，这里直接返回。
+     */
+    connect(): Promise<void>;
+    /** 断开连接（外部分享的客户端不会被断开） */
+    disconnect(): void;
+    /**
+     * 释放实例资源。
+     *
+     * 只清理进程内的东西，**不会**动 Redis：二级缓存是多实例共享的，
+     * 某个进程退出不应该把别人的缓存一起清掉。
+     */
+    dispose(): Promise<void>;
+    /**
+     * 清空一级缓存（同步），并尽力异步清空二级缓存里该前缀下的全部键。
+     * 二级缓存的清理不阻塞调用方，失败也不影响结果。
+     */
+    clear(): void;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    /**
+     * 按前缀批量删除。传空字符串表示清空当前缓存实例的全部键。
+     *
+     * 用于「改了一批数据，相关的缓存全部作废」的场景：
+     * 与其维护精细的依赖关系，不如按命名空间整体作废——
+     * 这类写操作本身频率很低，一次 SCAN 的代价可以接受。
+     */
+    deleteByPrefix(prefix: string): Promise<number>;
+    /**
+     * 读缓存，未命中时执行 loader 并回填。
+     *
+     * 并发调用同一个 key 时只会执行一次 loader（请求合并），
+     * 这是鉴权链路上最容易被打穿的场景：热点用户缓存刚失效，
+     * 同一瞬间几十个请求同时涌入。
+     */
+    getOrSet<T>(key: string, loader: () => Promise<T>, ttlSeconds?: number): Promise<T>;
+    /**
+     * 生成最终键。
+     * 注意：调用方传入的 key 里已经带了业务前缀（如 `user:`），
+     * 因此这里只负责拼接实例前缀。
+     */
+    private buildKey;
+    /** 以下两个方法接收「已经拼好前缀的最终键」，供 getOrSet 避免重复拼前缀 */
+    private getByCacheKey;
+    private setByCacheKey;
+    private getLocal;
+    private setLocal;
+    private resolveTtl;
+    private getLogPrefix;
+    private logError;
+}
+/**
+ * 创建 Redis 客户端。
+ *
+ * 与 RedisQueueCommon 保持同样的连接策略，但补了两点：
+ * - 连接超时受限，避免 Redis 不可达时启动流程被拖住；
+ * - 重连采用固定上限的退避，避免无意义的密集重试。
+ */
+export interface CreateRedisClientOptions {
+    url: string;
+    logPrefix?: string;
+    connectTimeoutMs?: number;
+}
+export declare function createRedisClient(options: CreateRedisClientOptions): RedisClientType;
+//# sourceMappingURL=redis-cache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"redis-cache.d.ts","sourceRoot":"","sources":["../../source/redis-cache/redis-cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,OAAO,CAAA;AAE1D;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAA;IACd,kCAAkC;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,kDAAkD;IAClD,WAAW,CAAC,EAAE,eAAe,CAAA;IAC7B,uBAAuB;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,kCAAkC;IAClC,EAAE,CAAC,EAAE,mBAAmB,GAAG,KAAK,CAAA;CACjC;AAaD;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAQ;IAC/B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA+B;IACrD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiB;IACjD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAQ;IAC1C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IAEvC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAA0B;IAC7C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAEhC,gDAAgD;IAChD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;IAE/D,OAAO,CAAC,gBAAgB,CAAI;gBAEhB,OAAO,EAAE,iBAAiB;IA6BtC,uBAAuB;IACvB,IAAW,IAAI,IAAI,MAAM,CAExB;IAED,sBAAsB;IACtB,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,wCAAwC;IACxC,IAAW,WAAW,IAAI,OAAO,CAEhC;IAED;;;OAGG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAOrC,0BAA0B;IACnB,UAAU,IAAI,IAAI;IAOzB;;;;;OAKG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrC;;;OAGG;IACI,KAAK,IAAI,IAAI;IAQP,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAItC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIjE,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa/C;;;;;;OAMG;IACU,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAwB5D;;;;;;OAMG;IACU,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IA6BhG;;;;OAIG;IACH,OAAO,CAAC,QAAQ;IAIhB,8CAA8C;YAChC,aAAa;YAmBb,aAAa;IAY3B,OAAO,CAAC,QAAQ;IAahB,OAAO,CAAC,QAAQ;IAUhB,OAAO,CAAC,UAAU;IAalB,OAAO,CAAC,YAAY;IAIpB,OAAO,CAAC,QAAQ;CAOjB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,wBAAwB;IACvC,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,eAAe,CAkBpF"}