@dangao/bun-server 1.2.0 → 1.4.0

package/src/core/application.ts

@@ -13,6 +13,9 @@ import { ModuleRegistry } from '../di/module-registry';
 import type { ModuleClass } from '../di/module';
 import type { Constructor } from './types';
 import { InterceptorRegistry, INTERCEPTOR_REGISTRY_TOKEN } from '../interceptor';
+import { CONFIG_SERVICE_TOKEN } from '../config/types';
+import { ConfigService } from '../config/service';
+import { ConfigModule } from '../config/config-module';
 
 /**
  * 应用配置选项
@@ -81,15 +84,24 @@ export class Application {
     // 初始化所有扩展（包括数据库连接等）
     await this.initializeExtensions();
 
+    // 初始化配置中心集成（在所有模块注册完成后）
+    await this.initializeConfigCenter();
+
+    const finalPort = port ?? this.options.port ?? 3000;
+    const finalHostname = hostname ?? this.options.hostname;
+
     const serverOptions: ServerOptions = {
-      port: port ?? this.options.port ?? 3000,
-      hostname: hostname ?? this.options.hostname,
+      port: finalPort,
+      hostname: finalHostname,
       fetch: this.handleRequest.bind(this),
       websocketRegistry: this.websocketRegistry,
     };
 
     this.server = new BunServer(serverOptions);
     this.server.start();
+
+    // 自动注册服务到注册中心（如果使用了 @ServiceRegistry 装饰器）
+    await this.registerServices(finalPort, finalHostname);
   }
 
   /**
@@ -116,10 +128,42 @@ export class Application {
     // 所以上面的循环已经处理了
   }
 
+  /**
+   * 初始化配置中心集成
+   * 在所有模块注册完成后调用，确保 ConfigCenterModule 已注册
+   */
+  private async initializeConfigCenter(): Promise<void> {
+    const container = this.getContainer();
+    // ConfigModule 可能未注册（很多测试/应用不使用配置模块），此时不要抛错
+    if (!container.isRegistered(CONFIG_SERVICE_TOKEN)) {
+      return;
+    }
+
+    const configService = container.resolve<ConfigService>(CONFIG_SERVICE_TOKEN);
+
+    // 检查是否有待初始化的配置中心选项
+    const configCenterOptions = (configService as any)._configCenterOptions;
+    if (configCenterOptions) {
+      try {
+        await ConfigModule.initializeConfigCenter(configService, configCenterOptions);
+        // 清除临时选项
+        delete (configService as any)._configCenterOptions;
+      } catch (error) {
+        console.error(
+          '[Application] Failed to initialize config center:',
+          error,
+        );
+      }
+    }
+  }
+
   /**
    * 停止应用
    */
   public async stop(): Promise<void> {
+    // 自动注销服务（如果使用了 @ServiceRegistry 装饰器）
+    await this.deregisterServices();
+
     // 关闭所有扩展（包括数据库连接等）
     await this.closeExtensions();
     this.server?.stop();
@@ -235,6 +279,60 @@ export class Application {
     return this.server;
   }
 
+  /**
+   * 自动注册服务到注册中心
+   * 扫描所有使用 @ServiceRegistry 装饰器的控制器，自动注册服务
+   */
+  private async registerServices(port: number, hostname?: string): Promise<void> {
+    try {
+      // 动态导入服务注册装饰器（避免循环依赖）
+      const { registerServiceInstance } = await import(
+        '../microservice/service-registry/decorators'
+      );
+
+      const registry = ControllerRegistry.getInstance();
+      const controllers = registry.getRegisteredControllers();
+
+      for (const controllerClass of controllers) {
+        await registerServiceInstance(controllerClass, port, hostname);
+      }
+    } catch (error) {
+      // 如果服务注册失败，不影响应用启动（可能是没有配置 ServiceRegistryModule）
+      // 只在调试模式下输出警告
+      if (process.env.NODE_ENV === 'development') {
+        console.warn('[Application] Failed to register services:', error);
+      }
+    }
+  }
+
+  /**
+   * 自动注销服务
+   * 注销所有使用 @ServiceRegistry 装饰器的服务
+   */
+  private async deregisterServices(): Promise<void> {
+    try {
+      // 动态导入服务注册装饰器（避免循环依赖）
+      const { deregisterServiceInstance } = await import(
+        '../microservice/service-registry/decorators'
+      );
+
+      const registry = ControllerRegistry.getInstance();
+      const controllers = registry.getRegisteredControllers();
+
+      const port = this.server?.getPort() ?? this.options.port ?? 3000;
+      const hostname = this.server?.getHostname() ?? this.options.hostname;
+
+      for (const controllerClass of controllers) {
+        await deregisterServiceInstance(controllerClass, port, hostname);
+      }
+    } catch (error) {
+      // 如果服务注销失败，不影响应用关闭
+      if (process.env.NODE_ENV === 'development') {
+        console.warn('[Application] Failed to deregister services:', error);
+      }
+    }
+  }
+
   /**
    * 获取 DI 容器（用于注册服务）
    * @returns DI 容器

package/src/core/context.ts

@@ -1,6 +1,7 @@
 import { BodyParser } from '../request/body-parser';
 import type { UploadedFileInfo } from '../files';
 import type { BodyInit } from 'bun'
+import { type URLSearchParams, URL } from 'url';
 
 /**
  * 请求上下文

package/src/core/server.ts

@@ -125,4 +125,18 @@ export class BunServer {
   public isRunning(): boolean {
     return this.server !== undefined;
   }
+
+  /**
+   * 获取服务器端口
+   */
+  public getPort(): number {
+    return this.options.port ?? 3000;
+  }
+
+  /**
+   * 获取服务器主机名
+   */
+  public getHostname(): string | undefined {
+    return this.options.hostname;
+  }
 }

package/src/index.ts

@@ -6,9 +6,24 @@ export { Route, Router, RouteRegistry } from './router';
 export { GET, POST, PUT, DELETE, PATCH } from './router/decorators';
 export type { HttpMethod, RouteHandler, RouteMatch } from './router/types';
 export { BodyParser, RequestWrapper, ResponseBuilder } from './request';
-export { Body, Query, Param, Header, ParamBinder, Controller, ControllerRegistry } from './controller';
+export {
+  Body,
+  Query,
+  QueryMap,
+  Param,
+  Header,
+  HeaderMap,
+  ParamBinder,
+  Controller,
+  ControllerRegistry,
+} from './controller';
 export { Context as ContextParam } from './controller';
-export type { ParamMetadata, ControllerMetadata } from './controller';
+export type {
+  ParamMetadata,
+  QueryMapOptions,
+  HeaderMapOptions,
+  ControllerMetadata,
+} from './controller';
 export { Container } from './di/container';
 export { Injectable, Inject } from './di/decorators';
 export { Lifecycle, type ProviderConfig, type DependencyMetadata } from './di/types';
@@ -291,4 +306,85 @@ export type {
   SessionData,
   RedisSessionStoreOptions,
 } from './session';
+// Microservice 模块
+export {
+  ConfigCenterModule,
+  NacosConfigCenter,
+  CONFIG_CENTER_TOKEN,
+  type ConfigCenterModuleOptions,
+  type ConfigCenterProvider,
+  type NacosConfigCenterOptions,
+  type ConfigCenter,
+  type ConfigChangeListener,
+  type ConfigResult,
+} from './microservice';
+export {
+  ServiceRegistryModule,
+  NacosServiceRegistry,
+  SERVICE_REGISTRY_TOKEN,
+  type ServiceRegistryModuleOptions,
+  type ServiceRegistryProvider,
+  type NacosServiceRegistryOptions,
+  type ServiceRegistry,
+  type GetInstancesOptions,
+  type InstancesChangeListener,
+  type ServiceInstance,
+} from './microservice';
+// Service Client 模块
+export {
+  ServiceClient,
+  LoadBalancerFactory,
+  RandomLoadBalancer,
+  RoundRobinLoadBalancer,
+  WeightedRoundRobinLoadBalancer,
+  ConsistentHashLoadBalancer,
+  LeastActiveLoadBalancer,
+  TraceIdRequestInterceptor,
+  UserInfoRequestInterceptor,
+  RequestLogInterceptor,
+  ResponseLogInterceptor,
+  ResponseTransformInterceptor,
+  ErrorHandlerInterceptor,
+  type LoadBalanceStrategy,
+  type LoadBalancer,
+  type ServiceCallOptions,
+  type ServiceCallResponse,
+  type ServiceRequestInterceptor,
+  type ServiceResponseInterceptor,
+  type ServiceCallError,
+} from './microservice';
+// Governance 模块
+export {
+  CircuitBreaker,
+  CircuitBreakerState,
+  RateLimiter,
+  RetryStrategyImpl,
+  type CircuitBreakerOptions,
+  type CircuitBreakerStats,
+  type RateLimiterOptions,
+  type RetryStrategy,
+} from './microservice';
+// Tracing 模块
+export {
+  Tracer,
+  ConsoleTraceCollector,
+  MemoryTraceCollector,
+  SpanStatus,
+  SpanKind,
+  type TraceId,
+  type SpanId,
+  type SpanContext,
+  type Span,
+  type SpanTags,
+  type SpanEvent,
+  type TracingOptions,
+  type TraceCollector,
+} from './microservice';
+// Monitoring 模块
+export {
+  ServiceMetricsCollector,
+  type ServiceCallMetrics,
+  type ServiceInstanceHealth,
+  type MonitoringOptions,
+} from './microservice';
 

package/src/microservice/config-center/config-center-module.ts

@@ -0,0 +1,98 @@
+import { Module, MODULE_METADATA_KEY, type ModuleProvider } from '../../di/module';
+import { NacosClient } from '@dangao/nacos-client';
+import type { NacosClientOptions } from '@dangao/nacos-client';
+import { NacosConfigCenter } from './nacos-config-center';
+import { CONFIG_CENTER_TOKEN, type ConfigCenter } from './types';
+
+/**
+ * 配置中心 Provider 类型
+ */
+export type ConfigCenterProvider = 'nacos' | 'consul' | 'etcd' | 'apollo';
+
+/**
+ * Nacos 配置中心选项
+ */
+export interface NacosConfigCenterOptions {
+  /**
+   * Nacos 客户端配置
+   */
+  client: NacosClientOptions;
+
+  /**
+   * 配置监听轮询间隔（毫秒）
+   * @default 3000
+   */
+  watchInterval?: number;
+}
+
+/**
+ * 配置中心模块选项
+ */
+export interface ConfigCenterModuleOptions {
+  /**
+   * Provider 类型
+   */
+  provider: ConfigCenterProvider;
+
+  /**
+   * Nacos 配置（当 provider 为 'nacos' 时使用）
+   */
+  nacos?: NacosConfigCenterOptions;
+
+  // 未来可以添加其他 provider 的配置
+  // consul?: ConsulConfigCenterOptions;
+  // etcd?: EtcdConfigCenterOptions;
+}
+
+/**
+ * 配置中心模块
+ */
+@Module({
+  providers: [],
+})
+export class ConfigCenterModule {
+  /**
+   * 创建配置中心模块
+   * @param options - 模块配置
+   */
+  public static forRoot(options: ConfigCenterModuleOptions): typeof ConfigCenterModule {
+    const providers: ModuleProvider[] = [];
+
+    let configCenter: ConfigCenter;
+
+    switch (options.provider) {
+      case 'nacos':
+        if (!options.nacos) {
+          throw new Error('Nacos configuration is required when provider is "nacos"');
+        }
+
+        const nacosClient = new NacosClient(options.nacos.client);
+        configCenter = new NacosConfigCenter(nacosClient, {
+          watchInterval: options.nacos.watchInterval,
+        });
+        break;
+
+      default:
+        throw new Error(`Unsupported config center provider: ${options.provider}`);
+    }
+
+    providers.push({
+      provide: CONFIG_CENTER_TOKEN,
+      useValue: configCenter,
+    });
+
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, ConfigCenterModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...(existingMetadata.providers || []), ...providers],
+      exports: [
+        ...(existingMetadata.exports || []),
+        CONFIG_CENTER_TOKEN,
+      ],
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, ConfigCenterModule);
+
+    return ConfigCenterModule;
+  }
+}
+

package/src/microservice/config-center/decorators.ts

@@ -0,0 +1,159 @@
+import 'reflect-metadata';
+import type { ConfigCenter } from './types';
+import { CONFIG_CENTER_TOKEN } from './types';
+import { ControllerRegistry } from '../../controller/controller';
+import type { Constructor } from '../../core/types';
+
+/**
+ * 配置中心值装饰器元数据键
+ */
+const CONFIG_CENTER_VALUE_METADATA_KEY = Symbol('config-center:value');
+
+/**
+ * 配置中心值元数据
+ */
+export interface ConfigCenterValueMetadata {
+  /**
+   * 配置 dataId
+   */
+  dataId: string;
+
+  /**
+   * 配置分组
+   */
+  groupName: string;
+
+  /**
+   * 命名空间（可选）
+   */
+  namespaceId?: string;
+
+  /**
+   * 默认值（可选）
+   */
+  defaultValue?: string;
+
+  /**
+   * 是否监听配置变更
+   */
+  watch?: boolean;
+}
+
+/**
+ * ConfigCenterValue 装饰器
+ * 用于自动注入配置中心的值
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class MyService {
+ *   @ConfigCenterValue('my-config', 'DEFAULT_GROUP')
+ *   public configValue: string = '';
+ *
+ *   @ConfigCenterValue('app-name', 'DEFAULT_GROUP', { defaultValue: 'MyApp' })
+ *   public appName: string = '';
+ * }
+ * ```
+ */
+export function ConfigCenterValue(
+  dataId: string,
+  groupName: string = 'DEFAULT_GROUP',
+  options?: {
+    namespaceId?: string;
+    defaultValue?: string;
+    watch?: boolean;
+  },
+): PropertyDecorator {
+  return function (target: object, propertyKey: string | symbol) {
+    const metadata: ConfigCenterValueMetadata = {
+      dataId,
+      groupName,
+      namespaceId: options?.namespaceId,
+      defaultValue: options?.defaultValue,
+      watch: options?.watch ?? false,
+    };
+
+    // 保存元数据
+    const existingMetadata: Map<string | symbol, ConfigCenterValueMetadata> =
+      Reflect.getMetadata(CONFIG_CENTER_VALUE_METADATA_KEY, target.constructor) ||
+      new Map();
+    existingMetadata.set(propertyKey, metadata);
+    Reflect.defineMetadata(
+      CONFIG_CENTER_VALUE_METADATA_KEY,
+      existingMetadata,
+      target.constructor,
+    );
+
+    // 定义属性描述符，实现自动注入
+    // 注意：属性 getter 必须是同步的，不能是 async
+    // 实际值通过 initializeConfigCenterValues 在实例化时预加载
+    let value: string | undefined = options?.defaultValue;
+
+    Object.defineProperty(target, propertyKey, {
+      get: () => {
+        // 同步返回已加载的值（如果还未加载，返回默认值）
+        return value ?? options?.defaultValue ?? '';
+      },
+      set: (newValue: string) => {
+        value = newValue;
+      },
+      enumerable: true,
+      configurable: true,
+    });
+  };
+}
+
+/**
+ * 获取类的所有配置中心值元数据
+ */
+export function getConfigCenterValueMetadata(
+  target: Constructor<unknown>,
+): Map<string | symbol, ConfigCenterValueMetadata> {
+  return (
+    Reflect.getMetadata(CONFIG_CENTER_VALUE_METADATA_KEY, target) || new Map()
+  );
+}
+
+/**
+ * 初始化类的配置中心值
+ * 在类实例化后调用，自动加载配置值
+ */
+export async function initializeConfigCenterValues(
+  instance: object,
+  target: Constructor<unknown>,
+): Promise<void> {
+  const metadata = getConfigCenterValueMetadata(target);
+  const container = ControllerRegistry.getInstance().getContainer();
+  const configCenter = container.resolve<ConfigCenter>(CONFIG_CENTER_TOKEN);
+
+  if (!configCenter) {
+    return;
+  }
+
+  for (const [propertyKey, meta] of metadata.entries()) {
+    try {
+      const result = await configCenter.getConfig(
+        meta.dataId,
+        meta.groupName,
+        meta.namespaceId,
+      );
+      (instance as any)[propertyKey] = result.content;
+
+      // 如果启用监听，设置监听器
+      if (meta.watch) {
+        configCenter.watchConfig(meta.dataId, meta.groupName, (newResult: any) => {
+          (instance as any)[propertyKey] = newResult.content;
+        });
+      }
+    } catch (error) {
+      console.error(
+        `[ConfigCenterValue] Failed to initialize config ${meta.dataId}:`,
+        error,
+      );
+      if (meta.defaultValue !== undefined) {
+        (instance as any)[propertyKey] = meta.defaultValue;
+      }
+    }
+  }
+}
+

package/src/microservice/config-center/index.ts

@@ -0,0 +1,13 @@
+export { ConfigCenterModule } from './config-center-module';
+export type { ConfigCenterModuleOptions, ConfigCenterProvider, NacosConfigCenterOptions } from './config-center-module';
+export { NacosConfigCenter } from './nacos-config-center';
+export { CONFIG_CENTER_TOKEN } from './types';
+export type { ConfigCenter, ConfigChangeListener, ConfigResult } from './types';
+export {
+  ConfigCenterValue,
+  getConfigCenterValueMetadata,
+  initializeConfigCenterValues,
+} from './decorators';
+export { NacosValue } from './nacos-decorators';
+export type { ConfigCenterValueMetadata } from './decorators';
+

package/src/microservice/config-center/nacos-config-center.ts

@@ -0,0 +1,126 @@
+import { NacosClient, NacosConfigClient } from '@dangao/nacos-client';
+import type { ConfigResult, ConfigChangeListener, ConfigCenter } from './types';
+
+/**
+ * Nacos 配置中心实现
+ * 实现 ConfigCenter 接口，内部使用 @dangao/nacos-client
+ */
+export class NacosConfigCenter implements ConfigCenter {
+  private readonly client: NacosClient;
+  private readonly configClient: NacosConfigClient;
+  private readonly watchers: Map<string, { listener: ConfigChangeListener; intervalId: number }> = new Map();
+  private readonly watchInterval: number = 3000; // 默认 3 秒轮询一次
+
+  public constructor(
+    client: NacosClient,
+    options?: {
+      /**
+       * 配置监听轮询间隔（毫秒）
+       * @default 3000
+       */
+      watchInterval?: number;
+    },
+  ) {
+    this.client = client;
+    this.configClient = new NacosConfigClient(client);
+    this.watchInterval = options?.watchInterval ?? 3000;
+  }
+
+  /**
+   * 获取配置
+   */
+  public async getConfig(
+    dataId: string,
+    groupName: string,
+    namespaceId?: string,
+  ): Promise<ConfigResult> {
+    const result = await this.configClient.getConfig({
+      dataId,
+      groupName,
+      namespaceId,
+    });
+
+    return {
+      content: result.content,
+      md5: result.md5,
+      lastModified: result.lastModified,
+      contentType: result.contentType,
+    };
+  }
+
+  /**
+   * 监听配置变更
+   * 通过轮询和 md5 比对实现配置热更新
+   */
+  public watchConfig(
+    dataId: string,
+    groupName: string,
+    listener: ConfigChangeListener,
+    namespaceId?: string,
+  ): () => void {
+    const key = this.getWatchKey(dataId, groupName, namespaceId);
+
+    // 如果已经存在监听器，先取消
+    const existing = this.watchers.get(key);
+    if (existing) {
+      clearInterval(existing.intervalId);
+    }
+
+    let lastMd5: string | undefined;
+
+    const intervalId = setInterval(async () => {
+      try {
+        const result = await this.getConfig(dataId, groupName, namespaceId);
+
+        // 通过 md5 判断配置是否变更
+        if (lastMd5 === undefined || lastMd5 !== result.md5) {
+          lastMd5 = result.md5;
+          listener(result);
+        }
+      } catch (error) {
+        // 监听错误不抛出，避免影响其他监听器
+        console.error(`[NacosConfigCenter] Failed to watch config ${dataId}:`, error);
+      }
+    }, this.watchInterval) as unknown as number;
+
+    // 立即获取一次配置
+    this.getConfig(dataId, groupName, namespaceId)
+      .then((result) => {
+        lastMd5 = result.md5;
+        listener(result);
+      })
+      .catch((error) => {
+        console.error(`[NacosConfigCenter] Failed to get initial config ${dataId}:`, error);
+      });
+
+    this.watchers.set(key, { listener, intervalId });
+
+    // 返回取消监听的函数
+    return () => {
+      const watcher = this.watchers.get(key);
+      if (watcher) {
+        clearInterval(watcher.intervalId);
+        this.watchers.delete(key);
+      }
+    };
+  }
+
+  /**
+   * 关闭配置中心连接
+   */
+  public async close(): Promise<void> {
+    // 清除所有监听器
+    for (const watcher of this.watchers.values()) {
+      clearInterval(watcher.intervalId);
+    }
+    this.watchers.clear();
+  }
+
+  /**
+   * 生成监听器 key
+   */
+  private getWatchKey(dataId: string, groupName: string, namespaceId?: string): string {
+    return `${namespaceId ?? 'default'}:${groupName}:${dataId}`;
+  }
+}
+