@dangao/bun-server 1.0.0 → 1.0.3

package/tests/integration/session-e2e.test.ts

@@ -0,0 +1,207 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import 'reflect-metadata';
+import {
+  Application,
+  SessionModule,
+  SessionService,
+  SESSION_SERVICE_TOKEN,
+  ConfigModule,
+  Controller,
+  GET,
+  POST,
+  Inject,
+  Injectable,
+  Module,
+  Param,
+  Body,
+  Session,
+  createSessionMiddleware,
+} from '../../src';
+import { getTestPort } from '../utils/test-port';
+
+@Injectable()
+class AuthService {
+  public constructor(
+    @Inject(SESSION_SERVICE_TOKEN) private readonly sessionService: SessionService,
+  ) {}
+
+  public async login(username: string, sessionId?: string): Promise<{ sessionId: string }> {
+    // 如果提供了 sessionId，使用现有 Session，否则创建新 Session
+    let session;
+    if (sessionId) {
+      session = await this.sessionService.get(sessionId);
+      if (session) {
+        // 更新现有 Session 的数据
+        await this.sessionService.set(sessionId, {
+          username,
+          loginTime: Date.now(),
+        });
+        session = await this.sessionService.get(sessionId);
+      }
+    }
+    
+    if (!session) {
+      session = await this.sessionService.create({
+        username,
+        loginTime: Date.now(),
+      });
+    }
+    
+    return { sessionId: session.id };
+  }
+}
+
+@Controller('/api/auth')
+class AuthController {
+  public constructor(
+    @Inject(AuthService) private readonly authService: AuthService,
+  ) {}
+
+  @POST('/login')
+  public async login(
+    @Body() body: { username: string },
+    @Session() session: any,
+  ) {
+    // 使用中间件创建的 Session（如果存在）
+    const sessionId = session?.id;
+    return await this.authService.login(body.username, sessionId);
+  }
+}
+
+@Controller('/api/session')
+class SessionController {
+  public constructor(
+    @Inject(SESSION_SERVICE_TOKEN) private readonly sessionService: SessionService,
+  ) {}
+
+  @GET('/info')
+  public async getInfo(@Session() session: any) {
+    if (!session) {
+      return { error: 'No session' };
+    }
+    return {
+      sessionId: session.id,
+      username: session.data.username,
+    };
+  }
+
+  @POST('/set')
+  public async setValue(
+    @Session() session: any,
+    @Body() body: { key: string; value: unknown },
+  ) {
+    if (!session) {
+      return { error: 'No session' };
+    }
+    await this.sessionService.setValue(session.id, body.key, body.value);
+    return { success: true };
+  }
+}
+
+@Module({
+  controllers: [AuthController, SessionController],
+  providers: [AuthService],
+})
+class AppModule {}
+
+describe('Session E2E', () => {
+  let app: Application;
+  let port: number;
+
+  beforeEach(async () => {
+    port = getTestPort();
+    ConfigModule.forRoot({
+      defaultConfig: { app: { name: 'Session E2E Test', port } },
+    });
+    SessionModule.forRoot({
+      name: 'sessionId',
+      maxAge: 86400000,
+      rolling: true,
+    });
+    app = new Application({ port });
+    app.registerModule(SessionModule);
+    const container = app.getContainer();
+    app.use(createSessionMiddleware(container));
+    app.registerModule(AppModule);
+    await app.listen();
+  });
+
+  afterEach(async () => {
+    await app.stop();
+  });
+
+  test('should create session on login', async () => {
+    const response = await fetch(`http://localhost:${port}/api/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ username: 'testuser' }),
+    });
+
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.sessionId).toBeDefined();
+
+    // 检查 Cookie
+    const setCookie = response.headers.get('Set-Cookie');
+    expect(setCookie).toBeTruthy();
+    // Set-Cookie 可能返回字符串或数组
+    const cookieStr = Array.isArray(setCookie) ? setCookie[0] : setCookie;
+    if (cookieStr && typeof cookieStr === 'string') {
+      expect(cookieStr.includes('sessionId=')).toBe(true);
+    }
+  });
+
+  test('should get session info', async () => {
+    // 先登录获取 session
+    const loginResponse = await fetch(`http://localhost:${port}/api/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ username: 'testuser' }),
+    });
+    const loginData = await loginResponse.json();
+    const setCookie = loginResponse.headers.get('Set-Cookie');
+
+    // Set-Cookie 可能返回字符串或数组
+    const cookieStr = Array.isArray(setCookie) ? setCookie[0] : setCookie;
+    if (!cookieStr || typeof cookieStr !== 'string') {
+      throw new Error('Set-Cookie header not found');
+    }
+
+    // 提取 sessionId=value 部分（第一个分号之前的内容）
+    const cookieValue = cookieStr.split(';')[0].trim();
+
+    // 使用 Cookie 访问受保护端点
+    const infoResponse = await fetch(`http://localhost:${port}/api/session/info`, {
+      headers: {
+        Cookie: cookieValue,
+      },
+    });
+
+    expect(infoResponse.status).toBe(200);
+    const infoData = await infoResponse.json();
+    expect(infoData.sessionId).toBe(loginData.sessionId);
+    expect(infoData.username).toBe('testuser');
+  });
+
+  test('should set session value', async () => {
+    const loginResponse = await fetch(`http://localhost:${port}/api/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ username: 'testuser' }),
+    });
+    const cookies = loginResponse.headers.get('Set-Cookie') || '';
+
+    const setResponse = await fetch(`http://localhost:${port}/api/session/set`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Cookie: cookies.split(';')[0],
+      },
+      body: JSON.stringify({ key: 'cart', value: ['item1', 'item2'] }),
+    });
+
+    expect(setResponse.status).toBe(200);
+    const data = await setResponse.json();
+    expect(data.success).toBe(true);
+  });
+});

package/tests/metrics/metrics-module.test.ts

@@ -0,0 +1,178 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { Application } from '../../src/core/application';
+import { MetricsModule, MetricsCollector, createHttpMetricsMiddleware, type CustomMetric } from '../../src/metrics';
+import { Controller } from '../../src/controller';
+import { METRICS_SERVICE_TOKEN } from '../../src/metrics';
+import { Inject } from '../../src/di/decorators';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+
+describe('MetricsModule', () => {
+  beforeEach(() => {
+    // 清除模块元数据
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, MetricsModule);
+  });
+
+  test('should register metrics service provider', () => {
+    MetricsModule.forRoot();
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, MetricsModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.providers).toBeDefined();
+
+    const metricsProvider = metadata.providers.find(
+      (provider: any) => provider.provide === METRICS_SERVICE_TOKEN,
+    );
+    expect(metricsProvider).toBeDefined();
+    expect(metricsProvider.useValue).toBeInstanceOf(MetricsCollector);
+  });
+
+  test('should register custom metrics', () => {
+    const customMetric: CustomMetric = {
+      name: 'custom_metric',
+      type: 'gauge',
+      help: 'A custom metric',
+      getValue: () => 42,
+    };
+
+    MetricsModule.forRoot({
+      customMetrics: [customMetric],
+    });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, MetricsModule);
+    const metricsProvider = metadata.providers.find(
+      (provider: any) => provider.provide === METRICS_SERVICE_TOKEN,
+    );
+    const collector = metricsProvider.useValue as MetricsCollector;
+
+    // 验证自定义指标已注册（通过检查是否能获取到）
+    expect(collector).toBeInstanceOf(MetricsCollector);
+  });
+});
+
+describe('MetricsCollector', () => {
+  let collector: MetricsCollector;
+
+  beforeEach(() => {
+    collector = new MetricsCollector();
+  });
+
+  test('should increment counter', async () => {
+    collector.incrementCounter('test_counter');
+    collector.incrementCounter('test_counter', { label: 'value' }, 2);
+
+    const dataPoints = await collector.getAllDataPoints();
+    const counterPoints = dataPoints.filter((p) => p.name === 'test_counter');
+    expect(counterPoints.length).toBeGreaterThan(0);
+  });
+
+  test('should set gauge', async () => {
+    collector.setGauge('test_gauge', undefined, 100);
+    collector.setGauge('test_gauge', { label: 'value' }, 200);
+
+    const dataPoints = await collector.getAllDataPoints();
+    const gaugePoints = dataPoints.filter((p) => p.name === 'test_gauge');
+    expect(gaugePoints.length).toBeGreaterThan(0);
+  });
+
+  test('should observe histogram', async () => {
+    collector.observeHistogram('test_histogram', undefined, 0.5);
+    collector.observeHistogram('test_histogram', { label: 'value' }, 1.0);
+
+    const dataPoints = await collector.getAllDataPoints();
+    const histogramPoints = dataPoints.filter((p) => p.name.startsWith('test_histogram'));
+    expect(histogramPoints.length).toBeGreaterThan(0);
+  });
+
+  test('should collect custom metrics', async () => {
+    const customMetric: CustomMetric = {
+      name: 'custom_gauge',
+      type: 'gauge',
+      help: 'Custom gauge metric',
+      getValue: () => 123,
+    };
+
+    collector.registerCustomMetric(customMetric);
+
+    const dataPoints = await collector.getAllDataPoints();
+    const customPoint = dataPoints.find((p) => p.name === 'custom_gauge');
+    expect(customPoint).toBeDefined();
+    expect(customPoint?.value).toBe(123);
+    expect(customPoint?.help).toBe('Custom gauge metric');
+  });
+
+  test('should reset all metrics', async () => {
+    collector.incrementCounter('test_counter');
+    collector.setGauge('test_gauge', undefined, 100);
+
+    collector.reset();
+
+    const dataPoints = await collector.getAllDataPoints();
+    // 自定义指标可能仍然存在
+    const nonCustomPoints = dataPoints.filter((p) => !p.name.startsWith('custom_'));
+    expect(nonCustomPoints.length).toBe(0);
+  });
+});
+
+describe('PrometheusFormatter', () => {
+  test('should format metrics in Prometheus format', async () => {
+    const collector = new MetricsCollector();
+    collector.incrementCounter('http_requests_total', { method: 'GET', status: '200' });
+    collector.setGauge('active_connections', undefined, 10);
+
+    const { PrometheusFormatter } = await import('../../src/metrics/prometheus');
+    const formatter = new PrometheusFormatter();
+    const dataPoints = await collector.getAllDataPoints();
+    const formatted = formatter.format(dataPoints);
+
+    expect(formatted).toContain('http_requests_total');
+    expect(formatted).toContain('active_connections');
+    expect(formatted).toContain('method="GET"');
+    expect(formatted).toContain('status="200"');
+  });
+});
+
+describe('MetricsController', () => {
+  test('should create controller instance', () => {
+    const collector = new MetricsCollector();
+    const { MetricsController } = require('../../src/metrics/controller');
+    const controller = new MetricsController(collector, {});
+    expect(controller).toBeDefined();
+  });
+
+  test('should format metrics response', async () => {
+    const collector = new MetricsCollector();
+    collector.incrementCounter('test_counter', { label: 'value' });
+
+    const { MetricsController } = await import('../../src/metrics/controller');
+    const controller = new MetricsController(collector, {});
+
+    const response = await controller.metrics();
+    expect(response.status).toBe(200);
+    expect(response.headers.get('Content-Type')).toContain('text/plain');
+
+    const text = await response.text();
+    expect(text).toContain('test_counter');
+  });
+});
+
+describe('createHttpMetricsMiddleware', () => {
+  test('should collect HTTP request metrics', async () => {
+    const collector = new MetricsCollector();
+    const middleware = createHttpMetricsMiddleware(collector);
+
+    const { Context } = await import('../../src/core/context');
+    const context = new Context(new Request('http://localhost:3000/api/test', { method: 'GET' }));
+
+    await middleware(context, async () => {
+      return new Response('OK', { status: 200 });
+    });
+
+    const dataPoints = await collector.getAllDataPoints();
+    const requestTotal = dataPoints.find((p) => p.name === 'http_requests_total');
+    expect(requestTotal).toBeDefined();
+    expect(requestTotal?.labels?.method).toBe('GET');
+    expect(requestTotal?.labels?.status).toBe('200');
+  });
+});

package/tests/middleware/builtin.test.ts

@@ -0,0 +1,206 @@
+import { describe, expect, test } from 'bun:test';
+
+import { Context } from '../../src/core/context';
+import {
+  createLoggerMiddleware,
+  createRequestLoggingMiddleware,
+  createErrorHandlingMiddleware,
+  createCorsMiddleware,
+  runMiddlewares,
+} from '../../src/middleware';
+import { ValidationError } from '../../src/validation/errors';
+import { HttpException } from '../../src/error/http-exception';
+
+function createContext(url = 'http://localhost:3000/api/test', method: string = 'GET'): Context {
+  return new Context(
+    new Request(url, {
+      method,
+      headers: {
+        Origin: 'http://localhost:4000',
+      },
+    }),
+  );
+}
+
+describe('Builtin Middlewares', () => {
+  test('logger middleware should invoke custom logger', async () => {
+    const logs: string[] = [];
+    const logger = createLoggerMiddleware({
+      logger: (message) => logs.push(message),
+      prefix: '[TestLogger]',
+    });
+
+    const ctx = createContext();
+    const response = await runMiddlewares(
+      [logger],
+      ctx,
+      async () => ctx.createResponse({ message: 'ok' }),
+    );
+
+    expect(await response.json()).toEqual({ message: 'ok' });
+    expect(logs).toContain('[TestLogger] GET /api/test 200');
+  });
+
+  test('logger middleware should log downstream status code', async () => {
+    const logs: string[] = [];
+    const logger = createLoggerMiddleware({
+      logger: (message) => logs.push(message),
+      prefix: '[TestLogger]',
+    });
+
+    const ctx = createContext();
+    const response = await runMiddlewares(
+      [logger],
+      ctx,
+      async () => {
+        ctx.setStatus(404);
+        return ctx.createResponse({ error: 'not found' });
+      },
+    );
+
+    expect(response.status).toBe(404);
+    expect(logs).toContain('[TestLogger] GET /api/test 404');
+  });
+
+  test('request logging middleware should set duration header', async () => {
+    const ctx = createContext();
+    const middleware = createRequestLoggingMiddleware({ setHeader: true });
+
+    const response = await runMiddlewares(
+      [middleware],
+      ctx,
+      async () => ctx.createResponse({ ok: true }),
+    );
+
+    expect(response.headers.get('x-request-duration')).toBeDefined();
+  });
+
+  test('request logging middleware should capture error details', async () => {
+    const logs: Array<{ message: string; details?: Record<string, unknown> }> = [];
+    const middleware = createRequestLoggingMiddleware({
+      logger: (message, details) => logs.push({ message, details }),
+      setHeader: false,
+      prefix: '[ReqTest]',
+    });
+
+    const ctx = createContext();
+    await expect(
+      runMiddlewares([middleware], ctx, async () => {
+        throw new Error('request failed');
+      }),
+    ).rejects.toThrow('request failed');
+
+    expect(logs[0]?.message).toContain('[ReqTest] GET /api/test error');
+    expect(logs[0]?.details?.error).toBe('request failed');
+  });
+
+  test('error handling middleware should capture errors', async () => {
+    const errors: string[] = [];
+    const middleware = createErrorHandlingMiddleware({
+      exposeError: true,
+      logger: (error) => {
+        errors.push(error instanceof Error ? error.message : String(error));
+      },
+    });
+
+    const ctx = createContext();
+    const response = await runMiddlewares([middleware], ctx, async () => {
+      throw new Error('boom');
+    });
+
+    expect(errors).toContain('boom');
+    expect(response.status).toBe(500);
+    expect(await response.json()).toEqual({ error: 'boom' });
+  });
+
+  test('error handling middleware should format validation errors', async () => {
+    const middleware = createErrorHandlingMiddleware();
+    const ctx = createContext();
+    const response = await runMiddlewares([middleware], ctx, async () => {
+      throw new ValidationError('invalid', [{ index: 0, rule: 'IsString', message: 'bad' }]);
+    });
+
+    expect(response.status).toBe(400);
+    expect(await response.json()).toEqual({
+      error: 'invalid',
+      issues: [{ index: 0, rule: 'IsString', message: 'bad' }],
+    });
+  });
+
+  test('error handling middleware should return response when downstream throws Response', async () => {
+    const middleware = createErrorHandlingMiddleware();
+    const ctx = createContext();
+    const downstream = new Response('prebuilt', { status: 418 });
+    const response = await runMiddlewares([middleware], ctx, async () => {
+      throw downstream;
+    });
+
+    expect(response.status).toBe(418);
+    expect(await response.text()).toBe('prebuilt');
+  });
+
+  test('error handling middleware should respect HttpException exposure flag', async () => {
+    const middleware = createErrorHandlingMiddleware();
+    const ctx = createContext();
+    const response = await runMiddlewares([middleware], ctx, async () => {
+      throw new HttpException(503, 'Service down', { retry: true });
+    });
+
+    expect(response.status).toBe(503);
+    expect(await response.json()).toEqual({
+      error: 'Service down',
+      details: { retry: true },
+    });
+  });
+
+  test('error handling middleware should expose HttpException when configured', async () => {
+    const middleware = createErrorHandlingMiddleware({ exposeError: true });
+    const ctx = createContext();
+    const response = await runMiddlewares([middleware], ctx, async () => {
+      throw new HttpException(429, 'Too Many Requests');
+    });
+
+    expect(response.status).toBe(429);
+    expect(await response.json()).toEqual({ error: 'Too Many Requests' });
+  });
+
+  test('cors middleware should handle options request', async () => {
+    const cors = createCorsMiddleware({
+      origin: ['http://localhost:4000'],
+      allowedHeaders: ['Content-Type'],
+    });
+
+    const ctx = createContext('http://localhost:3000/api/cors', 'OPTIONS');
+    const response = await runMiddlewares([cors], ctx, async () =>
+      ctx.createResponse({ ok: true }),
+    );
+
+    expect(response.status).toBe(204);
+    expect(response.headers.get('Access-Control-Allow-Origin')).toBe('http://localhost:4000');
+    expect(response.headers.get('Access-Control-Allow-Headers')).toContain('Content-Type');
+  });
+
+  test('cors middleware should allow fine grained configuration', async () => {
+    const cors = createCorsMiddleware({
+      origin: ['http://foo.com', 'http://bar.com'],
+      methods: ['GET'],
+      allowedHeaders: ['X-Test'],
+      exposedHeaders: ['X-Expose'],
+      credentials: false,
+      maxAge: 10,
+    });
+
+    const ctx = createContext('http://localhost:3000/api/cors', 'GET');
+    ctx.headers.set('Origin', 'http://bar.com');
+    const response = await runMiddlewares([cors], ctx, async () => ctx.createResponse({}));
+
+    expect(response).toBeDefined();
+    expect(ctx.responseHeaders.get('Access-Control-Allow-Origin')).toBe('http://bar.com');
+    expect(ctx.responseHeaders.get('Access-Control-Allow-Credentials')).toBeNull();
+    expect(ctx.responseHeaders.get('Access-Control-Allow-Methods')).toBe('GET');
+    expect(ctx.responseHeaders.get('Access-Control-Expose-Headers')).toBe('X-Expose');
+    expect(ctx.responseHeaders.get('Access-Control-Max-Age')).toBe('10');
+  });
+});
+
+

package/tests/middleware/file-upload.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from 'bun:test';
+
+import { Context } from '../../src/core/context';
+import { createFileUploadMiddleware } from '../../src/middleware/builtin/file-upload';
+
+function createMultipartRequest(boundary: string, body: string): Request {
+  return new Request('http://localhost/upload', {
+    method: 'POST',
+    headers: {
+      'Content-Type': `multipart/form-data; boundary=${boundary}`,
+    },
+    body,
+  });
+}
+
+describe('FileUploadMiddleware', () => {
+  test('should parse multipart form data and attach files', async () => {
+    const boundary = '----WebKitFormBoundary7MA4YWxkTrZu0gW';
+    const body =
+      `--${boundary}\r\n` +
+      `Content-Disposition: form-data; name="text"\r\n\r\n` +
+      `hello\r\n` +
+      `--${boundary}\r\n` +
+      `Content-Disposition: form-data; name="file"; filename="test.txt"\r\n` +
+      `Content-Type: text/plain\r\n\r\n` +
+      `file content\r\n` +
+      `--${boundary}--`;
+
+    const ctx = new Context(createMultipartRequest(boundary, body));
+    const middleware = createFileUploadMiddleware();
+
+    const response = await middleware(ctx, async () => ctx.createResponse({ ok: true }));
+    expect(response.status).toBe(200);
+
+    const bodyData = ctx.body as { fields: Record<string, unknown>; files: Record<string, unknown> };
+    expect(bodyData.fields.text).toBe('hello');
+    expect(bodyData.files.file[0].name).toBe('test.txt');
+  });
+});
+
+