@dangao/bun-server 1.0.0 → 1.0.3

package/src/testing/harness.ts

@@ -0,0 +1,96 @@
+import { performance } from 'node:perf_hooks';
+
+export interface BenchmarkResult {
+  name: string;
+  iterations: number;
+  durationMs: number;
+  opsPerSecond: number;
+}
+
+export interface StressResult {
+  name: string;
+  iterations: number;
+  concurrency: number;
+  durationMs: number;
+  errors: number;
+}
+
+/**
+ * 简单性能压测工具，方便在 bun:test 中快速基准测试组件
+ */
+export class PerformanceHarness {
+  public static async benchmark(
+    name: string,
+    iterations: number,
+    runner: (iteration: number) => void | Promise<void>,
+  ): Promise<BenchmarkResult> {
+    if (iterations <= 0) {
+      throw new Error('iterations must be greater than 0');
+    }
+
+    const start = performance.now();
+    for (let i = 0; i < iterations; i++) {
+      await runner(i);
+    }
+    const durationMs = performance.now() - start;
+    const opsPerSecond = iterations / Math.max(durationMs / 1000, 0.0001);
+
+    return {
+      name,
+      iterations,
+      durationMs,
+      opsPerSecond,
+    };
+  }
+}
+
+/**
+ * 简单压力测试运行器，支持并发执行任务并收集错误
+ */
+export class StressTester {
+  public static async run(
+    name: string,
+    iterations: number,
+    concurrency: number,
+    task: (iteration: number) => Promise<void>,
+  ): Promise<StressResult> {
+    if (iterations <= 0) {
+      throw new Error('iterations must be greater than 0');
+    }
+    if (concurrency <= 0) {
+      throw new Error('concurrency must be greater than 0');
+    }
+
+    let next = 0;
+    let errors = 0;
+    const start = performance.now();
+
+    const worker = async () => {
+      while (true) {
+        const current = next;
+        next += 1;
+        if (current >= iterations) {
+          break;
+        }
+        try {
+          await task(current);
+        } catch (error) {
+          errors += 1;
+        }
+      }
+    };
+
+    const workers = Array.from({ length: Math.min(concurrency, iterations) }, () => worker());
+    await Promise.all(workers);
+
+    const durationMs = performance.now() - start;
+    return {
+      name,
+      iterations,
+      concurrency: Math.min(concurrency, iterations),
+      durationMs,
+      errors,
+    };
+  }
+}
+

package/src/validation/decorators.ts

@@ -0,0 +1,95 @@
+import 'reflect-metadata';
+import type { ValidationRuleDefinition, ValidationMetadata } from './types';
+
+const VALIDATION_METADATA_KEY = Symbol('validation:param');
+
+function getOrCreateMetadata(target: object, propertyKey: string | symbol): ValidationMetadata[] {
+  const existing = Reflect.getMetadata(VALIDATION_METADATA_KEY, target, propertyKey) as
+    | ValidationMetadata[]
+    | undefined;
+  if (existing) {
+    return existing;
+  }
+  const metadata: ValidationMetadata[] = [];
+  Reflect.defineMetadata(VALIDATION_METADATA_KEY, metadata, target, propertyKey);
+  return metadata;
+}
+
+/**
+ * 通用校验装饰器
+ * @param rules - 校验规则
+ */
+export function Validate(...rules: ValidationRuleDefinition[]): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey) {
+      throw new Error('@Validate decorator can only be used on methods');
+    }
+    if (!rules.length) {
+      throw new Error('@Validate requires at least one validation rule');
+    }
+    const metadata = getOrCreateMetadata(target, propertyKey);
+    let entry = metadata.find((item) => item.index === parameterIndex);
+    if (!entry) {
+      entry = { index: parameterIndex, rules: [] };
+      metadata.push(entry);
+    }
+    entry.rules.push(...rules);
+  };
+}
+
+export interface RuleOption {
+  message?: string;
+}
+
+export function IsString(options: RuleOption = {}): ValidationRuleDefinition {
+  return {
+    name: 'isString',
+    message: options.message ?? '必须是字符串',
+    validate: (value) => typeof value === 'string',
+  };
+}
+
+export function IsNumber(options: RuleOption = {}): ValidationRuleDefinition {
+  return {
+    name: 'isNumber',
+    message: options.message ?? '必须是数字',
+    validate: (value) => typeof value === 'number' && !Number.isNaN(value),
+  };
+}
+
+export function IsEmail(options: RuleOption = {}): ValidationRuleDefinition {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return {
+    name: 'isEmail',
+    message: options.message ?? '必须是合法的邮箱地址',
+    validate: (value) => typeof value === 'string' && emailRegex.test(value),
+  };
+}
+
+export function IsOptional(): ValidationRuleDefinition {
+  return {
+    name: 'isOptional',
+    message: '',
+    optional: true,
+    validate: () => true,
+  };
+}
+
+export function MinLength(min: number, options: RuleOption = {}): ValidationRuleDefinition {
+  return {
+    name: 'minLength',
+    message: options.message ?? `长度不能小于 ${min}`,
+    validate: (value) => typeof value === 'string' && value.length >= min,
+  };
+}
+
+/**
+ * 获取方法参数的验证元数据
+ */
+export function getValidationMetadata(target: object, propertyKey: string | symbol): ValidationMetadata[] {
+  return (
+    (Reflect.getMetadata(VALIDATION_METADATA_KEY, target, propertyKey) as ValidationMetadata[]) || []
+  );
+}
+
+

package/src/validation/errors.ts

@@ -0,0 +1,28 @@
+export interface ValidationIssue {
+  /**
+   * 参数索引
+   */
+  index: number;
+
+  /**
+   * 失败的规则名称
+   */
+  rule: string;
+
+  /**
+   * 错误信息
+   */
+  message: string;
+}
+
+export class ValidationError extends Error {
+  public readonly issues: ValidationIssue[];
+
+  public constructor(message: string, issues: ValidationIssue[]) {
+    super(message);
+    this.name = 'ValidationError';
+    this.issues = issues;
+  }
+}
+
+

package/src/validation/index.ts

@@ -0,0 +1,14 @@
+export {
+  Validate,
+  IsString,
+  IsNumber,
+  IsEmail,
+  IsOptional,
+  MinLength,
+  getValidationMetadata,
+} from './decorators';
+export type { ValidationRuleDefinition, ValidationMetadata } from './types';
+export { validateParameters } from './validator';
+export { ValidationError, type ValidationIssue } from './errors';
+
+

package/src/validation/types.ts

@@ -0,0 +1,35 @@
+export interface ValidationRuleDefinition {
+  /**
+   * 规则名称
+   */
+  name: string;
+
+  /**
+   * 错误信息
+   */
+  message: string;
+
+  /**
+   * 校验函数
+   */
+  validate: (value: unknown) => boolean;
+
+  /**
+   * 是否为可选字段
+   */
+  optional?: boolean;
+}
+
+export interface ValidationMetadata {
+  /**
+   * 参数索引
+   */
+  index: number;
+
+  /**
+   * 规则列表
+   */
+  rules: ValidationRuleDefinition[];
+}
+
+

package/src/validation/validator.ts

@@ -0,0 +1,63 @@
+import type { ValidationMetadata, ValidationRuleDefinition } from './types';
+import { ValidationError, type ValidationIssue } from './errors';
+
+function shouldSkip(rule: ValidationRuleDefinition, value: unknown): boolean {
+  return rule.optional === true && (value === undefined || value === null);
+}
+
+function validateRule(
+  rule: ValidationRuleDefinition,
+  value: unknown,
+  index: number,
+): ValidationIssue | null {
+  if (shouldSkip(rule, value)) {
+    return null;
+  }
+  const passed = rule.validate(value);
+  if (passed) {
+    return null;
+  }
+  return {
+    index,
+    rule: rule.name,
+    message: rule.message,
+  };
+}
+
+/**
+ * 根据元数据验证参数
+ * @param params - 参数数组
+ * @param metadata - 验证元数据
+ */
+export function validateParameters(params: unknown[], metadata: ValidationMetadata[]): void {
+  if (!metadata.length) {
+    return;
+  }
+  const issues: ValidationIssue[] = [];
+
+  for (const item of metadata) {
+    const value = params[item.index];
+    let skipped = false;
+
+    for (const rule of item.rules) {
+      if (rule.optional && (value === undefined || value === null)) {
+        skipped = true;
+        break;
+      }
+      const issue = validateRule(rule, value, item.index);
+      if (issue) {
+        issues.push(issue);
+      }
+    }
+
+    if (skipped) {
+      continue;
+    }
+  }
+
+  if (issues.length > 0) {
+    throw new ValidationError('Validation failed', issues);
+  }
+}
+
+

package/src/websocket/decorators.ts

@@ -0,0 +1,51 @@
+import 'reflect-metadata';
+
+const GATEWAY_METADATA_KEY = Symbol('websocket:gateway');
+const HANDLER_METADATA_KEY = Symbol('websocket:handlers');
+
+export interface WebSocketGatewayMetadata {
+  path: string;
+}
+
+export interface WebSocketHandlerMetadata {
+  open?: string;
+  message?: string;
+  close?: string;
+}
+
+export function WebSocketGateway(path: string): ClassDecorator {
+  return (target: Function) => {
+    Reflect.defineMetadata(GATEWAY_METADATA_KEY, { path }, target);
+  };
+}
+
+function createHandlerDecorator(type: keyof WebSocketHandlerMetadata): MethodDecorator {
+  return function (target, propertyKey) {
+    if (typeof propertyKey !== 'string') {
+      throw new Error('@OnOpen/@OnMessage/@OnClose only support string method names');
+    }
+    const existing =
+      (Reflect.getMetadata(HANDLER_METADATA_KEY, target) as WebSocketHandlerMetadata | undefined) ||
+      {};
+    existing[type] = propertyKey;
+    Reflect.defineMetadata(HANDLER_METADATA_KEY, existing, target);
+  };
+}
+
+export const OnOpen = createHandlerDecorator('open');
+export const OnMessage = createHandlerDecorator('message');
+export const OnClose = createHandlerDecorator('close');
+
+export function getGatewayMetadata(
+  constructor: new (...args: unknown[]) => unknown,
+): WebSocketGatewayMetadata | undefined {
+  return Reflect.getMetadata(GATEWAY_METADATA_KEY, constructor);
+}
+
+export function getHandlerMetadata(target: object): WebSocketHandlerMetadata {
+  return (
+    (Reflect.getMetadata(HANDLER_METADATA_KEY, target) as WebSocketHandlerMetadata | undefined) || {}
+  );
+}
+
+

package/src/websocket/index.ts

@@ -0,0 +1,12 @@
+export {
+  WebSocketGateway,
+  OnOpen,
+  OnMessage,
+  OnClose,
+  getGatewayMetadata,
+  getHandlerMetadata,
+} from './decorators';
+export { WebSocketGatewayRegistry } from './registry';
+export type { WebSocketConnectionData } from './registry';
+
+

package/src/websocket/registry.ts

@@ -0,0 +1,133 @@
+import type { ServerWebSocket } from 'bun';
+
+import { Container } from '../di/container';
+import { ControllerRegistry } from '../controller/controller';
+import { getGatewayMetadata, getHandlerMetadata } from './decorators';
+import type { Constructor } from '@/core/types'
+
+interface GatewayDefinition {
+  path: string;
+  gatewayClass: Constructor<unknown>;
+  handlers: {
+    open?: string;
+    message?: string;
+    close?: string;
+  };
+  instance?: unknown;
+}
+
+export interface WebSocketConnectionData {
+  path: string;
+}
+
+export class WebSocketGatewayRegistry {
+  private static instance: WebSocketGatewayRegistry;
+  private readonly container: Container;
+  private readonly gateways = new Map<string, GatewayDefinition>();
+
+  private constructor() {
+    this.container = ControllerRegistry.getInstance().getContainer();
+  }
+
+  public static getInstance(): WebSocketGatewayRegistry {
+    if (!WebSocketGatewayRegistry.instance) {
+      WebSocketGatewayRegistry.instance = new WebSocketGatewayRegistry();
+    }
+    return WebSocketGatewayRegistry.instance;
+  }
+
+  public register(gatewayClass: Constructor<unknown>): void {
+    const metadata = getGatewayMetadata(gatewayClass);
+    if (!metadata) {
+      throw new Error(`WebSocket gateway ${gatewayClass.name} must use @WebSocketGateway()`);
+    }
+
+    const handlers = getHandlerMetadata(gatewayClass.prototype);
+    if (!handlers.open && !handlers.message && !handlers.close) {
+      throw new Error(`WebSocket gateway ${gatewayClass.name} must define at least one handler`);
+    }
+
+    if (!this.container.isRegistered(gatewayClass)) {
+      this.container.register(gatewayClass);
+    }
+
+    this.gateways.set(metadata.path, {
+      path: metadata.path,
+      gatewayClass,
+      handlers,
+    });
+  }
+
+  public hasGateway(path: string): boolean {
+    return this.gateways.has(path);
+  }
+
+  public clear(): void {
+    this.gateways.clear();
+  }
+
+  private getGateway(path: string): GatewayDefinition | undefined {
+    return this.gateways.get(path);
+  }
+
+  private getGatewayInstance(definition: GatewayDefinition): unknown {
+    if (!definition.instance) {
+      definition.instance = this.container.resolve(definition.gatewayClass);
+    }
+    return definition.instance;
+  }
+
+  private invokeHandler(
+    ws: ServerWebSocket<WebSocketConnectionData>,
+    definition: GatewayDefinition,
+    handlerName: string | undefined,
+    ...args: unknown[]
+  ): void {
+    if (!handlerName) {
+      return;
+    }
+    const instance = this.getGatewayInstance(definition);
+    const handler = (instance as Record<string, unknown>)[handlerName];
+    if (typeof handler === 'function') {
+      handler.apply(instance, [ws, ...args]);
+    }
+  }
+
+  public handleOpen(ws: ServerWebSocket<WebSocketConnectionData>): void {
+    const path = ws.data?.path;
+    const definition = path ? this.getGateway(path) : undefined;
+    if (!definition) {
+      ws.close(1008, 'Gateway not found');
+      return;
+    }
+    this.invokeHandler(ws, definition, definition.handlers.open);
+  }
+
+  public handleMessage(
+    ws: ServerWebSocket<WebSocketConnectionData>,
+    message: string | ArrayBuffer | ArrayBufferView,
+  ): void {
+    const path = ws.data?.path;
+    const definition = path ? this.getGateway(path) : undefined;
+    if (!definition) {
+      ws.close(1008, 'Gateway not found');
+      return;
+    }
+    this.invokeHandler(ws, definition, definition.handlers.message, message);
+  }
+
+  public handleClose(
+    ws: ServerWebSocket<WebSocketConnectionData>,
+    code: number,
+    reason: string,
+  ): void {
+    const path = ws.data?.path;
+    const definition = path ? this.getGateway(path) : undefined;
+    if (!definition) {
+      return;
+    }
+    this.invokeHandler(ws, definition, definition.handlers.close, code, reason);
+  }
+}
+
+