@dangao/bun-server 1.0.1 → 1.1.2

package/src/middleware/builtin/static-file.ts

@@ -0,0 +1,88 @@
+import { normalize, resolve, sep } from 'path';
+
+import type { Middleware } from '../middleware';
+import type { HeadersInit } from 'bun'
+
+export interface StaticFileOptions {
+  root: string;
+  prefix?: string;
+  indexFile?: string;
+  enableCache?: boolean;
+  headers?: HeadersInit | Headers;
+}
+
+function isSubPath(root: string, target: string): boolean {
+  const normalizedRoot = normalize(root);
+  const normalizedTarget = normalize(target);
+  if (normalizedRoot === normalizedTarget) {
+    return true;
+  }
+  const rootWithSep = normalizedRoot.endsWith(sep) ? normalizedRoot : normalizedRoot + sep;
+  return normalizedTarget.startsWith(rootWithSep);
+}
+
+/**
+ * 静态文件服务中间件
+ */
+export function createStaticFileMiddleware(options: StaticFileOptions): Middleware {
+  if (!options.root) {
+    throw new Error('Static file middleware requires a root directory');
+  }
+
+  const root = resolve(options.root);
+  const prefix = options.prefix ?? '/';
+  const indexFile = options.indexFile ?? 'index.html';
+  const enableCache = options.enableCache ?? true;
+
+  return async (context, next) => {
+    if (!context.path.startsWith(prefix)) {
+      return await next();
+    }
+
+    let relativePath = context.path.slice(prefix.length);
+    if (!relativePath || relativePath === '') {
+      relativePath = '/';
+    }
+
+    let cleanPath = relativePath.startsWith('/') ? relativePath.slice(1) : relativePath;
+    if (cleanPath === '') {
+      cleanPath = '.';
+    }
+
+    const segments = cleanPath.split('/').filter((segment) => segment.length > 0);
+    if (segments.some((segment) => segment === '..')) {
+      context.setStatus(403);
+      return context.createResponse({ error: 'Forbidden' });
+    }
+
+    let targetPath = resolve(root, cleanPath);
+    if (context.path.endsWith('/') || relativePath === '/') {
+      targetPath = resolve(root, cleanPath, indexFile);
+    }
+
+    if (!isSubPath(root, targetPath)) {
+      context.setStatus(403);
+      return context.createResponse({ error: 'Forbidden' });
+    }
+
+    const file = Bun.file(targetPath);
+    if (!(await file.exists())) {
+      return await next();
+    }
+
+    const headers = new Headers(options.headers);
+    if (enableCache) {
+      headers.set('Cache-Control', 'public, max-age=31536000, immutable');
+    }
+    if (!headers.has('Content-Type') && file.type) {
+      headers.set('Content-Type', file.type);
+    }
+
+    return new Response(file, {
+      status: 200,
+      headers,
+    });
+  };
+}
+
+

package/src/middleware/decorators.ts

@@ -0,0 +1,92 @@
+import 'reflect-metadata';
+import type { Constructor } from '../core/types';
+import type { Middleware } from './middleware';
+import { createRateLimitMiddleware, type RateLimitOptions } from './builtin/rate-limit';
+
+const CLASS_MIDDLEWARE_METADATA_KEY = Symbol('middleware:class');
+const METHOD_MIDDLEWARE_METADATA_KEY = Symbol('middleware:method');
+
+/**
+ * 注册中间件到元数据
+ * @param target - 目标对象
+ * @param propertyKey - 属性键
+ * @param middlewares - 中间件列表
+ */
+function appendMiddlewareMetadata(
+  target: object,
+  propertyKey: string | symbol | undefined,
+  middlewares: Middleware[],
+): void {
+  if (!middlewares.length) {
+    return;
+  }
+
+  if (propertyKey === undefined) {
+    const existing = (Reflect.getMetadata(CLASS_MIDDLEWARE_METADATA_KEY, target) as Middleware[]) || [];
+    Reflect.defineMetadata(CLASS_MIDDLEWARE_METADATA_KEY, existing.concat(middlewares), target);
+    return;
+  }
+
+  const existing =
+    (Reflect.getMetadata(METHOD_MIDDLEWARE_METADATA_KEY, target, propertyKey) as Middleware[]) || [];
+  Reflect.defineMetadata(
+    METHOD_MIDDLEWARE_METADATA_KEY,
+    existing.concat(middlewares),
+    target,
+    propertyKey,
+  );
+}
+
+/**
+ * UseMiddleware 装饰器
+ * 可用于控制器类或方法
+ * @param middlewares - 中间件列表
+ */
+export function UseMiddleware(...middlewares: Middleware[]): ClassDecorator & MethodDecorator {
+  return function (target: object, propertyKey?: string | symbol) {
+    appendMiddlewareMetadata(
+      propertyKey === undefined ? (target as object) : target,
+      propertyKey,
+      middlewares,
+    );
+  };
+}
+
+/**
+ * RateLimit 装饰器
+ * 用于在控制器方法上应用速率限制
+ * @param options - 速率限制选项
+ */
+export function RateLimit(options: RateLimitOptions): MethodDecorator {
+  return function (target: object, propertyKey: string | symbol) {
+    const middleware = createRateLimitMiddleware(options);
+    appendMiddlewareMetadata(target, propertyKey, [middleware]);
+  };
+}
+
+/**
+ * 获取类级中间件
+ * @param constructor - 控制器构造函数
+ * @returns 中间件列表
+ */
+export function getClassMiddlewares(constructor: Constructor<unknown>): Middleware[] {
+  return (
+    (Reflect.getMetadata(CLASS_MIDDLEWARE_METADATA_KEY, constructor) as Middleware[]) || []
+  );
+}
+
+/**
+ * 获取方法级中间件
+ * @param target - 控制器原型
+ * @param propertyKey - 方法名
+ * @returns 中间件列表
+ */
+export function getMethodMiddlewares(
+  target: object,
+  propertyKey: string | symbol,
+): Middleware[] {
+  return (
+    (Reflect.getMetadata(METHOD_MIDDLEWARE_METADATA_KEY, target, propertyKey) as Middleware[]) ||
+    []
+  );
+}

package/src/middleware/index.ts

@@ -0,0 +1,11 @@
+export type { Middleware, NextFunction } from './middleware';
+export { MiddlewarePipeline, runMiddlewares } from './pipeline';
+export { UseMiddleware, RateLimit, getClassMiddlewares, getMethodMiddlewares } from './decorators';
+export {
+  createLoggerMiddleware,
+  createRequestLoggingMiddleware,
+  createErrorHandlingMiddleware,
+  createCorsMiddleware,
+} from './builtin';
+
+

package/src/middleware/middleware.ts

@@ -0,0 +1,13 @@
+import type { Context } from '../core/context';
+
+/**
+ * 中间件 Next 函数
+ */
+export type NextFunction = () => Promise<Response>;
+
+/**
+ * 中间件接口
+ */
+export type Middleware = (context: Context, next: NextFunction) => Promise<Response> | Response;
+
+

package/src/middleware/pipeline.ts

@@ -0,0 +1,93 @@
+import type { Context } from '../core/context';
+import type { Middleware, NextFunction } from './middleware';
+
+/**
+ * 中间件执行管道
+ */
+export class MiddlewarePipeline {
+  private readonly middlewares: Middleware[] = [];
+
+  public constructor(initialMiddlewares: Middleware[] = []) {
+    this.middlewares.push(...initialMiddlewares);
+  }
+
+  /**
+   * 注册中间件
+   * @param middleware - 要注册的中间件
+   */
+  public use(middleware: Middleware): void {
+    this.middlewares.push(middleware);
+  }
+
+  /**
+   * 清空所有中间件
+   */
+  public clear(): void {
+    this.middlewares.length = 0;
+  }
+
+  /**
+   * 是否存在中间件
+   */
+  public hasMiddlewares(): boolean {
+    return this.middlewares.length > 0;
+  }
+
+  /**
+   * 执行中间件管道
+   * @param context - 请求上下文
+   * @param finalHandler - 最终处理函数
+   * @returns 响应对象
+   */
+  public async run(context: Context, finalHandler: NextFunction): Promise<Response> {
+    const length = this.middlewares.length;
+    if (length === 0) {
+      return await finalHandler();
+    }
+
+    // 优化：使用索引而不是数组来跟踪调用状态，减少内存分配
+    let currentIndex = 0;
+    const called = new Array<boolean>(length).fill(false);
+
+    // 创建链式调用函数（从后往前构建）
+    const createNext = (index: number): NextFunction => {
+      if (index >= length) {
+        return finalHandler;
+      }
+
+      return async () => {
+        if (called[index]) {
+          throw new Error('next() called multiple times');
+        }
+        called[index] = true;
+        currentIndex = index + 1;
+        const middleware = this.middlewares[index];
+        return await middleware(context, createNext(index + 1));
+      };
+    };
+
+    return await createNext(0)();
+  }
+}
+
+/**
+ * 使用指定的中间件队列执行一次性管道
+ * @param middlewares - 中间件数组
+ * @param context - 请求上下文
+ * @param finalHandler - 最终处理函数
+ * @returns 响应对象
+ */
+export async function runMiddlewares(
+  middlewares: Middleware[],
+  context: Context,
+  finalHandler: NextFunction,
+): Promise<Response> {
+  if (middlewares.length === 0) {
+    return await finalHandler();
+  }
+
+  const pipeline = new MiddlewarePipeline(middlewares);
+  return await pipeline.run(context, finalHandler);
+}
+
+

package/src/queue/decorators.ts

@@ -0,0 +1,110 @@
+import 'reflect-metadata';
+
+/**
+ * 队列装饰器元数据键
+ */
+const QUEUE_METADATA_KEY = Symbol('@dangao/bun-server:queue:queue');
+const CRON_METADATA_KEY = Symbol('@dangao/bun-server:queue:cron');
+
+/**
+ * 队列配置
+ */
+export interface QueueOptions {
+  /**
+   * 队列名称
+   * @default 'default'
+   */
+  name?: string;
+}
+
+/**
+ * Cron 配置
+ */
+export interface CronDecoratorOptions {
+  /**
+   * Cron 表达式
+   */
+  pattern: string;
+
+  /**
+   * 时区
+   * @default 'UTC'
+   */
+  timezone?: string;
+
+  /**
+   * 是否立即执行一次
+   * @default false
+   */
+  runOnInit?: boolean;
+
+  /**
+   * 队列名称
+   * @default 'default'
+   */
+  queueName?: string;
+}
+
+/**
+ * 队列装饰器元数据
+ */
+export interface QueueMetadata {
+  name?: string;
+}
+
+export interface CronMetadata {
+  pattern: string;
+  timezone?: string;
+  runOnInit?: boolean;
+  queueName?: string;
+}
+
+/**
+ * 标记方法为队列任务处理器
+ * @param options - 队列配置
+ */
+export function Queue(options: QueueOptions = {}): MethodDecorator {
+  return function (
+    target: unknown,
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor,
+  ) {
+    const metadata: QueueMetadata = {
+      name: options.name,
+    };
+
+    Reflect.defineMetadata(QUEUE_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+
+/**
+ * 标记方法为定时任务（Cron）
+ * @param options - Cron 配置
+ */
+export function Cron(options: CronDecoratorOptions): MethodDecorator {
+  return function (
+    target: unknown,
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor,
+  ) {
+    const metadata: CronMetadata = {
+      pattern: options.pattern,
+      timezone: options.timezone,
+      runOnInit: options.runOnInit ?? false,
+      queueName: options.queueName,
+    };
+
+    Reflect.defineMetadata(CRON_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+
+/**
+ * 获取队列装饰器元数据
+ */
+export function getQueueMetadata(target: unknown): QueueMetadata | undefined {
+  return Reflect.getMetadata(QUEUE_METADATA_KEY, target as object);
+}
+
+export function getCronMetadata(target: unknown): CronMetadata | undefined {
+  return Reflect.getMetadata(CRON_METADATA_KEY, target as object);
+}

package/src/queue/index.ts

@@ -0,0 +1,26 @@
+export { QueueModule } from './queue-module';
+export { QueueService } from './service';
+export {
+  Queue,
+  Cron,
+  getQueueMetadata,
+  getCronMetadata,
+  type QueueOptions,
+  type CronDecoratorOptions,
+  type QueueMetadata,
+  type CronMetadata,
+} from './decorators';
+export {
+  MemoryQueueStore,
+  QUEUE_SERVICE_TOKEN,
+  QUEUE_OPTIONS_TOKEN,
+} from './types';
+export type {
+  QueueStore,
+  QueueModuleOptions,
+  Job,
+  JobData,
+  JobHandler,
+  JobOptions,
+  CronOptions,
+} from './types';

package/src/queue/queue-module.ts

@@ -0,0 +1,64 @@
+import { Module, MODULE_METADATA_KEY, type ModuleProvider } from '../di/module';
+
+import { QueueService } from './service';
+import {
+  QUEUE_OPTIONS_TOKEN,
+  QUEUE_SERVICE_TOKEN,
+  MemoryQueueStore,
+  type QueueModuleOptions,
+  type QueueStore,
+} from './types';
+
+@Module({
+  providers: [],
+})
+export class QueueModule {
+  /**
+   * 创建队列模块
+   * @param options - 模块配置
+   */
+  public static forRoot(
+    options: QueueModuleOptions = {},
+  ): typeof QueueModule {
+    const providers: ModuleProvider[] = [];
+
+    // 如果没有提供 store，使用默认的内存存储
+    const store: QueueStore = options.store ?? new MemoryQueueStore();
+
+    const service = new QueueService({
+      store,
+      defaultQueue: options.defaultQueue,
+      enableWorker: options.enableWorker,
+      concurrency: options.concurrency,
+    });
+
+    providers.push(
+      {
+        provide: QUEUE_SERVICE_TOKEN,
+        useValue: service,
+      },
+      {
+        provide: QUEUE_OPTIONS_TOKEN,
+        useValue: options,
+      },
+      QueueService,
+    );
+
+    // 动态更新模块元数据
+    const existingMetadata =
+      Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...(existingMetadata.providers || []), ...providers],
+      exports: [
+        ...(existingMetadata.exports || []),
+        QUEUE_SERVICE_TOKEN,
+        QUEUE_OPTIONS_TOKEN,
+        QueueService,
+      ],
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, QueueModule);
+
+    return QueueModule;
+  }
+}