@dangao/bun-server 1.8.0 → 1.8.1

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

@@ -1,199 +1,251 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
 import 'reflect-metadata';
-import { describe, expect, test } from 'bun:test';
-import { InterceptorChain } from '../../src/interceptor';
-import type { Interceptor } from '../../src/interceptor';
+
+import { InterceptorChain } from '../../src/interceptor/interceptor-chain';
+import type { Interceptor } from '../../src/interceptor/types';
 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',
-    ]);
-  });
+  let container: Container;
+  let context: Context;
 
-  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');
+  beforeEach(() => {
+    container = new Container();
+    const request = new Request('http://localhost/test');
+    context = new Context(request, container);
   });
 
-  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');
+  describe('execute', () => {
+    test('should execute original method when no interceptors', async () => {
+      let methodCalled = false;
+      const originalMethod = () => {
+        methodCalled = true;
+        return 'result';
+      };
+
+      const result = await InterceptorChain.execute(
+        [],
+        {},
+        'testMethod',
+        originalMethod,
+        [],
+        container,
+        context,
+      );
+
+      expect(methodCalled).toBe(true);
+      expect(result).toBe('result');
+    });
+
+    test('should execute single interceptor', async () => {
+      const calls: string[] = [];
+
+      const interceptor: Interceptor = {
+        priority: 0,
+        execute: async (target, propertyKey, next, args, container, context) => {
+          calls.push('before');
+          const result = await next();
+          calls.push('after');
+          return result;
+        },
+      };
+
+      const result = await InterceptorChain.execute(
+        [interceptor],
+        {},
+        'testMethod',
+        () => {
+          calls.push('method');
+          return 'result';
+        },
+        [],
+        container,
+        context,
+      );
+
+      expect(calls).toEqual(['before', 'method', 'after']);
+      expect(result).toBe('result');
+    });
+
+    test('should execute interceptors in order', async () => {
+      const calls: number[] = [];
+
+      const interceptor1: Interceptor = {
+        priority: 1,
+        execute: async (target, propertyKey, next) => {
+          calls.push(1);
+          const result = await next();
+          calls.push(-1);
+          return result;
+        },
+      };
+
+      const interceptor2: Interceptor = {
+        priority: 2,
+        execute: async (target, propertyKey, next) => {
+          calls.push(2);
+          const result = await next();
+          calls.push(-2);
+          return result;
+        },
+      };
+
+      await InterceptorChain.execute(
+        [interceptor1, interceptor2],
+        {},
+        'testMethod',
+        () => {
+          calls.push(0);
+          return 'result';
+        },
+        [],
+        container,
+        context,
+      );
+
+      expect(calls).toEqual([1, 2, 0, -2, -1]);
+    });
+
+    test('should allow interceptor to modify return value', async () => {
+      const interceptor: Interceptor = {
+        priority: 0,
+        execute: async (target, propertyKey, next) => {
+          const result = await next();
+          return `modified-${result}`;
+        },
+      };
+
+      const result = await InterceptorChain.execute(
+        [interceptor],
+        {},
+        'testMethod',
+        () => 'original',
+        [],
+        container,
+        context,
+      );
+
+      expect(result).toBe('modified-original');
+    });
+
+    test('should pass arguments to interceptors', async () => {
+      let receivedArgs: unknown[] = [];
+
+      const interceptor: Interceptor = {
+        priority: 0,
+        execute: async (target, propertyKey, next, args) => {
+          receivedArgs = args;
+          return await next();
+        },
+      };
+
+      await InterceptorChain.execute(
+        [interceptor],
+        {},
+        'testMethod',
+        (a: number, b: string) => `${a}-${b}`,
+        [42, 'hello'],
+        container,
+        context,
+      );
+
+      expect(receivedArgs).toEqual([42, 'hello']);
+    });
+
+    test('should handle async original method', async () => {
+      const interceptor: Interceptor = {
+        priority: 0,
+        execute: async (target, propertyKey, next) => {
+          return await next();
+        },
+      };
+
+      const result = await InterceptorChain.execute(
+        [interceptor],
+        {},
+        'testMethod',
+        async () => {
+          await new Promise((r) => setTimeout(r, 10));
+          return 'async-result';
+        },
+        [],
+        container,
+        context,
+      );
+
+      expect(result).toBe('async-result');
+    });
+
+    test('should propagate errors from original method', async () => {
+      const interceptor: Interceptor = {
+        priority: 0,
+        execute: async (target, propertyKey, next) => {
+          return await next();
+        },
+      };
+
+      await expect(
+        InterceptorChain.execute(
+          [interceptor],
+          {},
+          'testMethod',
+          () => {
+            throw new Error('Method error');
+          },
+          [],
+          container,
+          context,
+        ),
+      ).rejects.toThrow('Method error');
+    });
+
+    test('should propagate errors from interceptor', async () => {
+      const interceptor: Interceptor = {
+        priority: 0,
+        execute: async () => {
+          throw new Error('Interceptor error');
+        },
+      };
+
+      await expect(
+        InterceptorChain.execute(
+          [interceptor],
+          {},
+          'testMethod',
+          () => 'result',
+          [],
+          container,
+          context,
+        ),
+      ).rejects.toThrow('Interceptor error');
+    });
+
+    test('should allow interceptor to modify arguments', async () => {
+      let finalArgs: unknown[] = [];
+
+      const interceptor: Interceptor = {
+        priority: 0,
+        execute: async (target, propertyKey, next, args) => {
+          // Modify arguments by calling next with new args
+          return await next(...['modified', 42]);
+        },
+      };
+
+      const result = await InterceptorChain.execute(
+        [interceptor],
+        {},
+        'testMethod',
+        (...args: unknown[]) => {
+          finalArgs = args;
+          return 'done';
+        },
+        ['original', 0],
+        container,
+        context,
+      );
+
+      expect(finalArgs).toEqual(['modified', 42]);
+    });
   });
 });
-

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

@@ -0,0 +1,221 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { scanInterceptorMetadata } from '../../src/interceptor/metadata';
+import { InterceptorRegistry } from '../../src/interceptor/interceptor-registry';
+import type { Interceptor } from '../../src/interceptor/types';
+import type { Container } from '../../src/di/container';
+import type { Context } from '../../src/core/context';
+
+// 创建测试用的拦截器
+class TestInterceptor1 implements Interceptor {
+  public async execute<T>(
+    target: unknown,
+    propertyKey: string | symbol,
+    originalMethod: (...args: unknown[]) => T | Promise<T>,
+    args: unknown[],
+    container: Container,
+    context?: Context,
+  ): Promise<T> {
+    return await Promise.resolve(originalMethod.apply(target, args));
+  }
+}
+
+class TestInterceptor2 implements Interceptor {
+  public async execute<T>(
+    target: unknown,
+    propertyKey: string | symbol,
+    originalMethod: (...args: unknown[]) => T | Promise<T>,
+    args: unknown[],
+    container: Container,
+    context?: Context,
+  ): Promise<T> {
+    return await Promise.resolve(originalMethod.apply(target, args));
+  }
+}
+
+// 测试用的元数据键
+const TEST_METADATA_KEY_1 = Symbol('test:interceptor:1');
+const TEST_METADATA_KEY_2 = Symbol('test:interceptor:2');
+
+describe('scanInterceptorMetadata', () => {
+  let registry: InterceptorRegistry;
+  let interceptor1: TestInterceptor1;
+  let interceptor2: TestInterceptor2;
+
+  beforeEach(() => {
+    registry = new InterceptorRegistry();
+    interceptor1 = new TestInterceptor1();
+    interceptor2 = new TestInterceptor2();
+  });
+
+  test('should return empty array when no interceptors registered', () => {
+    class TestClass {
+      public testMethod(): void {}
+    }
+
+    const interceptors = scanInterceptorMetadata(
+      TestClass.prototype,
+      'testMethod',
+      registry,
+    );
+
+    expect(interceptors).toEqual([]);
+  });
+
+  test('should return empty array when method has no matching metadata', () => {
+    // 注册拦截器
+    registry.register(TEST_METADATA_KEY_1, interceptor1);
+
+    class TestClass {
+      public testMethod(): void {}
+    }
+
+    // 方法没有 TEST_METADATA_KEY_1 元数据
+    const interceptors = scanInterceptorMetadata(
+      TestClass.prototype,
+      'testMethod',
+      registry,
+    );
+
+    expect(interceptors).toEqual([]);
+  });
+
+  test('should return interceptor when method has matching metadata', () => {
+    // 注册拦截器
+    registry.register(TEST_METADATA_KEY_1, interceptor1);
+
+    class TestClass {
+      public testMethod(): void {}
+    }
+
+    // 在方法上设置元数据
+    Reflect.defineMetadata(
+      TEST_METADATA_KEY_1,
+      { value: 'test' },
+      TestClass.prototype,
+      'testMethod',
+    );
+
+    const interceptors = scanInterceptorMetadata(
+      TestClass.prototype,
+      'testMethod',
+      registry,
+    );
+
+    expect(interceptors.length).toBe(1);
+    expect(interceptors[0]).toBe(interceptor1);
+  });
+
+  test('should return multiple interceptors sorted by priority', () => {
+    // 注册拦截器，interceptor2 优先级更高（数字更小）
+    registry.register(TEST_METADATA_KEY_1, interceptor1, { priority: 20 });
+    registry.register(TEST_METADATA_KEY_2, interceptor2, { priority: 10 });
+
+    class TestClass {
+      public testMethod(): void {}
+    }
+
+    // 在方法上设置两个元数据
+    Reflect.defineMetadata(
+      TEST_METADATA_KEY_1,
+      { value: 'test1' },
+      TestClass.prototype,
+      'testMethod',
+    );
+    Reflect.defineMetadata(
+      TEST_METADATA_KEY_2,
+      { value: 'test2' },
+      TestClass.prototype,
+      'testMethod',
+    );
+
+    const interceptors = scanInterceptorMetadata(
+      TestClass.prototype,
+      'testMethod',
+      registry,
+    );
+
+    expect(interceptors.length).toBe(2);
+    // 两个拦截器都应该存在
+    expect(interceptors).toContain(interceptor1);
+    expect(interceptors).toContain(interceptor2);
+  });
+
+  test('should only return interceptors for matching metadata', () => {
+    const unmatchedKey = Symbol('unmatched');
+    registry.register(TEST_METADATA_KEY_1, interceptor1);
+    registry.register(unmatchedKey, interceptor2);
+
+    class TestClass {
+      public testMethod(): void {}
+    }
+
+    // 只设置 TEST_METADATA_KEY_1 元数据
+    Reflect.defineMetadata(
+      TEST_METADATA_KEY_1,
+      { value: 'test' },
+      TestClass.prototype,
+      'testMethod',
+    );
+
+    const interceptors = scanInterceptorMetadata(
+      TestClass.prototype,
+      'testMethod',
+      registry,
+    );
+
+    expect(interceptors.length).toBe(1);
+    expect(interceptors[0]).toBe(interceptor1);
+  });
+
+  test('should handle null metadata value', () => {
+    registry.register(TEST_METADATA_KEY_1, interceptor1);
+
+    class TestClass {
+      public testMethod(): void {}
+    }
+
+    // 设置 null 值的元数据
+    Reflect.defineMetadata(
+      TEST_METADATA_KEY_1,
+      null,
+      TestClass.prototype,
+      'testMethod',
+    );
+
+    const interceptors = scanInterceptorMetadata(
+      TestClass.prototype,
+      'testMethod',
+      registry,
+    );
+
+    // null 值应该被忽略
+    expect(interceptors).toEqual([]);
+  });
+
+  test('should handle symbol property key', () => {
+    registry.register(TEST_METADATA_KEY_1, interceptor1);
+
+    const methodKey = Symbol('symbolMethod');
+
+    class TestClass {
+      public [methodKey](): void {}
+    }
+
+    Reflect.defineMetadata(
+      TEST_METADATA_KEY_1,
+      { value: 'test' },
+      TestClass.prototype,
+      methodKey,
+    );
+
+    const interceptors = scanInterceptorMetadata(
+      TestClass.prototype,
+      methodKey,
+      registry,
+    );
+
+    expect(interceptors.length).toBe(1);
+  });
+});