@dangao/bun-server 1.1.4 → 1.3.0

package/tests/controller/param-map.test.ts

@@ -0,0 +1,237 @@
+import { describe, expect, test } from 'bun:test';
+
+import { ParamBinder } from '../../src/controller/param-binder';
+import {
+  QueryMap,
+  HeaderMap,
+  type QueryMapOptions,
+  type HeaderMapOptions,
+} from '../../src/controller/decorators';
+import { Context } from '../../src/core/context';
+
+class QueryMapController {
+  public constructor(public readonly store: unknown[] = []) {}
+
+  public async handle(@QueryMap() query: Record<string, string | string[]>) {
+    this.store.push(query);
+    return query;
+  }
+
+  public async handleTransformed(
+    @QueryMap<{ name: string; age: number }>((input) => ({
+      name: (input.name as string) ?? '',
+      age: Number((input.age as string) ?? '0'),
+    }))
+    query: { name: string; age: number },
+  ) {
+    this.store.push(query);
+    return query;
+  }
+
+  public async handleValidated(
+    @QueryMap<{ foo: string }>(
+      ((input) => ({ foo: input.foo as string })) as QueryMapOptions<{ foo: string }>['transform'],
+    )
+    query: { foo: string },
+  ) {
+    if (!query.foo) {
+      throw new Error('validation failed');
+    }
+    this.store.push(query);
+    return query;
+  }
+}
+
+class HeaderMapController {
+  public constructor(public readonly store: unknown[] = []) {}
+
+  public async handle(
+    @HeaderMap() headers: Record<string, string | string[]>,
+  ) {
+    this.store.push(headers);
+    return headers;
+  }
+
+  public async handlePicked(
+    @HeaderMap({
+      normalize: true,
+      pick: ['x-custom', 'x-list'],
+    })
+    headers: Record<string, string | string[]>,
+  ) {
+    this.store.push(headers);
+    return headers;
+  }
+
+  public async handlePickedWithNormalizeFalse(
+    @HeaderMap({
+      normalize: false,
+      pick: ['X-Custom', 'X-List'], // 混合大小写
+    })
+    headers: Record<string, string | string[]>,
+  ) {
+    this.store.push(headers);
+    return headers;
+  }
+
+  public async handleTransformed(
+    @HeaderMap<{ token: string }>((input) => ({
+      token: (input.authorization as string) ?? '',
+    }))
+    headers: { token: string },
+  ) {
+    this.store.push(headers);
+    return headers;
+  }
+}
+
+function createContext(url: string, init?: RequestInit) {
+  return new Context(new Request(url, init));
+}
+
+describe('ParamBinder QueryMap', () => {
+  test('should aggregate query params into map with arrays', async () => {
+    const controller = new QueryMapController();
+    const ctx = createContext('http://localhost/api?q=1&q=2&name=alice');
+    const params = await ParamBinder.bind(
+      controller,
+      'handle',
+      ctx,
+    );
+    expect(params[0]).toEqual({ q: ['1', '2'], name: 'alice' });
+  });
+
+  test('should transform query map', async () => {
+    const controller = new QueryMapController();
+    const ctx = createContext('http://localhost/api?name=alice&age=20');
+    const params = await ParamBinder.bind(
+      controller,
+      'handleTransformed',
+      ctx,
+    );
+    expect(params[0]).toEqual({ name: 'alice', age: 20 });
+  });
+
+  test('should validate query map via user code', async () => {
+    const controller = new QueryMapController();
+    const ctx = createContext('http://localhost/api?foo=bar');
+    const params = await ParamBinder.bind(
+      controller,
+      'handleValidated',
+      ctx,
+    );
+    expect(params[0]).toEqual({ foo: 'bar' });
+  });
+});
+
+describe('ParamBinder HeaderMap', () => {
+  test('should aggregate headers into map with optional array', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-Token': 'abc',
+        'X-List': 'a, b',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handle',
+      ctx,
+    );
+    expect(params[0]).toMatchObject({
+      'x-token': 'abc',
+      'x-list': ['a', 'b'],
+    });
+  });
+
+  test('should pick and normalize headers', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-Custom': 'val',
+        'X-List': 'a, b',
+        'Other': 'ignore',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handlePicked',
+      ctx,
+    );
+    expect(params[0]).toEqual({
+      'x-custom': 'val',
+      'x-list': ['a', 'b'],
+    });
+  });
+
+  test('should pick headers with case-insensitive pick when normalize=true (default)', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-CUSTOM': 'val',
+        'X-LIST': 'a, b',
+        'Other': 'ignore',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handlePicked',
+      ctx,
+    );
+    expect(params[0]).toEqual({
+      'x-custom': 'val',
+      'x-list': ['a', 'b'],
+    });
+  });
+
+  test('should transform headers', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        Authorization: '  Bearer token123  ',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handleTransformed',
+      ctx,
+    );
+    expect(params[0]).toEqual({ token: 'Bearer token123' });
+  });
+
+  test('should trim single header value when no comma', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-Single': '  abc  ',
+      },
+    });
+    const params = await ParamBinder.bind(controller, 'handle', ctx);
+    expect(params[0]).toMatchObject({
+      'x-single': 'abc',
+    });
+  });
+
+  test('should pick headers with mixed-case pick keys when normalize=false', async () => {
+    const controller = new HeaderMapController();
+    const ctx = createContext('http://localhost/api', {
+      headers: {
+        'X-Custom': 'val',
+        'X-List': 'a, b',
+        'Other': 'ignore',
+      },
+    });
+    const params = await ParamBinder.bind(
+      controller,
+      'handlePickedWithNormalizeFalse',
+      ctx,
+    );
+    // Headers API 总是返回小写的 key，所以即使 normalize=false，结果中的 key 也是小写
+    expect(params[0]).toEqual({
+      'x-custom': 'val',
+      'x-list': ['a', 'b'],
+    });
+  });
+});
+
+

package/tests/core/context-service.test.ts

@@ -0,0 +1,191 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { ContextService, contextStore, CONTEXT_SERVICE_TOKEN } from '../../src/core/context-service';
+import { Context } from '../../src/core/context';
+import { Container } from '../../src/di/container';
+
+describe('ContextService', () => {
+  let contextService: ContextService;
+  let container: Container;
+
+  beforeEach(() => {
+    container = new Container();
+    contextService = new ContextService();
+    container.registerInstance(CONTEXT_SERVICE_TOKEN, contextService);
+  });
+
+  test('should create ContextService instance', () => {
+    expect(contextService).toBeInstanceOf(ContextService);
+  });
+
+  test('should get context from AsyncLocalStorage', async () => {
+    const request = new Request('http://localhost:3000/api/users?id=1');
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      const retrievedContext = contextService.getContext();
+      expect(retrievedContext).toBe(context);
+      expect(retrievedContext?.getQuery('id')).toBe('1');
+    });
+  });
+
+  test('should return undefined when not in request context', () => {
+    const context = contextService.getContext();
+    expect(context).toBeUndefined();
+  });
+
+  test('should get header from context', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      headers: { 'Authorization': 'Bearer token123' },
+    });
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      const header = contextService.getHeader('Authorization');
+      expect(header).toBe('Bearer token123');
+    });
+  });
+
+  test('should return null for non-existent header', async () => {
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      const header = contextService.getHeader('NonExistent');
+      expect(header).toBeNull();
+    });
+  });
+
+  test('should get query parameter from context', async () => {
+    const request = new Request('http://localhost:3000/api/users?name=John&age=30');
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      expect(contextService.getQuery('name')).toBe('John');
+      expect(contextService.getQuery('age')).toBe('30');
+      expect(contextService.getQuery('unknown')).toBeNull();
+    });
+  });
+
+  test('should get all query parameters', async () => {
+    const request = new Request('http://localhost:3000/api/users?name=John&age=30');
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      const all = contextService.getQueryAll();
+      expect(all.name).toBe('John');
+      expect(all.age).toBe('30');
+    });
+  });
+
+  test('should get path parameter from context', async () => {
+    const request = new Request('http://localhost:3000/api/users/123');
+    const context = new Context(request);
+    context.params = { id: '123' };
+
+    await contextStore.run(context, async () => {
+      expect(contextService.getParam('id')).toBe('123');
+      expect(contextService.getParam('unknown')).toBeUndefined();
+    });
+  });
+
+  test('should return null when body is not parsed', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'John' }),
+    });
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      expect(contextService.getBody()).toBeNull();
+    });
+  });
+
+  test('should get request method', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      method: 'POST',
+    });
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      expect(contextService.getMethod()).toBe('POST');
+    });
+  });
+
+  test('should get request path', async () => {
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      expect(contextService.getPath()).toBe('/api/users');
+    });
+  });
+
+  test('should get request URL', async () => {
+    const request = new Request('http://localhost:3000/api/users?id=1');
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      const url = contextService.getUrl();
+      expect(url).toBeDefined();
+      expect(url?.pathname).toBe('/api/users');
+      expect(url?.searchParams.get('id')).toBe('1');
+    });
+  });
+
+  test('should get client IP', async () => {
+    const request = new Request('http://localhost:3000/api/users', {
+      headers: { 'X-Forwarded-For': '192.168.1.1' },
+    });
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      const ip = contextService.getClientIp();
+      expect(ip).toBe('192.168.1.1');
+    });
+  });
+
+  test('should set response header', async () => {
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      contextService.setHeader('Content-Type', 'application/json');
+      expect(context.responseHeaders.get('Content-Type')).toBe('application/json');
+    });
+  });
+
+  test('should set status code', async () => {
+    const request = new Request('http://localhost:3000/api/users');
+    const context = new Context(request);
+
+    await contextStore.run(context, async () => {
+      contextService.setStatus(404);
+      expect(context.statusCode).toBe(404);
+    });
+  });
+
+  test('should handle multiple concurrent requests', async () => {
+    const request1 = new Request('http://localhost:3000/api/users?name=User1');
+    const request2 = new Request('http://localhost:3000/api/users?name=User2');
+    const context1 = new Context(request1);
+    const context2 = new Context(request2);
+
+    // 模拟并发请求
+    const promises = [
+      contextStore.run(context1, async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return contextService.getQuery('name');
+      }),
+      contextStore.run(context2, async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return contextService.getQuery('name');
+      }),
+    ];
+
+    const results = await Promise.all(promises);
+    expect(results[0]).toBe('User1');
+    expect(results[1]).toBe('User2');
+  });
+});
+

package/tests/di/scoped-lifecycle.test.ts

@@ -0,0 +1,223 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { Container } from '../../src/di/container';
+import { Injectable } from '../../src/di/decorators';
+import { Lifecycle } from '../../src/di/types';
+import { contextStore } from '../../src/core/context-service';
+import { Context } from '../../src/core/context';
+
+describe('Lifecycle.Scoped', () => {
+  let container: Container;
+
+  beforeEach(() => {
+    container = new Container();
+  });
+
+  test('should create new instance for each request', async () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {
+      public readonly id: string;
+
+      public constructor() {
+        this.id = Math.random().toString(36).substring(7);
+      }
+    }
+
+    container.register(ScopedService);
+
+    const request1 = new Request('http://localhost:3000/api/test1');
+    const request2 = new Request('http://localhost:3000/api/test2');
+    const context1 = new Context(request1);
+    const context2 = new Context(request2);
+
+    let instance1: ScopedService;
+    let instance2: ScopedService;
+
+    await contextStore.run(context1, async () => {
+      instance1 = container.resolve(ScopedService);
+    });
+
+    await contextStore.run(context2, async () => {
+      instance2 = container.resolve(ScopedService);
+    });
+
+    // 每个请求应该有独立的实例
+    expect(instance1!.id).not.toBe(instance2!.id);
+  });
+
+  test('should reuse instance within same request', async () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {
+      public readonly id: string;
+
+      public constructor() {
+        this.id = Math.random().toString(36).substring(7);
+      }
+    }
+
+    container.register(ScopedService);
+
+    const request = new Request('http://localhost:3000/api/test');
+    const context = new Context(request);
+
+    let instance1: ScopedService;
+    let instance2: ScopedService;
+
+    await contextStore.run(context, async () => {
+      instance1 = container.resolve(ScopedService);
+      instance2 = container.resolve(ScopedService);
+    });
+
+    // 同一请求内应该复用同一个实例
+    expect(instance1!.id).toBe(instance2!.id);
+  });
+
+  test('should handle scoped service with dependencies', async () => {
+    @Injectable({ lifecycle: Lifecycle.Singleton })
+    class SingletonService {
+      public readonly id = 'singleton';
+    }
+
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {
+      public constructor(public readonly singleton: SingletonService) {}
+    }
+
+    container.register(SingletonService);
+    container.register(ScopedService);
+
+    const request = new Request('http://localhost:3000/api/test');
+    const context = new Context(request);
+
+    let scopedInstance: ScopedService;
+
+    await contextStore.run(context, async () => {
+      scopedInstance = container.resolve(ScopedService);
+    });
+
+    expect(scopedInstance!.singleton).toBeDefined();
+    expect(scopedInstance!.singleton.id).toBe('singleton');
+  });
+
+  test('should handle scoped service depending on another scoped service', async () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedServiceA {
+      public readonly id = 'A';
+    }
+
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedServiceB {
+      public constructor(public readonly serviceA: ScopedServiceA) {}
+    }
+
+    container.register(ScopedServiceA);
+    container.register(ScopedServiceB);
+
+    const request = new Request('http://localhost:3000/api/test');
+    const context = new Context(request);
+
+    let serviceB: ScopedServiceB;
+    let serviceA: ScopedServiceA;
+
+    await contextStore.run(context, async () => {
+      serviceB = container.resolve(ScopedServiceB);
+      serviceA = container.resolve(ScopedServiceA);
+    });
+
+    // 同一请求内，ScopedServiceB 应该注入同一个 ScopedServiceA 实例
+    expect(serviceB!.serviceA).toBe(serviceA!);
+  });
+
+  test('should return undefined when resolving scoped service outside request context', () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {}
+
+    container.register(ScopedService);
+
+    // 不在请求上下文中，应该能够解析（但实例不会被缓存）
+    const instance = container.resolve(ScopedService);
+    expect(instance).toBeDefined();
+    expect(instance).toBeInstanceOf(ScopedService);
+  });
+
+  test('should handle concurrent requests with scoped services', async () => {
+    @Injectable({ lifecycle: Lifecycle.Scoped })
+    class ScopedService {
+      public readonly requestId: string;
+
+      public constructor() {
+        this.requestId = Math.random().toString(36).substring(7);
+      }
+    }
+
+    container.register(ScopedService);
+
+    const request1 = new Request('http://localhost:3000/api/test1');
+    const request2 = new Request('http://localhost:3000/api/test2');
+    const context1 = new Context(request1);
+    const context2 = new Context(request2);
+
+    const promises = [
+      contextStore.run(context1, async () => {
+        const instance1 = container.resolve(ScopedService);
+        await new Promise(resolve => setTimeout(resolve, 10));
+        const instance2 = container.resolve(ScopedService);
+        return { instance1: instance1.requestId, instance2: instance2.requestId };
+      }),
+      contextStore.run(context2, async () => {
+        const instance1 = container.resolve(ScopedService);
+        await new Promise(resolve => setTimeout(resolve, 10));
+        const instance2 = container.resolve(ScopedService);
+        return { instance1: instance1.requestId, instance2: instance2.requestId };
+      }),
+    ];
+
+    const results = await Promise.all(promises);
+
+    // 每个请求内的实例应该相同
+    expect(results[0].instance1).toBe(results[0].instance2);
+    expect(results[1].instance1).toBe(results[1].instance2);
+
+    // 不同请求的实例应该不同
+    expect(results[0].instance1).not.toBe(results[1].instance1);
+  });
+
+  test('should handle scoped service with factory', async () => {
+    let factoryCallCount = 0;
+
+    container.register('ScopedService', {
+      lifecycle: Lifecycle.Scoped,
+      factory: () => {
+        factoryCallCount++;
+        return { id: factoryCallCount };
+      },
+    });
+
+    const request1 = new Request('http://localhost:3000/api/test1');
+    const request2 = new Request('http://localhost:3000/api/test2');
+    const context1 = new Context(request1);
+    const context2 = new Context(request2);
+
+    let instance1: { id: number };
+    let instance2: { id: number };
+    let instance1Again: { id: number };
+
+    await contextStore.run(context1, async () => {
+      instance1 = container.resolve<{ id: number }>('ScopedService');
+      instance1Again = container.resolve<{ id: number }>('ScopedService');
+    });
+
+    await contextStore.run(context2, async () => {
+      instance2 = container.resolve<{ id: number }>('ScopedService');
+    });
+
+    // 同一请求内应该复用实例
+    expect(instance1!.id).toBe(instance1Again!.id);
+
+    // 不同请求应该创建新实例
+    expect(instance1!.id).not.toBe(instance2!.id);
+
+    // 工厂函数应该被调用 2 次（每个请求一次）
+    expect(factoryCallCount).toBe(2);
+  });
+});
+

package/tests/middleware/rate-limit.test.ts

@@ -1,20 +1,25 @@
-import { describe, expect, test, beforeEach } from 'bun:test';
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
 import { Application } from '../../src/core/application';
 import { Context } from '../../src/core/context';
 import { Controller } from '../../src/controller';
 import { GET } from '../../src/router/decorators';
 import { createRateLimitMiddleware, MemoryRateLimitStore, type RateLimitOptions } from '../../src/middleware/builtin/rate-limit';
 import { RateLimit } from '../../src/middleware/decorators';
+import { getTestPort } from '../utils/test-port';
 
 describe('Rate Limit Middleware', () => {
   let app: Application;
   let port: number;
 
   beforeEach(() => {
-    port = 3000 + Math.floor(Math.random() * 10000);
+    port = getTestPort();
     app = new Application({ port });
   });
 
+  afterEach(async () => {
+    await app.stop();
+  });
+
   test('should allow requests within limit', async () => {
     const middleware = createRateLimitMiddleware({
       max: 5,