@dangao/bun-server 1.0.0 → 1.0.3

package/src/cache/decorators.ts

@@ -0,0 +1,202 @@
+import 'reflect-metadata';
+
+/**
+ * 缓存装饰器元数据键
+ */
+const CACHEABLE_METADATA_KEY = Symbol('@dangao/bun-server:cache:cacheable');
+const CACHE_EVICT_METADATA_KEY = Symbol('@dangao/bun-server:cache:cache-evict');
+const CACHE_PUT_METADATA_KEY = Symbol('@dangao/bun-server:cache:cache-put');
+
+/**
+ * 缓存配置
+ */
+export interface CacheableOptions {
+  /**
+   * 缓存键（支持 SpEL 表达式，如 'user:{id}'）
+   */
+  key?: string;
+
+  /**
+   * 缓存键前缀
+   */
+  keyPrefix?: string;
+
+  /**
+   * TTL（毫秒），0 表示永不过期
+   */
+  ttl?: number;
+
+  /**
+   * 条件表达式（如果返回 false，则不缓存）
+   * 支持 SpEL 表达式，如 'result.status === "success"'
+   */
+  condition?: string;
+}
+
+/**
+ * 缓存清除配置
+ */
+export interface CacheEvictOptions {
+  /**
+   * 缓存键（支持 SpEL 表达式）
+   */
+  key?: string;
+
+  /**
+   * 缓存键前缀
+   */
+  keyPrefix?: string;
+
+  /**
+   * 是否在方法执行前清除
+   * @default false
+   */
+  beforeInvocation?: boolean;
+
+  /**
+   * 是否清除所有匹配的键（支持通配符）
+   * @default false
+   */
+  allEntries?: boolean;
+}
+
+/**
+ * 缓存更新配置
+ */
+export interface CachePutOptions {
+  /**
+   * 缓存键（支持 SpEL 表达式）
+   */
+  key?: string;
+
+  /**
+   * 缓存键前缀
+   */
+  keyPrefix?: string;
+
+  /**
+   * TTL（毫秒），0 表示永不过期
+   */
+  ttl?: number;
+
+  /**
+   * 条件表达式（如果返回 false，则不更新缓存）
+   */
+  condition?: string;
+}
+
+/**
+ * 缓存装饰器元数据
+ */
+export interface CacheableMetadata {
+  key?: string;
+  keyPrefix?: string;
+  ttl?: number;
+  condition?: string;
+}
+
+export interface CacheEvictMetadata {
+  key?: string;
+  keyPrefix?: string;
+  beforeInvocation?: boolean;
+  allEntries?: boolean;
+}
+
+export interface CachePutMetadata {
+  key?: string;
+  keyPrefix?: string;
+  ttl?: number;
+  condition?: string;
+}
+
+/**
+ * 缓存方法结果
+ * @param options - 缓存配置
+ */
+export function Cacheable(options: CacheableOptions = {}): MethodDecorator {
+  return function (
+    target: unknown,
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor,
+  ) {
+    const metadata: CacheableMetadata = {
+      key: options.key,
+      keyPrefix: options.keyPrefix,
+      ttl: options.ttl,
+      condition: options.condition,
+    };
+
+    Reflect.defineMetadata(
+      CACHEABLE_METADATA_KEY,
+      metadata,
+      descriptor.value,
+    );
+  };
+}
+
+/**
+ * 清除缓存
+ * @param options - 清除配置
+ */
+export function CacheEvict(options: CacheEvictOptions = {}): MethodDecorator {
+  return function (
+    target: unknown,
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor,
+  ) {
+    const metadata: CacheEvictMetadata = {
+      key: options.key,
+      keyPrefix: options.keyPrefix,
+      beforeInvocation: options.beforeInvocation ?? false,
+      allEntries: options.allEntries ?? false,
+    };
+
+    Reflect.defineMetadata(
+      CACHE_EVICT_METADATA_KEY,
+      metadata,
+      descriptor.value,
+    );
+  };
+}
+
+/**
+ * 更新缓存
+ * @param options - 更新配置
+ */
+export function CachePut(options: CachePutOptions = {}): MethodDecorator {
+  return function (
+    target: unknown,
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor,
+  ) {
+    const metadata: CachePutMetadata = {
+      key: options.key,
+      keyPrefix: options.keyPrefix,
+      ttl: options.ttl,
+      condition: options.condition,
+    };
+
+    Reflect.defineMetadata(CACHE_PUT_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+
+/**
+ * 获取缓存装饰器元数据
+ */
+export function getCacheableMetadata(
+  target: unknown,
+): CacheableMetadata | undefined {
+  return Reflect.getMetadata(CACHEABLE_METADATA_KEY, target as object);
+}
+
+export function getCacheEvictMetadata(
+  target: unknown,
+): CacheEvictMetadata | undefined {
+  return Reflect.getMetadata(CACHE_EVICT_METADATA_KEY, target as object);
+}
+
+export function getCachePutMetadata(
+  target: unknown,
+): CachePutMetadata | undefined {
+  return Reflect.getMetadata(CACHE_PUT_METADATA_KEY, target as object);
+}

package/src/cache/index.ts

@@ -0,0 +1,27 @@
+export { CacheModule } from './cache-module';
+export { CacheService } from './service';
+export {
+  Cacheable,
+  CacheEvict,
+  CachePut,
+  getCacheableMetadata,
+  getCacheEvictMetadata,
+  getCachePutMetadata,
+  type CacheableOptions,
+  type CacheEvictOptions,
+  type CachePutOptions,
+  type CacheableMetadata,
+  type CacheEvictMetadata,
+  type CachePutMetadata,
+} from './decorators';
+export {
+  MemoryCacheStore,
+  RedisCacheStore,
+  CACHE_SERVICE_TOKEN,
+  CACHE_OPTIONS_TOKEN,
+} from './types';
+export type {
+  CacheStore,
+  CacheModuleOptions,
+  RedisCacheStoreOptions,
+} from './types';

package/src/cache/service.ts

@@ -0,0 +1,151 @@
+import { Injectable } from '../di/decorators';
+import type { CacheStore, CacheModuleOptions } from './types';
+import { CACHE_OPTIONS_TOKEN } from './types';
+import { Inject } from '../di/decorators';
+
+/**
+ * 缓存服务
+ */
+@Injectable()
+export class CacheService {
+  private store: CacheStore;
+  private defaultTtl: number;
+  private keyPrefix: string;
+
+  public constructor(
+    @Inject(CACHE_OPTIONS_TOKEN) options: CacheModuleOptions,
+  ) {
+    this.store = options.store!;
+    this.defaultTtl = options.defaultTtl ?? 3600000; // 1 小时
+    this.keyPrefix = options.keyPrefix ?? '';
+  }
+
+  /**
+   * 获取缓存值
+   * @param key - 缓存键
+   * @returns 缓存值，如果不存在则返回 undefined
+   */
+  public async get<T = unknown>(key: string): Promise<T | undefined> {
+    return this.store.get<T>(this.getKey(key));
+  }
+
+  /**
+   * 设置缓存值
+   * @param key - 缓存键
+   * @param value - 缓存值
+   * @param ttl - 过期时间（毫秒），0 表示永不过期，undefined 使用默认 TTL
+   * @returns 是否设置成功
+   */
+  public async set<T = unknown>(
+    key: string,
+    value: T,
+    ttl?: number,
+  ): Promise<boolean> {
+    const finalTtl = ttl !== undefined ? ttl : this.defaultTtl;
+    return this.store.set(this.getKey(key), value, finalTtl);
+  }
+
+  /**
+   * 删除缓存
+   * @param key - 缓存键
+   * @returns 是否删除成功
+   */
+  public async delete(key: string): Promise<boolean> {
+    return this.store.delete(this.getKey(key));
+  }
+
+  /**
+   * 检查缓存是否存在
+   * @param key - 缓存键
+   * @returns 是否存在
+   */
+  public async has(key: string): Promise<boolean> {
+    return this.store.has(this.getKey(key));
+  }
+
+  /**
+   * 清空所有缓存
+   * @returns 是否清空成功
+   */
+  public async clear(): Promise<boolean> {
+    return this.store.clear();
+  }
+
+  /**
+   * 获取多个缓存值
+   * @param keys - 缓存键数组
+   * @returns 缓存值映射
+   */
+  public async getMany<T = unknown>(
+    keys: string[],
+  ): Promise<Map<string, T>> {
+    const prefixedKeys = keys.map((k) => this.getKey(k));
+    const result = await this.store.getMany<T>(prefixedKeys);
+
+    // 移除前缀
+    const map = new Map<string, T>();
+    for (const [key, value] of result.entries()) {
+      map.set(key.replace(this.keyPrefix, ''), value);
+    }
+
+    return map;
+  }
+
+  /**
+   * 设置多个缓存值
+   * @param entries - 缓存条目数组
+   * @param ttl - 过期时间（毫秒），0 表示永不过期，undefined 使用默认 TTL
+   * @returns 是否设置成功
+   */
+  public async setMany<T = unknown>(
+    entries: Array<{ key: string; value: T }>,
+    ttl?: number,
+  ): Promise<boolean> {
+    const finalTtl = ttl !== undefined ? ttl : this.defaultTtl;
+    const prefixedEntries = entries.map(({ key, value }) => ({
+      key: this.getKey(key),
+      value,
+    }));
+    return this.store.setMany(prefixedEntries, finalTtl);
+  }
+
+  /**
+   * 删除多个缓存
+   * @param keys - 缓存键数组
+   * @returns 删除成功的键数组
+   */
+  public async deleteMany(keys: string[]): Promise<string[]> {
+    const prefixedKeys = keys.map((k) => this.getKey(k));
+    const deleted = await this.store.deleteMany(prefixedKeys);
+    return deleted.map((k) => k.replace(this.keyPrefix, ''));
+  }
+
+  /**
+   * 获取或设置缓存（如果不存在则执行函数并缓存结果）
+   * @param key - 缓存键
+   * @param factory - 值工厂函数
+   * @param ttl - 过期时间（毫秒），0 表示永不过期，undefined 使用默认 TTL
+   * @returns 缓存值
+   */
+  public async getOrSet<T = unknown>(
+    key: string,
+    factory: () => Promise<T> | T,
+    ttl?: number,
+  ): Promise<T> {
+    const cached = await this.get<T>(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+
+    const value = await factory();
+    await this.set(key, value, ttl);
+    return value;
+  }
+
+  /**
+   * 获取带前缀的键
+   */
+  private getKey(key: string): string {
+    return this.keyPrefix ? `${this.keyPrefix}${key}` : key;
+  }
+}