@dangao/bun-server 1.0.1 → 1.1.2

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');
+  });
+});
+
+

package/tests/middleware/middleware.test.ts

@@ -0,0 +1,120 @@
+import 'reflect-metadata';
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
+
+import { Application } from '../../src/core/application';
+import { Controller, ControllerRegistry } from '../../src/controller/controller';
+import { GET, POST } from '../../src/router/decorators';
+import { UseMiddleware } from '../../src/middleware';
+import type { Middleware } from '../../src/middleware';
+import { RouteRegistry } from '../../src/router/registry';
+import { Body } from '../../src/controller/decorators';
+import { getTestPort } from '../utils/test-port';
+
+describe('Middleware Integration', () => {
+  let app: Application;
+  let port: number;
+
+  beforeEach(() => {
+    port = getTestPort();
+    app = new Application({ port });
+  });
+
+  afterEach(async () => {
+    await app.stop();
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should apply global middleware', async () => {
+    const headerMiddleware: Middleware = async (ctx, next) => {
+      ctx.setHeader('x-global-middleware', 'enabled');
+      return await next();
+    };
+
+    app.use(headerMiddleware);
+
+    @Controller('/api/middleware/global')
+    class GlobalController {
+      @GET('/')
+      public getData() {
+        return { ok: true };
+      }
+    }
+
+    app.registerController(GlobalController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/middleware/global`);
+    expect(response.headers.get('x-global-middleware')).toBe('enabled');
+    const data = await response.json();
+    expect(data).toEqual({ ok: true });
+  });
+
+  test('should apply class and method level middleware', async () => {
+    const calls: string[] = [];
+
+    const classMiddleware: Middleware = async (ctx, next) => {
+      calls.push('class');
+      return await next();
+    };
+
+    const methodMiddleware: Middleware = async (ctx, next) => {
+      calls.push('method');
+      return await next();
+    };
+
+    @UseMiddleware(classMiddleware)
+    @Controller('/api/middleware/controller')
+    class ControllerWithMiddleware {
+      @UseMiddleware(methodMiddleware)
+      @GET('/')
+      public getData() {
+        calls.push('handler');
+        return { value: 'ok' };
+      }
+    }
+
+    app.registerController(ControllerWithMiddleware);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/middleware/controller`);
+    const data = await response.json();
+
+    expect(data).toEqual({ value: 'ok' });
+    expect(calls).toEqual(['class', 'method', 'handler']);
+  });
+
+  test('should allow middleware to short-circuit request', async () => {
+    const guard: Middleware = async () => {
+      return new Response(JSON.stringify({ blocked: true }), {
+        status: 403,
+        headers: { 'Content-Type': 'application/json' },
+      });
+    };
+
+    app.use(guard);
+
+    @Controller('/api/middleware/blocked')
+    class BlockedController {
+      @POST('/')
+      public createUser(@Body() user: { name: string }) {
+        return { id: '1', ...user };
+      }
+    }
+
+    app.registerController(BlockedController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/middleware/blocked`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'John' }),
+    });
+
+    expect(response.status).toBe(403);
+    const data = await response.json();
+    expect(data).toEqual({ blocked: true });
+  });
+});
+
+

package/tests/middleware/pipeline.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'bun:test';
+
+import { MiddlewarePipeline } from '../../src/middleware/pipeline';
+import type { Middleware } from '../../src/middleware';
+import { Context } from '../../src/core/context';
+
+function createContext(): Context {
+  const request = new Request('http://localhost:3000/api/test');
+  return new Context(request);
+}
+
+describe('MiddlewarePipeline', () => {
+  test('should execute middlewares in order and call final handler', async () => {
+    const pipeline = new MiddlewarePipeline();
+    const calls: string[] = [];
+
+    const first: Middleware = async (ctx, next) => {
+      calls.push('first:before');
+      const response = await next();
+      calls.push('first:after');
+      return response;
+    };
+
+    const second: Middleware = async (ctx, next) => {
+      calls.push('second:before');
+      const response = await next();
+      calls.push('second:after');
+      return response;
+    };
+
+    pipeline.use(first);
+    pipeline.use(second);
+
+    const context = createContext();
+    const response = await pipeline.run(context, async () => {
+      calls.push('handler');
+      return context.createResponse({ ok: true });
+    });
+
+    const data = await response.json();
+    expect(data).toEqual({ ok: true });
+    expect(calls).toEqual([
+      'first:before',
+      'second:before',
+      'handler',
+      'second:after',
+      'first:after',
+    ]);
+  });
+
+  test('should allow middleware to short circuit the pipeline', async () => {
+    const pipeline = new MiddlewarePipeline();
+
+    const blocker: Middleware = async (ctx) => {
+      ctx.setStatus(401);
+      return ctx.createResponse({ error: 'Unauthorized' });
+    };
+
+    pipeline.use(blocker);
+
+    const context = createContext();
+    const response = await pipeline.run(context, async () => {
+      return context.createResponse({ ok: true });
+    });
+
+    expect(response.status).toBe(401);
+    const data = await response.json();
+    expect(data).toEqual({ error: 'Unauthorized' });
+  });
+});
+
+