@dangao/bun-server 1.0.3 → 1.1.2

package/tests/interceptor/interceptor-chain.test.ts

@@ -0,0 +1,199 @@
+import 'reflect-metadata';
+import { describe, expect, test } from 'bun:test';
+import { InterceptorChain } from '../../src/interceptor';
+import type { Interceptor } from '../../src/interceptor';
+import { Container } from '../../src/di/container';
+import { Context } from '../../src/core/context';
+
+describe('InterceptorChain', () => {
+  test('should execute method directly when no interceptors', async () => {
+    const container = new Container();
+    const target = {};
+    const propertyKey = 'testMethod';
+    const originalMethod = () => 'result';
+
+    const result = await InterceptorChain.execute(
+      [],
+      target,
+      propertyKey,
+      originalMethod,
+      [],
+      container,
+    );
+
+    expect(result).toBe('result');
+  });
+
+  test('should execute single interceptor', async () => {
+    const container = new Container();
+    const target = {};
+    const propertyKey = 'testMethod';
+    const originalMethod = () => 'result';
+    let executed = false;
+
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        executed = true;
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    const result = await InterceptorChain.execute(
+      [interceptor],
+      target,
+      propertyKey,
+      originalMethod,
+      [],
+      container,
+    );
+
+    expect(executed).toBe(true);
+    expect(result).toBe('result');
+  });
+
+  test('should execute multiple interceptors in order', async () => {
+    const container = new Container();
+    const target = {};
+    const propertyKey = 'testMethod';
+    const originalMethod = () => 'result';
+    const executionOrder: string[] = [];
+
+    const interceptor1: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        executionOrder.push('interceptor1-before');
+        const result = await Promise.resolve(originalMethod.apply(target, args));
+        executionOrder.push('interceptor1-after');
+        return result;
+      },
+    };
+
+    const interceptor2: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        executionOrder.push('interceptor2-before');
+        const result = await Promise.resolve(originalMethod.apply(target, args));
+        executionOrder.push('interceptor2-after');
+        return result;
+      },
+    };
+
+    const result = await InterceptorChain.execute(
+      [interceptor1, interceptor2],
+      target,
+      propertyKey,
+      originalMethod,
+      [],
+      container,
+    );
+
+    expect(result).toBe('result');
+    // 执行顺序：interceptor1 -> interceptor2 -> method -> interceptor2 -> interceptor1
+    expect(executionOrder).toEqual([
+      'interceptor1-before',
+      'interceptor2-before',
+      'interceptor2-after',
+      'interceptor1-after',
+    ]);
+  });
+
+  test('should handle async method', async () => {
+    const container = new Container();
+    const target = {};
+    const propertyKey = 'testMethod';
+    const originalMethod = async () => {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      return 'async-result';
+    };
+
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    const result = await InterceptorChain.execute(
+      [interceptor],
+      target,
+      propertyKey,
+      originalMethod,
+      [],
+      container,
+    );
+
+    expect(result).toBe('async-result');
+  });
+
+  test('should propagate errors', async () => {
+    const container = new Container();
+    const target = {};
+    const propertyKey = 'testMethod';
+    const originalMethod = () => {
+      throw new Error('test error');
+    };
+
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    await expect(
+      InterceptorChain.execute([interceptor], target, propertyKey, originalMethod, [], container),
+    ).rejects.toThrow('test error');
+  });
+
+  test('should pass context to interceptors', async () => {
+    const container = new Container();
+    const target = {};
+    const propertyKey = 'testMethod';
+    const originalMethod = () => 'result';
+    const context = new Context(new Request('http://localhost/test'));
+    let receivedContext: Context | undefined;
+
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, ctx) {
+        receivedContext = ctx;
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    await InterceptorChain.execute(
+      [interceptor],
+      target,
+      propertyKey,
+      originalMethod,
+      [],
+      container,
+      context,
+    );
+
+    expect(receivedContext).toBe(context);
+  });
+
+  test('should pass args to interceptors', async () => {
+    const container = new Container();
+    const target = {};
+    const propertyKey = 'testMethod';
+    const originalMethod = (a: string, b: number) => `${a}-${b}`;
+    let receivedArgs: unknown[] = [];
+
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        receivedArgs = args;
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    const result = await InterceptorChain.execute(
+      [interceptor],
+      target,
+      propertyKey,
+      originalMethod,
+      ['test', 123],
+      container,
+    );
+
+    expect(receivedArgs).toEqual(['test', 123]);
+    expect(result).toBe('test-123');
+  });
+});
+

package/tests/interceptor/interceptor-integration.test.ts

@@ -0,0 +1,230 @@
+import 'reflect-metadata';
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { Controller, ControllerRegistry } from '../../src/controller/controller';
+import { GET } from '../../src/router/decorators';
+import { RouteRegistry } from '../../src/router/registry';
+import {
+  InterceptorRegistry,
+  INTERCEPTOR_REGISTRY_TOKEN,
+  InterceptorChain,
+  BaseInterceptor,
+} from '../../src/interceptor';
+import type { Interceptor } from '../../src/interceptor';
+import { getTestPort } from '../utils/test-port';
+
+describe('Interceptor Integration', () => {
+  let app: Application;
+  let port: number;
+  let interceptorRegistry: InterceptorRegistry;
+
+  beforeEach(() => {
+    port = getTestPort();
+    app = new Application({ port });
+    interceptorRegistry = app.getContainer().resolve<InterceptorRegistry>(
+      INTERCEPTOR_REGISTRY_TOKEN,
+    );
+  });
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+    }
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+    interceptorRegistry.clear();
+  });
+
+  test('should execute custom interceptor', async () => {
+    const METADATA_KEY = Symbol('test:custom');
+    let interceptorExecuted = false;
+
+    // 创建自定义装饰器
+    function CustomDecorator(): MethodDecorator {
+      return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(METADATA_KEY, true, target, propertyKey);
+      };
+    }
+
+    // 创建拦截器
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        interceptorExecuted = true;
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    // 注册拦截器
+    interceptorRegistry.register(METADATA_KEY, interceptor);
+
+    // 创建控制器
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      @CustomDecorator()
+      public test() {
+        return { message: 'test' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/test`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.message).toBe('test');
+    expect(interceptorExecuted).toBe(true);
+  });
+
+  test('should execute multiple interceptors in chain', async () => {
+    const METADATA_KEY_1 = Symbol('test:custom:1');
+    const METADATA_KEY_2 = Symbol('test:custom:2');
+    const executionOrder: string[] = [];
+
+    // 创建自定义装饰器
+    function CustomDecorator1(): MethodDecorator {
+      return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(METADATA_KEY_1, true, target, propertyKey);
+      };
+    }
+
+    function CustomDecorator2(): MethodDecorator {
+      return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(METADATA_KEY_2, true, target, propertyKey);
+      };
+    }
+
+    // 创建拦截器
+    const interceptor1: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        executionOrder.push('interceptor1');
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    const interceptor2: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        executionOrder.push('interceptor2');
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    // 注册拦截器（interceptor2 优先级更高）
+    interceptorRegistry.register(METADATA_KEY_1, interceptor1, 100);
+    interceptorRegistry.register(METADATA_KEY_2, interceptor2, 50);
+
+    // 创建控制器
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      @CustomDecorator1()
+      @CustomDecorator2()
+      public test() {
+        executionOrder.push('method');
+        return { message: 'test' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/test`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.message).toBe('test');
+    // 执行顺序：interceptor2 (50) -> interceptor1 (100) -> method
+    expect(executionOrder).toEqual(['interceptor2', 'interceptor1', 'method']);
+  });
+
+  test('should work without interceptors (backward compatibility)', async () => {
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      public test() {
+        return { message: 'test' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/test`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.message).toBe('test');
+  });
+
+  test('should handle interceptor modifying result', async () => {
+    const METADATA_KEY = Symbol('test:modify');
+
+    function CustomDecorator(): MethodDecorator {
+      return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(METADATA_KEY, true, target, propertyKey);
+      };
+    }
+
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        const result = await Promise.resolve(originalMethod.apply(target, args));
+        // 修改结果
+        return { ...result, modified: true };
+      },
+    };
+
+    interceptorRegistry.register(METADATA_KEY, interceptor);
+
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      @CustomDecorator()
+      public test() {
+        return { message: 'test' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/test`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.message).toBe('test');
+    expect(data.modified).toBe(true);
+  });
+
+  test('should handle interceptor error', async () => {
+    const METADATA_KEY = Symbol('test:error');
+
+    function CustomDecorator(): MethodDecorator {
+      return (target, propertyKey, descriptor) => {
+        Reflect.defineMetadata(METADATA_KEY, true, target, propertyKey);
+      };
+    }
+
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        throw new Error('Interceptor error');
+      },
+    };
+
+    interceptorRegistry.register(METADATA_KEY, interceptor);
+
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      @CustomDecorator()
+      public test() {
+        return { message: 'test' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/test`);
+    // 错误应该被全局错误处理器处理
+    expect(response.status).toBe(500);
+  });
+});
+

package/tests/interceptor/interceptor-registry.test.ts

@@ -0,0 +1,200 @@
+import 'reflect-metadata';
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { InterceptorRegistry, INTERCEPTOR_REGISTRY_TOKEN } from '../../src/interceptor';
+import type { Interceptor } from '../../src/interceptor';
+import type { Container } from '../../src/di/container';
+import type { Context } from '../../src/core/context';
+
+describe('InterceptorRegistry', () => {
+  let registry: InterceptorRegistry;
+  const METADATA_KEY_1 = Symbol('test:metadata:1');
+  const METADATA_KEY_2 = Symbol('test:metadata:2');
+
+  beforeEach(() => {
+    registry = new InterceptorRegistry();
+  });
+
+  test('should register interceptor', () => {
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    registry.register(METADATA_KEY_1, interceptor);
+    expect(registry.hasInterceptor(METADATA_KEY_1)).toBe(true);
+    expect(registry.count(METADATA_KEY_1)).toBe(1);
+  });
+
+  test('should register multiple interceptors with same metadata key', () => {
+    const interceptor1: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+    const interceptor2: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    registry.register(METADATA_KEY_1, interceptor1, 100);
+    registry.register(METADATA_KEY_1, interceptor2, 50);
+
+    const interceptors = registry.getInterceptors(METADATA_KEY_1);
+    expect(interceptors.length).toBe(2);
+    // 应该按优先级排序（50 < 100，所以 interceptor2 在前）
+    expect(interceptors[0]).toBe(interceptor2);
+    expect(interceptors[1]).toBe(interceptor1);
+  });
+
+  test('should not register duplicate interceptor', () => {
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    registry.register(METADATA_KEY_1, interceptor);
+    registry.register(METADATA_KEY_1, interceptor); // 重复注册
+
+    expect(registry.count(METADATA_KEY_1)).toBe(1);
+  });
+
+  test('should get interceptors by metadata key', () => {
+    const interceptor1: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+    const interceptor2: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    registry.register(METADATA_KEY_1, interceptor1);
+    registry.register(METADATA_KEY_2, interceptor2);
+
+    const interceptors1 = registry.getInterceptors(METADATA_KEY_1);
+    const interceptors2 = registry.getInterceptors(METADATA_KEY_2);
+
+    expect(interceptors1.length).toBe(1);
+    expect(interceptors1[0]).toBe(interceptor1);
+    expect(interceptors2.length).toBe(1);
+    expect(interceptors2[0]).toBe(interceptor2);
+  });
+
+  test('should return empty array for non-existent metadata key', () => {
+    const interceptors = registry.getInterceptors(METADATA_KEY_1);
+    expect(interceptors).toEqual([]);
+  });
+
+  test('should check if interceptor exists', () => {
+    const interceptor: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    expect(registry.hasInterceptor(METADATA_KEY_1)).toBe(false);
+    registry.register(METADATA_KEY_1, interceptor);
+    expect(registry.hasInterceptor(METADATA_KEY_1)).toBe(true);
+  });
+
+  test('should clear all interceptors', () => {
+    const interceptor1: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+    const interceptor2: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    registry.register(METADATA_KEY_1, interceptor1);
+    registry.register(METADATA_KEY_2, interceptor2);
+
+    expect(registry.count()).toBe(2);
+    registry.clear();
+    expect(registry.count()).toBe(0);
+    expect(registry.hasInterceptor(METADATA_KEY_1)).toBe(false);
+    expect(registry.hasInterceptor(METADATA_KEY_2)).toBe(false);
+  });
+
+  test('should remove interceptors by metadata key', () => {
+    const interceptor1: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+    const interceptor2: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    registry.register(METADATA_KEY_1, interceptor1);
+    registry.register(METADATA_KEY_2, interceptor2);
+
+    expect(registry.count()).toBe(2);
+    registry.remove(METADATA_KEY_1);
+    expect(registry.count()).toBe(1);
+    expect(registry.hasInterceptor(METADATA_KEY_1)).toBe(false);
+    expect(registry.hasInterceptor(METADATA_KEY_2)).toBe(true);
+  });
+
+  test('should sort interceptors by priority', () => {
+    const interceptor1: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+    const interceptor2: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+    const interceptor3: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    // 注册顺序：1(100), 2(50), 3(75)
+    registry.register(METADATA_KEY_1, interceptor1, 100);
+    registry.register(METADATA_KEY_1, interceptor2, 50);
+    registry.register(METADATA_KEY_1, interceptor3, 75);
+
+    const interceptors = registry.getInterceptors(METADATA_KEY_1);
+    expect(interceptors.length).toBe(3);
+    // 应该按优先级排序：50 < 75 < 100
+    expect(interceptors[0]).toBe(interceptor2); // 50
+    expect(interceptors[1]).toBe(interceptor3); // 75
+    expect(interceptors[2]).toBe(interceptor1); // 100
+  });
+
+  test('should get all metadata keys', () => {
+    const interceptor1: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+    const interceptor2: Interceptor = {
+      async execute(target, propertyKey, originalMethod, args, container, context) {
+        return await Promise.resolve(originalMethod.apply(target, args));
+      },
+    };
+
+    registry.register(METADATA_KEY_1, interceptor1);
+    registry.register(METADATA_KEY_2, interceptor2);
+
+    const keys = Array.from(registry.getAllMetadataKeys());
+    expect(keys.length).toBe(2);
+    expect(keys).toContain(METADATA_KEY_1);
+    expect(keys).toContain(METADATA_KEY_2);
+  });
+});
+