@jintianxiayu/cache-decorator 0.1.2 → 0.1.3

package/README.md

@@ -46,15 +46,15 @@ CacheProviderRegistry.register('memory', new MemoryCacheProvider());
 CacheProviderRegistry.setDefault('memory');
 
 class UserService {
-  @Cache('user-cache', { ttl: 60000 })
-  async getUser(id: number) {
-    return { id, name: 'test' };
-  }
-
-  @CacheEvict('user-cache')
-  async updateUser(id: number) {
-    return { id, updated: true };
-  }
+    @Cache('user-cache', { ttl: 60000 })
+    async getUser(id: number) {
+        return { id, name: 'test' };
+    }
+
+    @CacheEvict('user-cache')
+    async updateUser(id: number) {
+        return { id, updated: true };
+    }
 }
 ```
 
@@ -84,8 +84,6 @@ class UserService {
 }
 ```
 
-
-
 ## API
 
 ### @Cache(cacheName, options?)
@@ -96,9 +94,9 @@ class UserService {
 - `options.ttl`: 过期时间（秒）
 - `options.providerName`: 指定 CacheProvider
 - `options.key`: 自定义缓存 key，支持以下形式：
-  - `undefined/null`: 使用默认逻辑，基于方法参数生成 key
-  - `string`: 直接作为 key 值，格式为 `cacheName:keyValue`
-  - `function`: 接收方法参数数组，返回自定义字符串
+    - `undefined/null`: 使用默认逻辑，基于方法参数生成 key
+    - `string`: 直接作为 key 值，格式为 `cacheName:keyValue`
+    - `function`: 接收方法参数数组，返回自定义字符串
 
 ### @CacheEvict(cacheName, options?)
 
@@ -130,4 +128,4 @@ Redis 实现，适用于分布式场景。
 ```typescript
 import Redis from 'ioredis';
 const redisProvider = new RedisCacheProvider(new Redis());
-```
+```

package/jest.config.js

@@ -1,14 +1,11 @@
 module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  roots: ['<rootDir>'],
-  testMatch: ['**/test/**/*.test.ts'],
-  moduleFileExtensions: ['ts', 'js', 'json'],
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts'
-  ],
-  transform: {
-    '^.+\\.ts$': 'ts-jest'
-  }
-};
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    roots: ['<rootDir>'],
+    testMatch: ['**/test/**/*.test.ts'],
+    moduleFileExtensions: ['ts', 'js', 'json'],
+    collectCoverageFrom: ['src/**/*.ts', '!src/**/*.d.ts'],
+    transform: {
+        '^.+\\.ts$': 'ts-jest',
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jintianxiayu/cache-decorator",
-    "version": "0.1.2",
+    "version": "0.1.3",
     "description": "Method caching decorators for TypeScript",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
@@ -26,5 +26,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "357e736abbe6b25a707663c1b9e027b2e8b532a6"
+    "gitHead": "0518a4e3649799cc6c176dabfebeb86bd0891085"
 }

package/src/core/cache-provider-registry.ts

@@ -8,46 +8,46 @@ let defaultName: string | undefined;
  * 用于注册和获取不同类型的 CacheProvider
  */
 export class CacheProviderRegistry {
-  /**
-   * 注册缓存提供者
-   * @param name 提供者名称
-   * @param provider 缓存提供者实例
-   */
-  static register(name: string, provider: CacheProvider): void {
-    providers.set(name, provider);
-  }
-
-  /**
-   * 获取缓存提供者
-   * @param name 提供者名称，不指定则使用默认提供者
-   * @returns 缓存提供者实例
-   * @throws 未注册且无默认提供者时抛出错误
-   */
-  static get(name?: string): CacheProvider {
-    const providerName = name || defaultName;
-    if (!providerName) {
-      throw new Error('No CacheProvider registered and no default set');
+    /**
+     * 注册缓存提供者
+     * @param name 提供者名称
+     * @param provider 缓存提供者实例
+     */
+    static register(name: string, provider: CacheProvider): void {
+        providers.set(name, provider);
     }
-    const provider = providers.get(providerName);
-    if (!provider) {
-      throw new Error(`CacheProvider "${providerName}" not found`);
+
+    /**
+     * 获取缓存提供者
+     * @param name 提供者名称，不指定则使用默认提供者
+     * @returns 缓存提供者实例
+     * @throws 未注册且无默认提供者时抛出错误
+     */
+    static get(name?: string): CacheProvider {
+        const providerName = name || defaultName;
+        if (!providerName) {
+            throw new Error('No CacheProvider registered and no default set');
+        }
+        const provider = providers.get(providerName);
+        if (!provider) {
+            throw new Error(`CacheProvider "${providerName}" not found`);
+        }
+        return provider;
     }
-    return provider;
-  }
 
-  /**
-   * 设置默认缓存提供者
-   * @param name 提供者名称
-   */
-  static setDefault(name: string): void {
-    defaultName = name;
-  }
+    /**
+     * 设置默认缓存提供者
+     * @param name 提供者名称
+     */
+    static setDefault(name: string): void {
+        defaultName = name;
+    }
 
-  /**
-   * 清空注册表
-   */
-  static clear(): void {
-    providers.clear();
-    defaultName = undefined;
-  }
-}
+    /**
+     * 清空注册表
+     */
+    static clear(): void {
+        providers.clear();
+        defaultName = undefined;
+    }
+}

package/src/core/cache-provider.ts

@@ -3,35 +3,35 @@
  * 支持可插拔的缓存实现（Memory、Redis、自定义）
  */
 export interface CacheProvider {
-  /**
-   * 获取缓存值
-   * @param key 缓存键
-   * @returns 缓存值，不存在或已过期返回 undefined
-   */
-  get<T>(key: string): T | undefined | Promise<T | undefined>;
+    /**
+     * 获取缓存值
+     * @param key 缓存键
+     * @returns 缓存值，不存在或已过期返回 undefined
+     */
+    get<T>(key: string): T | undefined | Promise<T | undefined>;
 
-  /**
-   * 设置缓存值
-   * @param key 缓存键
-   * @param value 缓存值
-   * @param ttl 过期时间（秒），不设置则永不过期
-   */
-  set<T>(key: string, value: T, ttl?: number): void | Promise<void>;
+    /**
+     * 设置缓存值
+     * @param key 缓存键
+     * @param value 缓存值
+     * @param ttl 过期时间（秒），不设置则永不过期
+     */
+    set<T>(key: string, value: T, ttl?: number): void | Promise<void>;
 
-  /**
-   * 删除指定缓存
-   * @param key 缓存键
-   */
-  delete(key: string): void | Promise<void>;
+    /**
+     * 删除指定缓存
+     * @param key 缓存键
+     */
+    delete(key: string): void | Promise<void>;
 
-  /**
-   * 清除所有缓存
-   */
-  clear(): void | Promise<void>;
+    /**
+     * 清除所有缓存
+     */
+    clear(): void | Promise<void>;
 
-  /**
-   * 根据模式删除匹配的缓存键
-   * @param pattern glob模式字符串（如 user:*），末尾的 * 作为前缀匹配
-   */
-  deleteByPattern(pattern: string): void | Promise<void>;
-}
+    /**
+     * 根据模式删除匹配的缓存键
+     * @param pattern glob模式字符串（如 user:*），末尾的 * 作为前缀匹配
+     */
+    deleteByPattern(pattern: string): void | Promise<void>;
+}

package/src/core/key-builder.ts

@@ -3,29 +3,29 @@
  * 负责将缓存名称和参数转换为统一的 key 字符串
  */
 export class KeyBuilder {
-  /**
-   * 构建缓存 key
-   * @param cacheName 缓存名称
-   * @param args 方法参数列表
-   * @returns 格式为 {cacheName}:{serializedArgs} 的 key 字符串
-   */
-  static build(cacheName: string, args: unknown[]): string {
-    if (args.length === 0) {
-      return cacheName;
-    }
-    const serializedArgs = args
-      .map(arg => {
-        if (arg === null || arg === undefined) return 'null';
-        if (typeof arg === 'object') {
-          try {
-            return JSON.stringify(arg);
-          } catch {
-            return String(arg);
-          }
+    /**
+     * 构建缓存 key
+     * @param cacheName 缓存名称
+     * @param args 方法参数列表
+     * @returns 格式为 {cacheName}:{serializedArgs} 的 key 字符串
+     */
+    static build(cacheName: string, args: unknown[]): string {
+        if (args.length === 0) {
+            return cacheName;
         }
-        return String(arg);
-      })
-      .join('&');
-    return `${cacheName}:${serializedArgs}`;
-  }
-}
+        const serializedArgs = args
+            .map((arg) => {
+                if (arg === null || arg === undefined) return 'null';
+                if (typeof arg === 'object') {
+                    try {
+                        return JSON.stringify(arg);
+                    } catch {
+                        return String(arg);
+                    }
+                }
+                return String(arg);
+            })
+            .join('&');
+        return `${cacheName}:${serializedArgs}`;
+    }
+}

package/src/core/native-cache.ts

@@ -4,8 +4,8 @@ import { CacheProvider } from './cache-provider';
  * 缓存条目结构
  */
 interface CacheEntry<T> {
-  value: T;
-  expiresAt: number | null;
+    value: T;
+    expiresAt: number | null;
 }
 
 /**
@@ -13,41 +13,41 @@ interface CacheEntry<T> {
  * 适用于单机应用，缓存随进程重启清除
  */
 export class MemoryCacheProvider implements CacheProvider {
-  private cache = new Map<string, CacheEntry<unknown>>();
+    private cache = new Map<string, CacheEntry<unknown>>();
 
-  get<T>(key: string): T | undefined {
-    const entry = this.cache.get(key);
-    if (!entry) return undefined;
-    if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
-      this.cache.delete(key);
-      return undefined;
+    get<T>(key: string): T | undefined {
+        const entry = this.cache.get(key);
+        if (!entry) return undefined;
+        if (entry.expiresAt !== null && Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value as T;
     }
-    return entry.value as T;
-  }
 
-  set<T>(key: string, value: T, ttl?: number): void {
-    const expiresAt = ttl ? Date.now() + ttl * 1000 : null;
-    this.cache.set(key, { value, expiresAt });
-  }
+    set<T>(key: string, value: T, ttl?: number): void {
+        const expiresAt = ttl ? Date.now() + ttl * 1000 : null;
+        this.cache.set(key, { value, expiresAt });
+    }
 
-  delete(key: string): void {
-    this.cache.delete(key);
-  }
+    delete(key: string): void {
+        this.cache.delete(key);
+    }
 
-  clear(): void {
-    this.cache.clear();
-  }
+    clear(): void {
+        this.cache.clear();
+    }
 
-  /**
-   * 根据模式删除匹配的缓存键
-   * @param pattern glob模式字符串（如 user:*），末尾的 * 作为前缀匹配
-   */
-  deleteByPattern(pattern: string): void {
-    const prefix = pattern.replace(/\*$/, '');
-    for (const key of this.cache.keys()) {
-      if (key.startsWith(prefix)) {
-        this.cache.delete(key);
-      }
+    /**
+     * 根据模式删除匹配的缓存键
+     * @param pattern glob模式字符串（如 user:*），末尾的 * 作为前缀匹配
+     */
+    deleteByPattern(pattern: string): void {
+        const prefix = pattern.replace(/\*$/, '');
+        for (const key of this.cache.keys()) {
+            if (key.startsWith(prefix)) {
+                this.cache.delete(key);
+            }
+        }
     }
-  }
-}
+}

package/src/core/pending-cache.ts

@@ -3,24 +3,24 @@
  * 用于在并发场景下返回同一个 Promise，避免重复执行
  */
 export class PendingCache {
-  private pending = new Map<string, Promise<unknown>>();
+    private pending = new Map<string, Promise<unknown>>();
 
-  get<T>(key: string): Promise<T> | undefined {
-    return this.pending.get(key) as Promise<T> | undefined;
-  }
+    get<T>(key: string): Promise<T> | undefined {
+        return this.pending.get(key) as Promise<T> | undefined;
+    }
 
-  set<T>(key: string, promise: Promise<T>): void {
-    this.pending.set(key, promise);
-    promise.finally(() => {
-      this.pending.delete(key);
-    });
-  }
+    set<T>(key: string, promise: Promise<T>): void {
+        this.pending.set(key, promise);
+        promise.finally(() => {
+            this.pending.delete(key);
+        });
+    }
 
-  delete(key: string): void {
-    this.pending.delete(key);
-  }
+    delete(key: string): void {
+        this.pending.delete(key);
+    }
 
-  clear(): void {
-    this.pending.clear();
-  }
-}
+    clear(): void {
+        this.pending.clear();
+    }
+}

package/src/core/redis-cache.ts

@@ -6,57 +6,51 @@ import Redis from 'ioredis';
  * 适用于分布式场景，支持跨进程共享缓存
  */
 export class RedisCacheProvider implements CacheProvider {
-  private redis: Redis;
+    private redis: Redis;
 
-  constructor(redis?: Redis) {
-    this.redis = redis ?? new Redis();
-  }
+    constructor(redis?: Redis) {
+        this.redis = redis ?? new Redis();
+    }
 
-  async get<T>(key: string): Promise<T | undefined> {
-    const value = await this.redis.get(key);
-    if (value === null) return undefined;
-    try {
-      return JSON.parse(value) as T;
-    } catch {
-      return value as unknown as T;
+    async get<T>(key: string): Promise<T | undefined> {
+        const value = await this.redis.get(key);
+        if (value === null) return undefined;
+        try {
+            return JSON.parse(value) as T;
+        } catch {
+            return value as unknown as T;
+        }
     }
-  }
 
-  async set<T>(key: string, value: T, ttl?: number): Promise<void> {
-    const serialized = typeof value === 'string' ? value : JSON.stringify(value);
-    if (ttl) {
-      await this.redis.setex(key, ttl, serialized);
-    } else {
-      await this.redis.set(key, serialized);
+    async set<T>(key: string, value: T, ttl?: number): Promise<void> {
+        const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+        if (ttl) {
+            await this.redis.setex(key, ttl, serialized);
+        } else {
+            await this.redis.set(key, serialized);
+        }
     }
-  }
 
-  async delete(key: string): Promise<void> {
-    await this.redis.del(key);
-  }
+    async delete(key: string): Promise<void> {
+        await this.redis.del(key);
+    }
 
-  async clear(): Promise<void> {
-    await this.redis.flushdb();
-  }
+    async clear(): Promise<void> {
+        await this.redis.flushdb();
+    }
 
-  /**
-   * 根据模式删除匹配的缓存键
-   * @param pattern glob模式字符串（如 user:*），使用 SCAN 游标迭代避免阻塞 Redis
-   */
-  async deleteByPattern(pattern: string): Promise<void> {
-    let cursor = '0';
-    do {
-      const [nextCursor, keys] = await this.redis.scan(
-        cursor,
-        'MATCH',
-        pattern,
-        'COUNT',
-        100,
-      );
-      cursor = nextCursor;
-      if (keys.length > 0) {
-        await this.redis.del(...keys);
-      }
-    } while (cursor !== '0');
-  }
-}
+    /**
+     * 根据模式删除匹配的缓存键
+     * @param pattern glob模式字符串（如 user:*），使用 SCAN 游标迭代避免阻塞 Redis
+     */
+    async deleteByPattern(pattern: string): Promise<void> {
+        let cursor = '0';
+        do {
+            const [nextCursor, keys] = await this.redis.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+            cursor = nextCursor;
+            if (keys.length > 0) {
+                await this.redis.del(...keys);
+            }
+        } while (cursor !== '0');
+    }
+}

package/src/decorators/cache-evict.ts

@@ -6,15 +6,15 @@ import { CacheOptions, CacheKeyResolver } from './cache';
  * @CacheEvict 装饰器配置项
  */
 export interface CacheEvictOptions extends Pick<CacheOptions, 'key'> {
-  /**
-   * 是否清除所有条目，默认为 false
-   */
-  allEntries?: boolean;
+    /**
+     * 是否清除所有条目，默认为 false
+     */
+    allEntries?: boolean;
 
-  /**
-   * 指定 CacheProvider 名称
-   */
-  providerName?: string;
+    /**
+     * 指定 CacheProvider 名称
+     */
+    providerName?: string;
 }
 
 /**
@@ -25,17 +25,17 @@ export interface CacheEvictOptions extends Pick<CacheOptions, 'key'> {
  * @returns 解析后的缓存 key
  */
 function resolveCacheKey(cacheName: string, keyResolver: CacheKeyResolver | undefined, args: unknown[]): string {
-  if (keyResolver === undefined || keyResolver === null) {
-    return KeyBuilder.build(cacheName, args);
-  }
-  if (typeof keyResolver === 'string') {
-    return KeyBuilder.build(cacheName, [keyResolver]);
-  }
-  try {
-    return KeyBuilder.build(cacheName, [keyResolver(...args)]);
-  } catch {
-    return KeyBuilder.build(cacheName, args);
-  }
+    if (keyResolver === undefined || keyResolver === null) {
+        return KeyBuilder.build(cacheName, args);
+    }
+    if (typeof keyResolver === 'string') {
+        return KeyBuilder.build(cacheName, [keyResolver]);
+    }
+    try {
+        return KeyBuilder.build(cacheName, [keyResolver(...args)]);
+    } catch {
+        return KeyBuilder.build(cacheName, args);
+    }
 }
 
 /**
@@ -45,29 +45,25 @@ function resolveCacheKey(cacheName: string, keyResolver: CacheKeyResolver | unde
  * @param options 配置项
  */
 export function CacheEvict(cacheName: string, options?: CacheEvictOptions) {
-  return function (
-    _target: object,
-    _propertyKey: string,
-    descriptor: PropertyDescriptor,
-  ) {
-    const originalMethod = descriptor.value;
+    return function (_target: object, _propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
 
-    descriptor.value = async function (...args: unknown[]) {
-      const result = await originalMethod.apply(this, args);
+        descriptor.value = async function (...args: unknown[]) {
+            const result = await originalMethod.apply(this, args);
 
-      const providerName = options?.providerName;
-      const provider = CacheProviderRegistry.get(providerName);
+            const providerName = options?.providerName;
+            const provider = CacheProviderRegistry.get(providerName);
 
-      if (options?.allEntries) {
-        await provider.deleteByPattern(cacheName + '*');
-      } else {
-        const cacheKey = resolveCacheKey(cacheName, options?.key, args);
-        provider.delete(cacheKey);
-      }
+            if (options?.allEntries) {
+                await provider.deleteByPattern(cacheName + '*');
+            } else {
+                const cacheKey = resolveCacheKey(cacheName, options?.key, args);
+                provider.delete(cacheKey);
+            }
 
-      return result;
+            return result;
+        };
     };
-  };
 }
 
-export { CacheProviderRegistry } from '../core/cache-provider-registry';
+export { CacheProviderRegistry } from '../core/cache-provider-registry';