@jintianxiayu/cache-decorator 0.1.2 → 0.1.3

package/src/decorators/cache.ts

@@ -15,37 +15,37 @@ export type CacheKeyResolver = null | string | ((...args: unknown[]) => string);
  * @Cache 装饰器配置项
  */
 export interface CacheOptions {
-  /**
-   * 过期时间（秒）
-   */
-  ttl?: number;
-
-  /**
-   * 指定 CacheProvider 名称
-   */
-  providerName?: string;
-
-  /**
-   * 自定义缓存 key 生成逻辑
-   * - undefined/null: 使用默认逻辑 KeyBuilder.build(cacheName, args)
-   * - string: 使用 KeyBuilder.build(cacheName, [key])
-   * - function: 调用函数后使用 KeyBuilder.build(cacheName, [result])
-   */
-  key?: CacheKeyResolver;
+    /**
+     * 过期时间（秒）
+     */
+    ttl?: number;
+
+    /**
+     * 指定 CacheProvider 名称
+     */
+    providerName?: string;
+
+    /**
+     * 自定义缓存 key 生成逻辑
+     * - undefined/null: 使用默认逻辑 KeyBuilder.build(cacheName, args)
+     * - string: 使用 KeyBuilder.build(cacheName, [key])
+     * - function: 调用函数后使用 KeyBuilder.build(cacheName, [result])
+     */
+    key?: CacheKeyResolver;
 }
 
 /**
  * 成功缓存条目
  */
 interface SuccessCacheEntry<T> {
-  value: T;
+    value: T;
 }
 
 /**
  * 错误缓存条目
  */
 interface ErrorCacheEntry {
-  error: unknown;
+    error: unknown;
 }
 
 /**
@@ -63,17 +63,17 @@ const pendingCache = new PendingCache();
  * @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);
+    }
 }
 
 /**
@@ -83,47 +83,43 @@ function resolveCacheKey(cacheName: string, keyResolver: CacheKeyResolver | unde
  * @param options 配置项
  */
 export function Cache(cacheName: string, options?: CacheOptions) {
-  return function <T>(
-    _target: object,
-    _propertyKey: string,
-    descriptor: PropertyDescriptor,
-  ) {
-    const originalMethod = descriptor.value;
-
-    descriptor.value = async function (...args: unknown[]) {
-      const cacheKey = resolveCacheKey(cacheName, options?.key, args);
-      const providerName = options?.providerName;
-      const provider = CacheProviderRegistry.get(providerName);
-
-      const cached = await provider.get(cacheKey);
-      if (cached !== undefined) {
-        const entry = cached as CacheEntry<T>;
-        if ('error' in entry) {
-          throw entry.error;
-        }
-        return entry.value;
-      }
-
-      const pending = pendingCache.get<T>(cacheKey);
-      if (pending) {
-        return pending;
-      }
-
-      const promise = (async () => {
-        try {
-          const result = await originalMethod.apply(this, args);
-          provider.set(cacheKey, { value: result } as CacheEntry<T>, options?.ttl);
-          return result;
-        } catch (error) {
-          provider.set(cacheKey, { error } as CacheEntry<T>, options?.ttl);
-          throw error;
-        }
-      })();
-
-      pendingCache.set(cacheKey, promise);
-      return promise;
+    return function <T>(_target: object, _propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+
+        descriptor.value = async function (...args: unknown[]) {
+            const cacheKey = resolveCacheKey(cacheName, options?.key, args);
+            const providerName = options?.providerName;
+            const provider = CacheProviderRegistry.get(providerName);
+
+            const cached = await provider.get(cacheKey);
+            if (cached !== undefined) {
+                const entry = cached as CacheEntry<T>;
+                if ('error' in entry) {
+                    throw entry.error;
+                }
+                return entry.value;
+            }
+
+            const pending = pendingCache.get<T>(cacheKey);
+            if (pending) {
+                return pending;
+            }
+
+            const promise = (async () => {
+                try {
+                    const result = await originalMethod.apply(this, args);
+                    provider.set(cacheKey, { value: result } as CacheEntry<T>, options?.ttl);
+                    return result;
+                } catch (error) {
+                    provider.set(cacheKey, { error } as CacheEntry<T>, options?.ttl);
+                    throw error;
+                }
+            })();
+
+            pendingCache.set(cacheKey, promise);
+            return promise;
+        };
     };
-  };
 }
 
-export { CacheProviderRegistry } from '../core/cache-provider-registry';
+export { CacheProviderRegistry } from '../core/cache-provider-registry';

package/src/index.ts

@@ -1,4 +1,3 @@
-
 export * from './core/cache-provider';
 export * from './core/cache-provider-registry';
 export * from './core/key-builder';

package/test/cache-evict.test.ts

@@ -4,175 +4,175 @@ import { CacheProviderRegistry } from '../src/core/cache-provider-registry';
 import { MemoryCacheProvider } from '../src/core/native-cache';
 
 describe('@CacheEvict 装饰器', () => {
-  let memoryProvider: MemoryCacheProvider;
-
-  beforeAll(() => {
-    memoryProvider = new MemoryCacheProvider();
-    CacheProviderRegistry.register('memory', memoryProvider);
-    CacheProviderRegistry.setDefault('memory');
-  });
-
-  afterEach(() => {
-    memoryProvider.clear();
-  });
-
-  describe('按入参清除', () => {
-    it('应清除对应缓存条目', async () => {
-      let getUserCallCount = 0;
-      let updateUserCallCount = 0;
-
-      class UserService {
-        @Cache('user-cache')
-        async getUser(id: number) {
-          getUserCallCount++;
-          return { id };
-        }
-
-        @CacheEvict('user-cache')
-        async updateUser(id: number) {
-          updateUserCallCount++;
-          return { id, updated: true };
-        }
-      }
-
-      const service = new UserService();
-      await service.getUser(1);
-      await service.getUser(1);
-      expect(getUserCallCount).toBe(1);
-
-      await service.updateUser(1);
-      await service.getUser(1);
-      expect(getUserCallCount).toBe(2);
-      expect(updateUserCallCount).toBe(1);
+    let memoryProvider: MemoryCacheProvider;
+
+    beforeAll(() => {
+        memoryProvider = new MemoryCacheProvider();
+        CacheProviderRegistry.register('memory', memoryProvider);
+        CacheProviderRegistry.setDefault('memory');
     });
-  });
-
-  describe('清除所有条目', () => {
-    it('应清除该缓存名称下所有条目', async () => {
-      let getUserCallCount = 0;
-      let getOrderCallCount = 0;
-      let clearCallCount = 0;
-
-      class Service {
-        @Cache('user-cache')
-        async getUser(id: number) {
-          getUserCallCount++;
-          return { id };
-        }
-
-        @Cache('order-cache')
-        async getOrder(id: number) {
-          getOrderCallCount++;
-          return { id };
-        }
-
-        @CacheEvict('user-cache', { allEntries: true })
-        async clearAllUsers() {
-          clearCallCount++;
-          return true;
-        }
-      }
-
-      const service = new Service();
-      await service.getUser(1);
-      await service.getUser(2);
-      await service.getOrder(1);
-      expect(getUserCallCount).toBe(2);
-      expect(getOrderCallCount).toBe(1);
-
-      await service.clearAllUsers();
-      expect(clearCallCount).toBe(1);
-
-      await service.getUser(1);
-      await service.getUser(2);
-      await service.getOrder(1);
-      expect(getUserCallCount).toBe(4);
-      expect(getOrderCallCount).toBe(1);
+
+    afterEach(() => {
+        memoryProvider.clear();
     });
-  });
-
-  describe('key 选项', () => {
-    it('key 为字符串时应删除对应缓存条目', async () => {
-      let getUserCallCount = 0;
-
-      class UserService {
-        @Cache('user-cache', { key: 'all-users' })
-        async getUsers() {
-          getUserCallCount++;
-          return [{ id: 1 }, { id: 2 }];
-        }
-
-        @CacheEvict('user-cache', { key: 'all-users' })
-        async clearUsers() {
-          return true;
-        }
-      }
-
-      const service = new UserService();
-      await service.getUsers();
-      await service.getUsers();
-      expect(getUserCallCount).toBe(1);
-
-      await service.clearUsers();
-      await service.getUsers();
-      expect(getUserCallCount).toBe(2);
+
+    describe('按入参清除', () => {
+        it('应清除对应缓存条目', async () => {
+            let getUserCallCount = 0;
+            let updateUserCallCount = 0;
+
+            class UserService {
+                @Cache('user-cache')
+                async getUser(id: number) {
+                    getUserCallCount++;
+                    return { id };
+                }
+
+                @CacheEvict('user-cache')
+                async updateUser(id: number) {
+                    updateUserCallCount++;
+                    return { id, updated: true };
+                }
+            }
+
+            const service = new UserService();
+            await service.getUser(1);
+            await service.getUser(1);
+            expect(getUserCallCount).toBe(1);
+
+            await service.updateUser(1);
+            await service.getUser(1);
+            expect(getUserCallCount).toBe(2);
+            expect(updateUserCallCount).toBe(1);
+        });
     });
 
-    it('key 为函数时应使用函数返回值删除缓存条目', async () => {
-      let getUserCallCount = 0;
-
-      class UserService {
-        @Cache('user-cache', { key: (...args: unknown[]) => String(args[0]) })
-        async getUser(id: number) {
-          getUserCallCount++;
-          return { id };
-        }
-
-        @CacheEvict('user-cache', { key: (...args: unknown[]) => String(args[0]) })
-        async deleteUser(id: number) {
-          return { id, deleted: true };
-        }
-      }
-
-      const service = new UserService();
-      await service.getUser(1);
-      await service.getUser(2);
-      expect(getUserCallCount).toBe(2);
-
-      await service.deleteUser(1);
-      await service.getUser(1);
-      await service.getUser(2);
-      expect(getUserCallCount).toBe(3);
+    describe('清除所有条目', () => {
+        it('应清除该缓存名称下所有条目', async () => {
+            let getUserCallCount = 0;
+            let getOrderCallCount = 0;
+            let clearCallCount = 0;
+
+            class Service {
+                @Cache('user-cache')
+                async getUser(id: number) {
+                    getUserCallCount++;
+                    return { id };
+                }
+
+                @Cache('order-cache')
+                async getOrder(id: number) {
+                    getOrderCallCount++;
+                    return { id };
+                }
+
+                @CacheEvict('user-cache', { allEntries: true })
+                async clearAllUsers() {
+                    clearCallCount++;
+                    return true;
+                }
+            }
+
+            const service = new Service();
+            await service.getUser(1);
+            await service.getUser(2);
+            await service.getOrder(1);
+            expect(getUserCallCount).toBe(2);
+            expect(getOrderCallCount).toBe(1);
+
+            await service.clearAllUsers();
+            expect(clearCallCount).toBe(1);
+
+            await service.getUser(1);
+            await service.getUser(2);
+            await service.getOrder(1);
+            expect(getUserCallCount).toBe(4);
+            expect(getOrderCallCount).toBe(1);
+        });
     });
 
-    it('allEntries 为 true 时忽略 key 选项', async () => {
-      let getUserCallCount = 0;
-      let clearCallCount = 0;
-
-      class UserService {
-        @Cache('user-cache', { key: 'specific-key' })
-        async getUsers() {
-          getUserCallCount++;
-          return [];
-        }
-
-        @CacheEvict('user-cache', { allEntries: true, key: 'ignored-key' })
-        async clearAllUsers() {
-          clearCallCount++;
-          return true;
-        }
-      }
-
-      const service = new UserService();
-      await service.getUsers();
-      await service.getUsers();
-      expect(getUserCallCount).toBe(1);
-
-      await service.clearAllUsers();
-      expect(clearCallCount).toBe(1);
-
-      await service.getUsers();
-      expect(getUserCallCount).toBe(2);
+    describe('key 选项', () => {
+        it('key 为字符串时应删除对应缓存条目', async () => {
+            let getUserCallCount = 0;
+
+            class UserService {
+                @Cache('user-cache', { key: 'all-users' })
+                async getUsers() {
+                    getUserCallCount++;
+                    return [{ id: 1 }, { id: 2 }];
+                }
+
+                @CacheEvict('user-cache', { key: 'all-users' })
+                async clearUsers() {
+                    return true;
+                }
+            }
+
+            const service = new UserService();
+            await service.getUsers();
+            await service.getUsers();
+            expect(getUserCallCount).toBe(1);
+
+            await service.clearUsers();
+            await service.getUsers();
+            expect(getUserCallCount).toBe(2);
+        });
+
+        it('key 为函数时应使用函数返回值删除缓存条目', async () => {
+            let getUserCallCount = 0;
+
+            class UserService {
+                @Cache('user-cache', { key: (...args: unknown[]) => String(args[0]) })
+                async getUser(id: number) {
+                    getUserCallCount++;
+                    return { id };
+                }
+
+                @CacheEvict('user-cache', { key: (...args: unknown[]) => String(args[0]) })
+                async deleteUser(id: number) {
+                    return { id, deleted: true };
+                }
+            }
+
+            const service = new UserService();
+            await service.getUser(1);
+            await service.getUser(2);
+            expect(getUserCallCount).toBe(2);
+
+            await service.deleteUser(1);
+            await service.getUser(1);
+            await service.getUser(2);
+            expect(getUserCallCount).toBe(3);
+        });
+
+        it('allEntries 为 true 时忽略 key 选项', async () => {
+            let getUserCallCount = 0;
+            let clearCallCount = 0;
+
+            class UserService {
+                @Cache('user-cache', { key: 'specific-key' })
+                async getUsers() {
+                    getUserCallCount++;
+                    return [];
+                }
+
+                @CacheEvict('user-cache', { allEntries: true, key: 'ignored-key' })
+                async clearAllUsers() {
+                    clearCallCount++;
+                    return true;
+                }
+            }
+
+            const service = new UserService();
+            await service.getUsers();
+            await service.getUsers();
+            expect(getUserCallCount).toBe(1);
+
+            await service.clearAllUsers();
+            expect(clearCallCount).toBe(1);
+
+            await service.getUsers();
+            expect(getUserCallCount).toBe(2);
+        });
     });
-  });
-});
+});

package/test/cache-provider-registry.test.ts

@@ -2,35 +2,35 @@ import { CacheProviderRegistry } from '../src/core/cache-provider-registry';
 import { MemoryCacheProvider } from '../src/core/native-cache';
 
 describe('CacheProviderRegistry', () => {
-  let memoryProvider: MemoryCacheProvider;
+    let memoryProvider: MemoryCacheProvider;
 
-  beforeEach(() => {
-    memoryProvider = new MemoryCacheProvider();
-    CacheProviderRegistry.register('memory', memoryProvider);
-  });
-
-  afterEach(() => {
-    CacheProviderRegistry.clear();
-  });
-
-  describe('register & get', () => {
-    it('应注册并获取 Provider', () => {
-      expect(CacheProviderRegistry.get('memory')).toBe(memoryProvider);
+    beforeEach(() => {
+        memoryProvider = new MemoryCacheProvider();
+        CacheProviderRegistry.register('memory', memoryProvider);
     });
 
-    it('应在 Provider 不存在时抛出错误', () => {
-      expect(() => CacheProviderRegistry.get('nonexistent')).toThrow();
+    afterEach(() => {
+        CacheProviderRegistry.clear();
     });
-  });
 
-  describe('setDefault & get', () => {
-    it('应设置并获取默认 Provider', () => {
-      CacheProviderRegistry.setDefault('memory');
-      expect(CacheProviderRegistry.get()).toBe(memoryProvider);
+    describe('register & get', () => {
+        it('应注册并获取 Provider', () => {
+            expect(CacheProviderRegistry.get('memory')).toBe(memoryProvider);
+        });
+
+        it('应在 Provider 不存在时抛出错误', () => {
+            expect(() => CacheProviderRegistry.get('nonexistent')).toThrow();
+        });
     });
 
-    it('应在未设置默认且未指定时抛出错误', () => {
-      expect(() => CacheProviderRegistry.get()).toThrow();
+    describe('setDefault & get', () => {
+        it('应设置并获取默认 Provider', () => {
+            CacheProviderRegistry.setDefault('memory');
+            expect(CacheProviderRegistry.get()).toBe(memoryProvider);
+        });
+
+        it('应在未设置默认且未指定时抛出错误', () => {
+            expect(() => CacheProviderRegistry.get()).toThrow();
+        });
     });
-  });
-});
+});