@dangao/bun-server 2.0.8 → 2.2.0

package/src/router/route.ts

@@ -3,6 +3,7 @@ import type { Constructor } from '../core/types';
 import type { HttpMethod, RouteHandler, RouteMatch } from './types';
 import { MiddlewarePipeline } from '../middleware/pipeline';
 import type { Middleware } from '../middleware';
+import { HttpException } from '../error';
 
 /**
  * 路由类
@@ -47,6 +48,7 @@ export class Route {
   private readonly middlewarePipeline: MiddlewarePipeline | null;
   private readonly staticKey?: string;
   public readonly isStatic: boolean;
+  private readonly timeout?: number;
 
   public constructor(
     method: HttpMethod,
@@ -55,12 +57,14 @@ export class Route {
     middlewares: Middleware[] = [],
     controllerClass?: Constructor<unknown>,
     methodName?: string,
+    timeout?: number,
   ) {
     this.method = method;
     this.path = path;
     this.handler = handler;
     this.controllerClass = controllerClass;
     this.methodName = methodName;
+    this.timeout = timeout;
 
     this.isStatic = !path.includes(':') && !path.includes('*');
     if (this.isStatic) {
@@ -124,11 +128,35 @@ export class Route {
    * @returns 响应对象
    */
   public async execute(context: Context): Promise<Response> {
-    if (!this.middlewarePipeline || !this.middlewarePipeline.hasMiddlewares()) {
-      return await this.handler(context);
+    const executeHandler = async (): Promise<Response> => {
+      if (!this.middlewarePipeline || !this.middlewarePipeline.hasMiddlewares()) {
+        return await this.handler(context);
+      }
+      return await this.middlewarePipeline.run(
+        context,
+        async () => await this.handler(context),
+      );
+    };
+
+    if (!this.timeout || this.timeout <= 0) {
+      return await executeHandler();
     }
 
-    return await this.middlewarePipeline.run(context, async () => this.handler(context));
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeoutPromise = new Promise<Response>((_, reject) => {
+      timer = setTimeout(
+        () => reject(new HttpException(408, 'Request Timeout')),
+        this.timeout,
+      );
+    });
+
+    try {
+      return await Promise.race([executeHandler(), timeoutPromise]);
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
   }
 
   /**

package/src/router/router.ts

@@ -49,10 +49,19 @@ export class Router {
     middlewares: Middleware[] = [],
     controllerClass?: Constructor<unknown>,
     methodName?: string,
+    timeout?: number,
   ): void {
     // 规范化路径
     const normalizedPath = this.normalizePath(path);
-    const route = new Route(method, normalizedPath, handler, middlewares, controllerClass, methodName);
+    const route = new Route(
+      method,
+      normalizedPath,
+      handler,
+      middlewares,
+      controllerClass,
+      methodName,
+      timeout,
+    );
     this.routes.push(route);
     const staticKey = route.getStaticKey();
     if (staticKey) {

package/src/router/timeout-decorator.ts

@@ -0,0 +1,35 @@
+import 'reflect-metadata';
+
+import type { Constructor } from '../core/types';
+
+export const IDLE_TIMEOUT_KEY = Symbol('@dangao/bun-server:route:idle-timeout');
+
+export function IdleTimeout(ms: number): MethodDecorator & ClassDecorator {
+  return (target: object, propertyKey?: string | symbol) => {
+    if (propertyKey !== undefined) {
+      Reflect.defineMetadata(IDLE_TIMEOUT_KEY, ms, target, propertyKey);
+      return;
+    }
+    Reflect.defineMetadata(IDLE_TIMEOUT_KEY, ms, target);
+  };
+}
+
+export function getIdleTimeout(
+  controllerClass: Constructor<unknown>,
+  methodName: string,
+): number | undefined {
+  const methodTimeout = Reflect.getMetadata(
+    IDLE_TIMEOUT_KEY,
+    controllerClass.prototype,
+    methodName,
+  ) as number | undefined;
+  if (typeof methodTimeout === 'number') {
+    return methodTimeout;
+  }
+  const classTimeout = Reflect.getMetadata(
+    IDLE_TIMEOUT_KEY,
+    controllerClass,
+  ) as number | undefined;
+  return typeof classTimeout === 'number' ? classTimeout : undefined;
+}
+

package/tests/core/application.test.ts

@@ -87,5 +87,15 @@ describe('Application', () => {
       await app2.stop();
     }
   });
+
+  test('should pass idleTimeout to BunServer options', async () => {
+    const port = getTestPort();
+    app = new Application({ port, idleTimeout: 8 });
+    await app.listen();
+
+    const server = app.getServer() as any;
+    expect(server).toBeDefined();
+    expect(server.options.idleTimeout).toBe(8);
+  });
 });