@dangao/bun-server 1.8.0 → 1.8.2

package/tests/cache/cache-service-proxy.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import {
+  CacheServiceProxy,
+  EnableCacheProxy,
+  isCacheProxyEnabled,
+  CachePostProcessor,
+  CACHE_PROXY_ENABLED_KEY,
+} from '../../src/cache/service-proxy';
+import {
+  Cacheable,
+  CacheEvict,
+  CachePut,
+} from '../../src/cache/decorators';
+import { CacheService } from '../../src/cache/service';
+import { MemoryCacheStore, CACHE_SERVICE_TOKEN } from '../../src/cache/types';
+import { Container } from '../../src/di/container';
+
+describe('CacheServiceProxy', () => {
+  let container: Container;
+  let cacheService: CacheService;
+
+  beforeEach(() => {
+    container = new Container();
+    const store = new MemoryCacheStore();
+    cacheService = new CacheService(store);
+    container.registerInstance(CACHE_SERVICE_TOKEN, cacheService);
+  });
+
+  describe('createProxy', () => {
+    test('should return original instance if no cache decorators', () => {
+      class NoCacheService {
+        public getValue(): string {
+          return 'value';
+        }
+      }
+
+      const instance = new NoCacheService();
+      const proxied = CacheServiceProxy.createProxy(instance, container);
+
+      // 如果没有缓存装饰器，应该返回原实例
+      expect(proxied).toBe(instance);
+    });
+
+    test('should create proxy for service with @Cacheable', async () => {
+      let callCount = 0;
+
+      class UserService {
+        @Cacheable({ key: 'user:{0}' })
+        public findById(id: string): string {
+          callCount++;
+          return `User-${id}`;
+        }
+      }
+
+      const instance = new UserService();
+      const proxied = CacheServiceProxy.createProxy(instance, container);
+
+      // 第一次调用应该执行方法
+      const result1 = await (proxied.findById as any)('123');
+      expect(result1).toBe('User-123');
+      expect(callCount).toBe(1);
+
+      // 第二次调用应该从缓存返回
+      const result2 = await (proxied.findById as any)('123');
+      expect(result2).toBe('User-123');
+      expect(callCount).toBe(1); // 不应该增加
+    });
+
+    test('should create proxy for service with @CacheEvict', async () => {
+      class UserService {
+        @CacheEvict({ key: 'user:{0}' })
+        public deleteUser(id: string): string {
+          return 'deleted';
+        }
+      }
+
+      const instance = new UserService();
+      const proxied = CacheServiceProxy.createProxy(instance, container);
+
+      const result = await (proxied.deleteUser as any)('123');
+      expect(result).toBe('deleted');
+    });
+
+    test('should create proxy for service with @CacheEvict beforeInvocation', async () => {
+      class UserService {
+        @CacheEvict({ key: 'user:{0}', beforeInvocation: true })
+        public deleteUser(id: string): string {
+          return 'deleted';
+        }
+      }
+
+      const instance = new UserService();
+      const proxied = CacheServiceProxy.createProxy(instance, container);
+
+      const result = await (proxied.deleteUser as any)('123');
+      expect(result).toBe('deleted');
+    });
+
+    test('should create proxy for service with @CachePut', async () => {
+      class UserService {
+        @CachePut({ key: 'user:{0}' })
+        public updateUser(id: string): string {
+          return `Updated-${id}`;
+        }
+      }
+
+      const instance = new UserService();
+      const proxied = CacheServiceProxy.createProxy(instance, container);
+
+      // CachePut 总是执行方法并更新缓存
+      const result = await (proxied.updateUser as any)('123');
+      expect(result).toBe('Updated-123');
+
+      // 验证缓存被更新
+      const cached = await cacheService.get('user:123');
+      expect(cached).toBe('Updated-123');
+    });
+
+    test('should handle non-function properties', () => {
+      class ServiceWithProps {
+        public name = 'TestService';
+
+        @Cacheable()
+        public getData(): string {
+          return 'data';
+        }
+      }
+
+      const instance = new ServiceWithProps();
+      const proxied = CacheServiceProxy.createProxy(instance, container);
+
+      // 非函数属性应该正常访问
+      expect(proxied.name).toBe('TestService');
+    });
+
+    test('should handle symbol properties', () => {
+      const sym = Symbol('test');
+
+      class ServiceWithSymbol {
+        public [sym](): string {
+          return 'symbol method';
+        }
+
+        @Cacheable()
+        public getData(): string {
+          return 'data';
+        }
+      }
+
+      const instance = new ServiceWithSymbol();
+      const proxied = CacheServiceProxy.createProxy(instance, container);
+
+      // Symbol 属性的方法应该正常执行（不被拦截）
+      expect(proxied[sym]()).toBe('symbol method');
+    });
+  });
+});
+
+describe('EnableCacheProxy decorator', () => {
+  test('should set cache proxy enabled metadata', () => {
+    @EnableCacheProxy()
+    class TestService {}
+
+    const enabled = isCacheProxyEnabled(TestService);
+    expect(enabled).toBe(true);
+  });
+
+  test('should return false for non-decorated class', () => {
+    class TestService {}
+
+    const enabled = isCacheProxyEnabled(TestService);
+    expect(enabled).toBe(false);
+  });
+
+  test('should set metadata with correct key', () => {
+    @EnableCacheProxy()
+    class TestService {}
+
+    const metadata = Reflect.getMetadata(CACHE_PROXY_ENABLED_KEY, TestService);
+    expect(metadata).toBe(true);
+  });
+});
+
+describe('CachePostProcessor', () => {
+  let container: Container;
+  let cacheService: CacheService;
+  let processor: CachePostProcessor;
+
+  beforeEach(() => {
+    container = new Container();
+    const store = new MemoryCacheStore();
+    cacheService = new CacheService(store);
+    container.registerInstance(CACHE_SERVICE_TOKEN, cacheService);
+    processor = new CachePostProcessor();
+  });
+
+  test('should have correct priority', () => {
+    expect(processor.priority).toBe(50);
+  });
+
+  test('should return original instance if not enabled', () => {
+    class RegularService {
+      public getData(): string {
+        return 'data';
+      }
+    }
+
+    const instance = new RegularService();
+    const result = processor.postProcess(instance, RegularService, container);
+
+    expect(result).toBe(instance);
+  });
+
+  test('should create proxy for enabled service', () => {
+    @EnableCacheProxy()
+    class CachedService {
+      @Cacheable({ key: 'test' })
+      public getData(): string {
+        return 'data';
+      }
+    }
+
+    const instance = new CachedService();
+    const result = processor.postProcess(instance, CachedService, container);
+
+    // 应该返回代理而不是原实例
+    expect(result).not.toBe(instance);
+  });
+
+  test('should return original if enabled but no cache decorators', () => {
+    @EnableCacheProxy()
+    class ServiceWithoutDecorators {
+      public getData(): string {
+        return 'data';
+      }
+    }
+
+    const instance = new ServiceWithoutDecorators();
+    const result = processor.postProcess(instance, ServiceWithoutDecorators, container);
+
+    // 没有缓存装饰器时，即使启用了代理也返回原实例
+    expect(result).toBe(instance);
+  });
+});

package/tests/cache/memory-cache-store.test.ts

@@ -0,0 +1,155 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+
+import { MemoryCacheStore } from '../../src/cache/types';
+
+describe('MemoryCacheStore', () => {
+  let store: MemoryCacheStore;
+
+  beforeEach(() => {
+    store = new MemoryCacheStore();
+  });
+
+  describe('get and set', () => {
+    test('should return undefined for non-existent key', async () => {
+      const value = await store.get('non-existent');
+      expect(value).toBeUndefined();
+    });
+
+    test('should set and get a value', async () => {
+      await store.set('key1', 'value1');
+      const value = await store.get('key1');
+      expect(value).toBe('value1');
+    });
+
+    test('should set and get an object', async () => {
+      const obj = { name: 'test', count: 42 };
+      await store.set('key2', obj);
+      const value = await store.get<typeof obj>('key2');
+      expect(value).toEqual(obj);
+    });
+
+    test('should return undefined for expired key', async () => {
+      await store.set('key3', 'value3', 50); // 50ms TTL
+      
+      // 立即获取应该有值
+      const value1 = await store.get('key3');
+      expect(value1).toBe('value3');
+      
+      // 等待过期
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      
+      const value2 = await store.get('key3');
+      expect(value2).toBeUndefined();
+    });
+
+    test('should overwrite existing value', async () => {
+      await store.set('key4', 'first');
+      await store.set('key4', 'second');
+      const value = await store.get('key4');
+      expect(value).toBe('second');
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete existing key', async () => {
+      await store.set('key5', 'value5');
+      const deleted = await store.delete('key5');
+      expect(deleted).toBe(true);
+      const value = await store.get('key5');
+      expect(value).toBeUndefined();
+    });
+
+    test('should return false for non-existent key', async () => {
+      const deleted = await store.delete('non-existent');
+      expect(deleted).toBe(false);
+    });
+  });
+
+  describe('has', () => {
+    test('should return true for existing key', async () => {
+      await store.set('key6', 'value6');
+      const exists = await store.has('key6');
+      expect(exists).toBe(true);
+    });
+
+    test('should return false for non-existent key', async () => {
+      const exists = await store.has('non-existent');
+      expect(exists).toBe(false);
+    });
+
+    test('should return false for expired key', async () => {
+      await store.set('key7', 'value7', 50);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      const exists = await store.has('key7');
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('clear', () => {
+    test('should clear all entries', async () => {
+      await store.set('key8', 'value8');
+      await store.set('key9', 'value9');
+      await store.clear();
+      expect(await store.has('key8')).toBe(false);
+      expect(await store.has('key9')).toBe(false);
+    });
+  });
+
+  describe('getMany', () => {
+    test('should get multiple values', async () => {
+      await store.set('a', 1);
+      await store.set('b', 2);
+      await store.set('c', 3);
+      
+      const result = await store.getMany<number>(['a', 'b', 'c', 'd']);
+      expect(result.get('a')).toBe(1);
+      expect(result.get('b')).toBe(2);
+      expect(result.get('c')).toBe(3);
+      expect(result.has('d')).toBe(false);
+    });
+  });
+
+  describe('setMany', () => {
+    test('should set multiple values', async () => {
+      const entries = [
+        { key: 'x', value: 'X' },
+        { key: 'y', value: 'Y' },
+        { key: 'z', value: 'Z' },
+      ];
+      await store.setMany(entries);
+      
+      expect(await store.get('x')).toBe('X');
+      expect(await store.get('y')).toBe('Y');
+      expect(await store.get('z')).toBe('Z');
+    });
+
+    test('should set multiple values with TTL', async () => {
+      const entries = [
+        { key: 'p', value: 'P' },
+        { key: 'q', value: 'Q' },
+      ];
+      await store.setMany(entries, 50);
+      
+      expect(await store.get('p')).toBe('P');
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      expect(await store.get('p')).toBeUndefined();
+    });
+  });
+
+  describe('deleteMany', () => {
+    test('should delete multiple keys', async () => {
+      await store.set('m', 1);
+      await store.set('n', 2);
+      await store.set('o', 3);
+      
+      const deleted = await store.deleteMany(['m', 'n', 'missing']);
+      expect(deleted).toContain('m');
+      expect(deleted).toContain('n');
+      expect(deleted).not.toContain('missing');
+      
+      expect(await store.has('m')).toBe(false);
+      expect(await store.has('n')).toBe(false);
+      expect(await store.has('o')).toBe(true);
+    });
+  });
+});

package/tests/cache/redis-cache-store.test.ts

@@ -0,0 +1,199 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+
+import { RedisCacheStore, type RedisCacheStoreOptions } from '../../src/cache/types';
+
+// Mock Redis client
+function createMockRedisClient() {
+  const store = new Map<string, { value: string; expiresAt?: number }>();
+
+  return {
+    get: async (key: string): Promise<string | null> => {
+      const entry = store.get(key);
+      if (!entry) return null;
+      if (entry.expiresAt && Date.now() > entry.expiresAt) {
+        store.delete(key);
+        return null;
+      }
+      return entry.value;
+    },
+    set: async (key: string, value: string, options?: { PX?: number }): Promise<void> => {
+      const expiresAt = options?.PX ? Date.now() + options.PX : undefined;
+      store.set(key, { value, expiresAt });
+    },
+    del: async (key: string): Promise<void> => {
+      store.delete(key);
+    },
+    exists: async (key: string): Promise<number> => {
+      return store.has(key) ? 1 : 0;
+    },
+    mget: async (keys: string[]): Promise<(string | null)[]> => {
+      return keys.map((key) => {
+        const entry = store.get(key);
+        return entry ? entry.value : null;
+      });
+    },
+    mset: async (entries: Array<{ key: string; value: string }>): Promise<void> => {
+      for (const { key, value } of entries) {
+        store.set(key, { value });
+      }
+    },
+    flushdb: async (): Promise<void> => {
+      store.clear();
+    },
+    _store: store, // For testing
+  };
+}
+
+describe('RedisCacheStore', () => {
+  let store: RedisCacheStore;
+  let mockClient: ReturnType<typeof createMockRedisClient>;
+
+  beforeEach(() => {
+    mockClient = createMockRedisClient();
+    store = new RedisCacheStore({ client: mockClient });
+  });
+
+  describe('get', () => {
+    test('should return undefined for non-existent key', async () => {
+      const value = await store.get('non-existent');
+      expect(value).toBeUndefined();
+    });
+
+    test('should get and parse JSON value', async () => {
+      await mockClient.set('cache:test', JSON.stringify({ name: 'alice' }));
+      const value = await store.get<{ name: string }>('test');
+      expect(value).toEqual({ name: 'alice' });
+    });
+
+    test('should return undefined for invalid JSON', async () => {
+      await mockClient.set('cache:invalid', 'not-json');
+      const value = await store.get('invalid');
+      expect(value).toBeUndefined();
+    });
+  });
+
+  describe('set', () => {
+    test('should set value', async () => {
+      const result = await store.set('key1', { count: 42 });
+      expect(result).toBe(true);
+
+      const stored = await mockClient.get('cache:key1');
+      expect(stored).toBe(JSON.stringify({ count: 42 }));
+    });
+
+    test('should set value with TTL', async () => {
+      await store.set('key2', 'value', 1000);
+
+      const stored = await mockClient.get('cache:key2');
+      expect(stored).toBe('"value"');
+    });
+  });
+
+  describe('delete', () => {
+    test('should delete key', async () => {
+      await store.set('key3', 'value');
+      const result = await store.delete('key3');
+      expect(result).toBe(true);
+
+      const value = await store.get('key3');
+      expect(value).toBeUndefined();
+    });
+  });
+
+  describe('has', () => {
+    test('should return true for existing key', async () => {
+      await store.set('key4', 'value');
+      const exists = await store.has('key4');
+      expect(exists).toBe(true);
+    });
+
+    test('should return false for non-existent key', async () => {
+      const exists = await store.has('non-existent');
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('clear', () => {
+    test('should clear all keys', async () => {
+      await store.set('a', 1);
+      await store.set('b', 2);
+      const result = await store.clear();
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('getMany', () => {
+    test('should get multiple values', async () => {
+      await store.set('m1', 'v1');
+      await store.set('m2', 'v2');
+
+      const result = await store.getMany<string>(['m1', 'm2', 'm3']);
+      expect(result.get('m1')).toBe('v1');
+      expect(result.get('m2')).toBe('v2');
+      expect(result.has('m3')).toBe(false);
+    });
+
+    test('should return empty map for empty keys', async () => {
+      const result = await store.getMany([]);
+      expect(result.size).toBe(0);
+    });
+  });
+
+  describe('setMany', () => {
+    test('should set multiple values', async () => {
+      const entries = [
+        { key: 's1', value: 'v1' },
+        { key: 's2', value: 'v2' },
+      ];
+      const result = await store.setMany(entries);
+      expect(result).toBe(true);
+
+      expect(await store.get('s1')).toBe('v1');
+      expect(await store.get('s2')).toBe('v2');
+    });
+
+    test('should return true for empty entries', async () => {
+      const result = await store.setMany([]);
+      expect(result).toBe(true);
+    });
+
+    test('should set multiple values with TTL', async () => {
+      const entries = [
+        { key: 't1', value: 'v1' },
+        { key: 't2', value: 'v2' },
+      ];
+      const result = await store.setMany(entries, 5000);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe('deleteMany', () => {
+    test('should delete multiple keys', async () => {
+      await store.set('d1', 'v1');
+      await store.set('d2', 'v2');
+
+      const deleted = await store.deleteMany(['d1', 'd2', 'd3']);
+      expect(deleted).toContain('d1');
+      expect(deleted).toContain('d2');
+    });
+
+    test('should return empty array for empty keys', async () => {
+      const deleted = await store.deleteMany([]);
+      expect(deleted).toEqual([]);
+    });
+  });
+
+  describe('keyPrefix', () => {
+    test('should use custom key prefix', async () => {
+      const customStore = new RedisCacheStore({
+        client: mockClient,
+        keyPrefix: 'custom:',
+      });
+
+      await customStore.set('test', 'value');
+
+      const stored = await mockClient.get('custom:test');
+      expect(stored).toBe('"value"');
+    });
+  });
+});