@dangao/bun-server 1.0.0 → 1.0.3

package/src/di/container.ts

@@ -0,0 +1,398 @@
+import "reflect-metadata";
+import {
+  type DependencyMetadata,
+  Lifecycle,
+  type ProviderConfig,
+} from "./types";
+import {
+  getDependencyMetadata,
+  getLifecycle,
+  getTypeReference,
+} from "./decorators";
+import { LoggerManager } from "@dangao/logsmith";
+import type { Constructor } from "@/core/types";
+
+/**
+ * 依赖注入容器
+ * 管理依赖的注册、解析和生命周期
+ */
+interface ContainerOptions {
+  parent?: Container;
+}
+
+export class Container {
+  private readonly parent?: Container;
+
+  public constructor(options: ContainerOptions = {}) {
+    this.parent = options.parent;
+  }
+  /**
+   * 注册的提供者
+   */
+  private readonly providers = new Map<string | symbol, ProviderConfig>();
+
+  /**
+   * 单例实例缓存
+   */
+  private readonly singletons = new Map<string | symbol, unknown>();
+
+  /**
+   * 类型到 token 的映射（用于接口注入）
+   */
+  private readonly typeToToken = new Map<
+    Constructor<unknown>,
+    string | symbol
+  >();
+
+  /**
+   * 依赖计划缓存，避免重复解析反射元数据
+   */
+  private readonly dependencyPlans = new Map<
+    Constructor<unknown>,
+    DependencyPlan
+  >();
+
+  /**
+   * 注册提供者
+   * @param token - 提供者标识符（类构造函数或 token）
+   * @param config - 提供者配置
+   */
+  public register<T>(
+    token: Constructor<T> | string | symbol,
+    config?: ProviderConfig,
+  ): void {
+    const tokenKey = this.getTokenKey(token);
+
+    // 如果配置中没有指定生命周期，尝试从装饰器元数据获取
+    let lifecycle = config?.lifecycle;
+    if (!lifecycle && typeof token === "function") {
+      lifecycle = getLifecycle(token);
+    }
+
+    const providerConfig: ProviderConfig = {
+      lifecycle: lifecycle || Lifecycle.Singleton,
+      ...config,
+    };
+
+    if (
+      typeof token === "function" && !providerConfig.factory &&
+      !providerConfig.implementation
+    ) {
+      providerConfig.implementation = token;
+    }
+
+    this.providers.set(tokenKey, providerConfig);
+
+    // 如果是类构造函数，建立类型到 token 的映射
+    if (typeof token === "function") {
+      this.typeToToken.set(token, tokenKey);
+    }
+  }
+
+  /**
+   * 注册单例
+   * @param token - 提供者标识符
+   * @param instance - 实例对象
+   */
+  public registerInstance<T>(
+    token: Constructor<T> | string | symbol,
+    instance: T,
+  ): void {
+    const tokenKey = this.getTokenKey(token);
+    this.singletons.set(tokenKey, instance);
+    this.providers.set(tokenKey, {
+      lifecycle: Lifecycle.Singleton,
+    });
+  }
+
+  /**
+   * 解析依赖
+   * @param token - 提供者标识符
+   * @returns 解析后的实例
+   */
+  public resolve<T>(token: Constructor<T> | string | symbol): T {
+    const tokenKey = this.getTokenKey(token);
+    const provider = this.providers.get(tokenKey);
+
+    if (!provider) {
+      if (this.parent) {
+        return this.parent.resolve(token as Constructor<T>);
+      }
+      // 如果没有注册，尝试直接实例化（用于未注册的类）
+      // 但只有在是构造函数时才允许
+      if (typeof token === "function") {
+        // 检查是否有参数，如果有参数则需要注册
+        const paramTypes = Reflect.getMetadata(
+          "design:paramtypes",
+          token,
+        ) as unknown[];
+        if (paramTypes && paramTypes.length > 0) {
+          // 有依赖，必须先注册
+          throw new Error(`Provider not found for token: ${String(tokenKey)}`);
+        }
+        // 无参数，可以直接实例化
+        return new token() as T;
+      }
+      throw new Error(`Provider not found for token: ${String(tokenKey)}`);
+    }
+
+    // 检查单例缓存
+    if (provider.lifecycle === Lifecycle.Singleton) {
+      const singleton = this.singletons.get(tokenKey);
+      if (singleton) {
+        return singleton as T;
+      }
+    }
+
+    // 使用工厂函数或实例化
+    let instance: T;
+    if (provider.factory) {
+      instance = provider.factory() as T;
+    } else if (typeof token === "function") {
+      instance = this.instantiate(token as Constructor<T>);
+    } else if (
+      provider.implementation && typeof provider.implementation === "function"
+    ) {
+      instance = this.instantiate(provider.implementation as Constructor<T>);
+    } else {
+      throw new Error(
+        `Cannot instantiate token: ${
+          String(tokenKey)
+        }. Factory function required.`,
+      );
+    }
+
+    // 缓存单例
+    if (provider.lifecycle === Lifecycle.Singleton) {
+      this.singletons.set(tokenKey, instance);
+    }
+
+    return instance;
+  }
+
+  /**
+   * 解析依赖（内部方法，支持 string | symbol token）
+   * @param token - 提供者标识符
+   * @returns 解析后的实例
+   */
+  private resolveInternal(
+    token: Constructor<unknown> | string | symbol,
+  ): unknown {
+    // 调试：记录 token 的类型和值
+    const tokenType = typeof token;
+    const tokenString = String(token);
+    const logger = LoggerManager.getLogger();
+
+    // 调试：记录 token 信息
+    if (
+      tokenString.includes("Level2") || tokenString.includes("Dependency") ||
+      tokenString.includes("Service")
+    ) {
+      logger.debug(
+        `[DI Debug] resolveInternal: token=${tokenString}, tokenType=${tokenType}`,
+      );
+    }
+
+    // 检查是否是 string 或 symbol
+    // 注意：必须先检查 string/symbol，因为函数也是对象
+    if (typeof token === "string" || typeof token === "symbol") {
+      // 对于 string | symbol token，直接查找提供者
+      const provider = this.providers.get(token);
+      if (!provider) {
+        if (this.parent) {
+          return this.parent.resolveInternal(token);
+        }
+        throw new Error(`Provider not found for token: ${String(token)}`);
+      }
+
+      // 检查单例缓存
+      if (provider.lifecycle === Lifecycle.Singleton) {
+        const singleton = this.singletons.get(token);
+        if (singleton) {
+          return singleton;
+        }
+      }
+
+      // 使用工厂函数或实现类
+      if (provider.factory) {
+        const instance = provider.factory();
+        if (provider.lifecycle === Lifecycle.Singleton) {
+          this.singletons.set(token, instance);
+        }
+        return instance;
+      }
+
+      if (
+        provider.implementation && typeof provider.implementation === "function"
+      ) {
+        const instance = this.instantiate(provider.implementation);
+        if (provider.lifecycle === Lifecycle.Singleton) {
+          this.singletons.set(token, instance);
+        }
+        return instance;
+      }
+
+      throw new Error(
+        `Cannot instantiate token: ${
+          String(token)
+        }. Factory function required.`,
+      );
+    }
+
+    // 对于构造函数类型，使用公共 resolve 方法
+    // 确保 token 是函数类型
+    if (typeof token === "function") {
+      return this.resolve(token as new (...args: unknown[]) => unknown);
+    }
+
+    throw new Error(
+      `Invalid token type: ${tokenType}. Token: ${String(token)}`,
+    );
+  }
+
+  /**
+   * 实例化类（自动注入依赖）
+   * @param constructor - 构造函数
+   * @returns 实例
+   */
+  private instantiate<T>(constructor: Constructor<T>): T {
+    const plan = this.getDependencyPlan(constructor);
+
+    if (plan.paramLength === 0) {
+      return new constructor();
+    }
+
+    const dependencies = new Array(plan.paramLength);
+    for (let index = 0; index < plan.paramLength; index++) {
+      dependencies[index] = this.resolveFromPlan(constructor, plan, index);
+    }
+
+    return new constructor(...dependencies);
+  }
+
+  /**
+   * 获取 token 键
+   * @param token - 提供者标识符
+   * @returns token 键
+   */
+  private getTokenKey(
+    token: (new (...args: unknown[]) => unknown) | string | symbol,
+  ): string | symbol {
+    if (typeof token === "function") {
+      return token.name || Symbol(token.toString());
+    }
+    return token;
+  }
+
+  /**
+   * 清除所有注册（主要用于测试）
+   */
+  public clear(): void {
+    this.providers.clear();
+    this.singletons.clear();
+    this.typeToToken.clear();
+    this.dependencyPlans.clear();
+  }
+
+  /**
+   * 检查是否已注册
+   * @param token - 提供者标识符
+   * @returns 是否已注册
+   */
+  public isRegistered(token: Constructor<unknown> | string | symbol): boolean {
+    const tokenKey = this.getTokenKey(token);
+    return this.providers.has(tokenKey);
+  }
+
+  private getDependencyPlan(constructor: Constructor<unknown>): DependencyPlan {
+    let plan = this.dependencyPlans.get(constructor);
+    if (plan) {
+      return plan;
+    }
+
+    const paramTypes =
+      (Reflect.getMetadata(
+        "design:paramtypes",
+        constructor,
+      ) as (Constructor<unknown> | undefined)[]) ?? [];
+    const dependencyMetadata = getDependencyMetadata(constructor);
+    const metadataMap = new Map<number, DependencyMetadata>();
+    let paramLength = paramTypes.length;
+
+    for (const meta of dependencyMetadata) {
+      if (meta && typeof meta.index === "number") {
+        metadataMap.set(meta.index, meta);
+        if (meta.index + 1 > paramLength) {
+          paramLength = meta.index + 1;
+        }
+      }
+    }
+
+    const resolvedTypes = new Map<number, Constructor<unknown>>();
+
+    for (let i = 0; i < paramLength; i++) {
+      const typeRef = getTypeReference(constructor, i);
+      if (typeRef && typeof typeRef === "function") {
+        resolvedTypes.set(i, typeRef as Constructor<unknown>);
+      }
+    }
+
+    for (const [index, meta] of metadataMap.entries()) {
+      const depType = meta?.type;
+      if (typeof depType === "function") {
+        resolvedTypes.set(index, depType as Constructor<unknown>);
+      } else if (typeof depType === "string") {
+        const globalType = (globalThis as Record<string, unknown>)[depType];
+        if (typeof globalType === "function") {
+          resolvedTypes.set(index, globalType as Constructor<unknown>);
+        }
+      }
+    }
+
+    plan = {
+      paramTypes,
+      metadataMap,
+      resolvedTypes,
+      paramLength,
+    };
+    this.dependencyPlans.set(constructor, plan);
+    return plan;
+  }
+
+  private resolveFromPlan(
+    constructor: Constructor<unknown>,
+    plan: DependencyPlan,
+    index: number,
+  ): unknown {
+    const meta = plan.metadataMap.get(index);
+    if (meta?.token) {
+      return this.resolveInternal(meta.token);
+    }
+
+    const resolvedType = plan.resolvedTypes.get(index);
+    if (resolvedType) {
+      return this.resolveInternal(resolvedType);
+    }
+
+    const paramType = plan.paramTypes[index];
+    if (paramType) {
+      const token = this.typeToToken.get(paramType);
+      if (token) {
+        return this.resolveInternal(token);
+      }
+      return this.resolveInternal(paramType);
+    }
+
+    throw new Error(
+      `Cannot resolve dependency at index ${index} of ${constructor.name}. ` +
+        "Parameter type is undefined. Use @Inject() decorator to specify the dependency type.",
+    );
+  }
+}
+
+interface DependencyPlan {
+  paramTypes: (Constructor<unknown> | undefined)[];
+  metadataMap: Map<number, DependencyMetadata>;
+  resolvedTypes: Map<number, Constructor<unknown>>;
+  paramLength: number;
+}

package/src/di/decorators.ts

@@ -0,0 +1,228 @@
+import "reflect-metadata";
+import { type DependencyMetadata, Lifecycle } from "./types";
+import { LoggerManager } from "@dangao/logsmith";
+import type { Constructor } from "@/core/types";
+
+/**
+ * 依赖元数据键
+ */
+const DEPENDENCY_METADATA_KEY = Symbol("dependency:metadata");
+const INJECTABLE_METADATA_KEY = Symbol("injectable");
+
+/**
+ * 类型引用映射（用于保存构造函数类型，避免 Reflect.defineMetadata 序列化问题）
+ */
+const typeReferenceMap = new WeakMap<
+  Constructor<unknown>,
+  Map<string, Constructor<unknown>>
+>();
+
+/**
+ * Injectable 装饰器
+ * 标记类为可注入的
+ * @param config - 提供者配置
+ */
+export function Injectable(
+  config?: { lifecycle?: Lifecycle },
+): (target: Constructor<unknown>) => void {
+  return function (target: new (...args: unknown[]) => unknown) {
+    // 保存可注入标记
+    Reflect.defineMetadata(INJECTABLE_METADATA_KEY, true, target);
+    // 保存生命周期配置
+    if (config?.lifecycle) {
+      Reflect.defineMetadata("lifecycle", config.lifecycle, target);
+    }
+  };
+}
+
+/**
+ * Inject 装饰器
+ * 标记需要注入的依赖
+ * @param token - 依赖标识符（可选，默认使用参数类型）
+ */
+export function Inject(
+  token?: Constructor<unknown> | string | symbol,
+): ParameterDecorator {
+  return function (
+    target: unknown,
+    _propertyKey: string | symbol | undefined,
+    parameterIndex: number,
+  ) {
+    const logger = LoggerManager.getLogger();
+
+    // 参数装饰器的 target 可能是构造函数本身（用于构造函数参数）
+    // 也可能是类的原型（用于方法参数）
+    const constructor = typeof target === "function"
+      ? (target as Constructor<unknown>)
+      : (target as any)?.constructor;
+    if (!constructor) {
+      return;
+    }
+
+    // 获取参数类型（从构造函数获取）
+    const paramTypes = Reflect.getMetadata(
+      "design:paramtypes",
+      constructor,
+    ) as Constructor<unknown>[];
+    const paramType = paramTypes?.[parameterIndex];
+
+    // 获取或创建依赖元数据（保存在构造函数上）
+    let metadata: DependencyMetadata[] =
+      Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor) || [];
+
+    // 确保数组有足够的长度
+    const paramCount = paramTypes?.length || 0;
+    while (metadata.length < paramCount) {
+      metadata.push(undefined as unknown as DependencyMetadata);
+    }
+
+    // 确定依赖类型
+    let dependencyType: Constructor<unknown>;
+    let dependencyToken: string | symbol | undefined;
+
+    if (token) {
+      if (typeof token === "string" || typeof token === "symbol") {
+        dependencyToken = token;
+        // 如果没有参数类型，使用 Object 作为占位符
+        dependencyType = paramType || (Object as Constructor<unknown>);
+      } else {
+        dependencyType = token;
+      }
+    } else {
+      // 如果没有提供 token，使用参数类型
+      // 如果 paramType 是 undefined，说明 reflect-metadata 没有正确获取类型
+      // 在这种情况下，我们不能使用 Object，因为 Object 不是正确的依赖类型
+      if (!paramType) {
+        throw new Error(
+          `Cannot determine dependency type for parameter ${parameterIndex} of ${constructor.name}. ` +
+            "Please provide explicit type using @Inject(Type) or ensure emitDecoratorMetadata is enabled.",
+        );
+      }
+      dependencyType = paramType;
+    }
+
+    // 保存类型引用到 WeakMap（避免 Reflect.defineMetadata 序列化问题）
+    // 无论 dependencyType 是什么类型，都保存到 WeakMap 中
+    if (!typeReferenceMap.has(constructor)) {
+      typeReferenceMap.set(constructor, new Map());
+    }
+    const typeRefs = typeReferenceMap.get(constructor)!;
+    // 保存类型引用（无论是函数类型还是其他类型）
+    typeRefs.set(String(parameterIndex), dependencyType);
+
+    metadata[parameterIndex] = {
+      index: parameterIndex,
+      type: dependencyType,
+      token: dependencyToken,
+    };
+
+    // 调试：记录元数据保存信息
+    if (constructor.name === "Service" || constructor.name === "Level2") {
+      logger.debug(
+        `[DI Debug] @Inject(${
+          token
+            ? (typeof token === "function" ? token.name : String(token))
+            : "auto"
+        }) on ${constructor.name}[${parameterIndex}]: saving metadata.length=${metadata.length}`,
+      );
+    }
+
+    Reflect.defineMetadata(DEPENDENCY_METADATA_KEY, metadata, constructor);
+
+    // 调试：验证元数据是否被正确保存
+    if (constructor.name === "Service" || constructor.name === "Level2") {
+      const savedMetadata = Reflect.getMetadata(
+        DEPENDENCY_METADATA_KEY,
+        constructor,
+      );
+      logger.debug(
+        `[DI Debug] @Inject on ${constructor.name}: saved metadata.exists=${
+          savedMetadata ? "yes" : "no"
+        }, length=${savedMetadata?.length || 0}`,
+      );
+    }
+  };
+}
+
+/**
+ * 获取依赖元数据
+ * @param target - 目标类或原型
+ * @returns 依赖元数据数组
+ */
+export function getDependencyMetadata(target: unknown): DependencyMetadata[] {
+  // 参数装饰器的元数据保存在构造函数上
+  // 如果 target 是构造函数，直接获取
+  // 如果 target 是原型，从构造函数获取
+  const constructor = typeof target === "function"
+    ? target
+    : (target as any)?.constructor;
+  if (!constructor) {
+    return [];
+  }
+  const rawMetadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor);
+  const metadata = rawMetadata || [];
+
+  // 调试：记录元数据信息
+  if (constructor.name === "Service" || constructor.name === "Level2") {
+    LoggerManager.getLogger().debug(
+      `[DI Debug] getDependencyMetadata(${constructor.name}): rawMetadata=${
+        rawMetadata ? "exists" : "undefined"
+      }, length=${metadata.length}`,
+    );
+  }
+
+  // 从 WeakMap 恢复类型引用（避免 Reflect.defineMetadata 序列化问题）
+  const typeRefs = typeReferenceMap.get(constructor);
+  if (typeRefs) {
+    for (let i = 0; i < metadata.length; i++) {
+      const meta = metadata[i];
+      if (meta !== undefined && meta !== null) {
+        const typeRef = typeRefs.get(String(meta.index));
+        if (typeRef && typeof typeRef === "function") {
+          // 恢复类型引用
+          meta.type = typeRef;
+        }
+      }
+    }
+  }
+
+  // 返回完整的元数据数组（包括 undefined），让调用者决定如何处理
+  return metadata;
+}
+
+/**
+ * 检查类是否可注入
+ * @param target - 目标类
+ * @returns 是否可注入
+ */
+export function isInjectable(target: Constructor<unknown>): boolean {
+  return Reflect.getMetadata(INJECTABLE_METADATA_KEY, target) === true;
+}
+
+/**
+ * 获取类的生命周期配置
+ * @param target - 目标类
+ * @returns 生命周期
+ */
+export function getLifecycle(
+  target: Constructor<unknown>,
+): Lifecycle | undefined {
+  return Reflect.getMetadata("lifecycle", target);
+}
+
+/**
+ * 获取类型引用（从 WeakMap）
+ * @param constructor - 构造函数
+ * @param parameterIndex - 参数索引
+ * @returns 类型引用
+ */
+export function getTypeReference(
+  constructor: Constructor<unknown>,
+  parameterIndex: number,
+): Constructor<unknown> | undefined {
+  const typeRefs = typeReferenceMap.get(constructor);
+  if (typeRefs) {
+    return typeRefs.get(String(parameterIndex)) as Constructor<unknown>;
+  }
+  return undefined as unknown as Constructor<unknown>;
+}

package/src/di/index.ts

@@ -0,0 +1,4 @@
+export { Container } from './container';
+export { Injectable, Inject, getDependencyMetadata, isInjectable, getLifecycle } from './decorators';
+export { Lifecycle, type ProviderConfig, type DependencyMetadata } from './types';
+