@dangao/bun-server 1.0.1 → 1.1.2

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/interceptor/builtin/cache-interceptor.test.ts

@@ -0,0 +1,137 @@
+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 {
+  Cache,
+  CacheInterceptor,
+  CACHE_METADATA_KEY,
+  InterceptorRegistry,
+  INTERCEPTOR_REGISTRY_TOKEN,
+} from '../../../src/interceptor';
+import { getTestPort } from '../../utils/test-port';
+
+describe('CacheInterceptor', () => {
+  let app: Application;
+  let port: number;
+  let interceptorRegistry: InterceptorRegistry;
+  let callCount = 0;
+
+  beforeEach(() => {
+    port = getTestPort();
+    app = new Application({ port });
+    interceptorRegistry = app.getContainer().resolve<InterceptorRegistry>(
+      INTERCEPTOR_REGISTRY_TOKEN,
+    );
+    interceptorRegistry.register(CACHE_METADATA_KEY, new CacheInterceptor());
+    callCount = 0;
+    CacheInterceptor.clearCache();
+  });
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+    }
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+    interceptorRegistry.clear();
+    CacheInterceptor.clearCache();
+  });
+
+  test('should cache method result', async () => {
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      @Cache({ ttl: 1000 })
+      public getData() {
+        callCount++;
+        return { data: 'cached', count: callCount };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    // 第一次调用
+    const response1 = await fetch(`http://localhost:${port}/api/test`);
+    expect(response1.status).toBe(200);
+    const data1 = await response1.json();
+    expect(data1.count).toBe(1);
+    expect(callCount).toBe(1);
+
+    // 第二次调用（应该使用缓存）
+    const response2 = await fetch(`http://localhost:${port}/api/test`);
+    expect(response2.status).toBe(200);
+    const data2 = await response2.json();
+    expect(data2.count).toBe(1); // 缓存的结果
+    expect(callCount).toBe(1); // 方法没有被再次调用
+  });
+
+  test('should use custom cache key', async () => {
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      @Cache({ ttl: 1000, key: 'custom-key' })
+      public getData() {
+        callCount++;
+        return { data: 'cached' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    await fetch(`http://localhost:${port}/api/test`);
+    await fetch(`http://localhost:${port}/api/test`);
+
+    expect(callCount).toBe(1); // 应该只调用一次（使用缓存）
+  });
+
+  test('should expire cache after TTL', async () => {
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      @Cache({ ttl: 100 }) // 100ms TTL
+      public getData() {
+        callCount++;
+        return { data: 'cached', count: callCount };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    // 第一次调用
+    await fetch(`http://localhost:${port}/api/test`);
+    expect(callCount).toBe(1);
+
+    // 等待缓存过期
+    await new Promise((resolve) => setTimeout(resolve, 150));
+
+    // 第二次调用（缓存已过期）
+    await fetch(`http://localhost:${port}/api/test`);
+    expect(callCount).toBe(2);
+  });
+
+  test('should work without cache decorator', async () => {
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      public getData() {
+        callCount++;
+        return { data: 'no-cache' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    await fetch(`http://localhost:${port}/api/test`);
+    await fetch(`http://localhost:${port}/api/test`);
+
+    expect(callCount).toBe(2); // 没有缓存，应该调用两次
+  });
+});
+

package/tests/interceptor/builtin/permission-interceptor.test.ts

@@ -0,0 +1,182 @@
+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 {
+  Permission,
+  PermissionInterceptor,
+  PERMISSION_METADATA_KEY,
+  InterceptorRegistry,
+  INTERCEPTOR_REGISTRY_TOKEN,
+  type PermissionService,
+} from '../../../src/interceptor';
+import { ForbiddenException } from '../../../src/error';
+import { getTestPort } from '../../utils/test-port';
+
+describe('PermissionInterceptor', () => {
+  let app: Application;
+  let port: number;
+  let interceptorRegistry: InterceptorRegistry;
+
+  beforeEach(() => {
+    port = getTestPort();
+    app = new Application({ port });
+    interceptorRegistry = app.getContainer().resolve<InterceptorRegistry>(
+      INTERCEPTOR_REGISTRY_TOKEN,
+    );
+    interceptorRegistry.register(PERMISSION_METADATA_KEY, new PermissionInterceptor());
+  });
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+    }
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+    interceptorRegistry.clear();
+  });
+
+  test('should allow access when permission check passes', async () => {
+    // 创建权限服务实现
+    class MockPermissionService implements PermissionService {
+      public async check(
+        userId: string | null,
+        resource: string,
+        action: string,
+      ): Promise<boolean> {
+        return userId === 'user1' && resource === 'user' && action === 'read';
+      }
+    }
+
+    // 注册权限服务
+    app.getContainer().registerInstance(
+      PermissionInterceptor.PERMISSION_SERVICE_TOKEN,
+      new MockPermissionService(),
+    );
+
+    @Controller('/api/users')
+    class UserController {
+      @GET('/:id')
+      @Permission({ resource: 'user', action: 'read' })
+      public getUser() {
+        return { id: '123', name: 'Test User' };
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users/123`, {
+      headers: { 'X-User-Id': 'user1' },
+    });
+
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.id).toBe('123');
+  });
+
+  test('should deny access when permission check fails', async () => {
+    // 创建权限服务实现
+    class MockPermissionService implements PermissionService {
+      public async check(
+        userId: string | null,
+        resource: string,
+        action: string,
+      ): Promise<boolean> {
+        return false; // 总是拒绝
+      }
+    }
+
+    // 注册权限服务
+    app.getContainer().registerInstance(
+      PermissionInterceptor.PERMISSION_SERVICE_TOKEN,
+      new MockPermissionService(),
+    );
+
+    @Controller('/api/users')
+    class UserController {
+      @GET('/:id')
+      @Permission({ resource: 'user', action: 'read' })
+      public getUser() {
+        return { id: '123', name: 'Test User' };
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users/123`, {
+      headers: { 'X-User-Id': 'user1' },
+    });
+
+    expect(response.status).toBe(403);
+  });
+
+  test('should allow anonymous access when allowAnonymous is true', async () => {
+    @Controller('/api/public')
+    class PublicController {
+      @GET('/')
+      @Permission({
+        resource: 'public',
+        action: 'read',
+        allowAnonymous: true,
+      })
+      public getPublicData() {
+        return { data: 'public' };
+      }
+    }
+
+    app.registerController(PublicController);
+    await app.listen();
+
+    // 没有提供用户 ID
+    const response = await fetch(`http://localhost:${port}/api/public`);
+
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.data).toBe('public');
+  });
+
+  test('should work without permission decorator', async () => {
+    @Controller('/api/test')
+    class TestController {
+      @GET('/')
+      public getData() {
+        return { data: 'no-permission-check' };
+      }
+    }
+
+    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.data).toBe('no-permission-check');
+  });
+
+  test('should throw error when PermissionService not registered', async () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('/:id')
+      @Permission({ resource: 'user', action: 'read' })
+      public getUser() {
+        return { id: '123' };
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users/123`, {
+      headers: { 'X-User-Id': 'user1' },
+    });
+
+    // 应该返回 500 错误（PermissionService 未注册）
+    expect(response.status).toBe(500);
+  });
+});
+