bxo 0.0.5-dev.65 → 0.0.5-dev.66

package/tests/unit/response-handler.test.ts

@@ -1,327 +0,0 @@
-import { describe, it, expect, beforeEach } from 'bun:test';
-import { processResponse, createErrorResponse, createValidationErrorResponse } from '../../src/utils/response-handler';
-import type { Context, InternalCookie } from '../../src/types';
-
-describe('Response Handler', () => {
-  let mockContext: Context;
-  let mockInternalCookies: InternalCookie[];
-
-  beforeEach(() => {
-    mockContext = {
-      params: {},
-      query: {},
-      body: {},
-      headers: {},
-      cookies: {},
-      path: '/',
-      request: new Request('http://localhost:3000/'),
-      set: {
-        status: 200,
-        headers: {},
-        cookies: () => { }
-      },
-      status: () => { },
-      redirect: () => new Response(),
-      clearRedirect: () => { }
-    } as any;
-
-    mockInternalCookies = [
-      {
-        name: 'session',
-        value: 'abc123',
-        domain: 'example.com',
-        path: '/',
-        secure: true,
-        httpOnly: true
-      }
-    ];
-  });
-
-  describe('processResponse', () => {
-    it('should handle implicit redirect intent', () => {
-      mockContext.set.redirect = { location: '/new-location', status: 301 };
-
-      const result = processResponse(undefined, mockContext, mockInternalCookies, true);
-
-      expect(result.status).toBe(301);
-      expect(result.headers.get('location')).toBe('/new-location');
-    });
-
-    it('should handle implicit redirect with status from set', () => {
-      mockContext.set.status = 307;
-
-      const result = processResponse(undefined, mockContext, mockInternalCookies, true);
-
-      expect(result.status).toBe(307);
-    });
-
-    it('should handle redirect with cookies', () => {
-      mockContext.set.redirect = { location: '/new-location', status: 302 };
-
-      const result = processResponse(undefined, mockContext, mockInternalCookies, true);
-
-      expect(result.status).toBe(302);
-      expect(result.headers.get('location')).toBe('/new-location');
-      expect(result.headers.get('set-cookie')).toContain('session=abc123');
-    });
-
-    it('should validate response with schema when enabled', () => {
-      const routeConfig = {
-        response: {
-          200: { parse: (data: any) => data }
-        }
-      };
-
-      const result = processResponse({ message: 'success' }, mockContext, mockInternalCookies, true, routeConfig);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('application/json');
-    });
-
-    it('should handle validation errors', () => {
-      const routeConfig = {
-        response: {
-          200: { parse: () => { throw new Error('Validation failed'); } }
-        }
-      };
-
-      const result = processResponse({ message: 'success' }, mockContext, mockInternalCookies, true, routeConfig);
-
-      expect(result.status).toBe(500);
-      expect(result.headers.get('content-type')).toBe('application/json');
-    });
-
-    it('should handle Response objects', () => {
-      const response = new Response('Hello World', { status: 200 });
-      mockContext.set.headers = { 'x-custom': 'value' };
-
-      const result = processResponse(response, mockContext, mockInternalCookies, true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('x-custom')).toBe('value');
-      expect(result.headers.get('set-cookie')).toContain('session=abc123');
-    });
-
-    it('should handle File objects', () => {
-      const file = new File(['test content'], 'test.txt', { type: 'text/plain' });
-
-      const result = processResponse(file, mockContext, mockInternalCookies, true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('text/plain;charset=utf-8');
-      expect(result.headers.get('content-length')).toBe('12');
-    });
-
-    it('should handle Bun.file objects', () => {
-      const bunFile = Bun.file('test.txt');
-
-      const result = processResponse(bunFile, mockContext, mockInternalCookies, true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('text/plain;charset=utf-8');
-    });
-
-    it('should handle string responses', async () => {
-      const result = processResponse('Hello World', mockContext, mockInternalCookies, true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('text/plain');
-      expect(await result.text()).toBe('Hello World');
-    });
-
-    it('should preserve custom Content-Type for string responses', async () => {
-      mockContext.set.headers = { 'Content-Type': 'text/html' };
-      const result = processResponse('<html><body>Hello World</body></html>', mockContext, mockInternalCookies, true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('text/html');
-      expect(await result.text()).toBe('<html><body>Hello World</body></html>');
-    });
-
-    it('should preserve custom Content-Type for string responses without cookies', async () => {
-      mockContext.set.headers = { 'Content-Type': 'text/html' };
-      const result = processResponse('<html><body>Hello World</body></html>', mockContext, [], true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('text/html');
-      expect(await result.text()).toBe('<html><body>Hello World</body></html>');
-    });
-
-    it('should default to text/plain when no Content-Type is set for string responses', async () => {
-      const result = processResponse('Hello World', mockContext, [], true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('text/plain');
-      expect(await result.text()).toBe('Hello World');
-    });
-
-    it('should handle object responses', async () => {
-      const result = processResponse({ message: 'success' }, mockContext, mockInternalCookies, true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('application/json');
-      expect(await result.json()).toEqual({ message: 'success' });
-    });
-
-    it('should handle responses with cookies', async () => {
-      const result = processResponse({ message: 'success' }, mockContext, mockInternalCookies, true);
-
-      const setCookieHeader = result.headers.get('set-cookie');
-      expect(setCookieHeader).toMatch(/session=abc123/);
-    });
-
-    it('should handle responses without cookies', () => {
-      const result = processResponse({ message: 'success' }, mockContext, [], true);
-
-      expect(result.headers.get('set-cookie')).toBeNull();
-    });
-
-    it('should use status from context', () => {
-      mockContext.set.status = 201;
-
-      const result = processResponse({ message: 'created' }, mockContext, [], true);
-
-      expect(result.status).toBe(201);
-    });
-
-    it('should handle custom headers from context', () => {
-      mockContext.set.headers = {
-        'x-custom': 'value',
-        'authorization': 'Bearer token'
-      };
-
-      const result = processResponse({ message: 'success' }, mockContext, [], true);
-
-      expect(result.headers.get('x-custom')).toBe('value');
-      expect(result.headers.get('authorization')).toBe('Bearer token');
-    });
-  });
-
-  describe('createErrorResponse', () => {
-    it('should create error response with Error object', async () => {
-      const error = new Error('Something went wrong');
-      const result = createErrorResponse(error, 500);
-
-      expect(result.status).toBe(500);
-      expect(result.headers.get('content-type')).toBe('application/json');
-
-      const body = await result.json() as { error: string };
-      expect(body.error).toBe('Something went wrong');
-    });
-
-    it('should create error response with string', async () => {
-      const result = createErrorResponse('Custom error message', 400);
-
-      expect(result.status).toBe(400);
-
-      const body = await result.json() as { error: string };
-      expect(body.error).toBe('Custom error message');
-    });
-
-    it('should create error response with details', async () => {
-      const error = new Error('Validation failed');
-      const details = { field: 'email', message: 'Invalid format' };
-      const result = createErrorResponse(error, 422, details);
-
-      expect(result.status).toBe(422);
-
-      const body = await result.json() as { error: string, details: any };
-      expect(body.error).toBe('Validation failed');
-      expect(body.details).toEqual(details);
-    });
-
-    it('should use default status when not provided', () => {
-      const result = createErrorResponse('Error');
-
-      expect(result.status).toBe(500);
-    });
-  });
-
-  describe('createValidationErrorResponse', () => {
-    it('should create validation error response with Zod errors', async () => {
-      const validationError = {
-        message: 'Validation failed',
-        errors: [
-          { field: 'email', message: 'Invalid email' },
-          { field: 'name', message: 'Name is required' }
-        ]
-      };
-
-      const result = createValidationErrorResponse(validationError, 400);
-
-      expect(result.status).toBe(400);
-
-      const body = await result.json() as { error: string, details: any };
-      expect(body.error).toBe('Validation failed for 2 field(s)');
-      expect(body.details).toEqual(validationError.errors);
-    });
-
-    it('should create validation error response with Zod issues', async () => {
-      const validationError = {
-        message: 'Validation failed',
-        issues: [
-          { path: ['email'], message: 'Invalid email' },
-          { path: ['name'], message: 'Name is required' }
-        ]
-      };
-
-      const result = createValidationErrorResponse(validationError, 400);
-
-      expect(result.status).toBe(400);
-
-      const body = await result.json() as { error: string, details: any };
-      expect(body.error).toBe('Validation failed for 2 field(s)');
-      expect(body.details).toEqual(validationError.issues);
-    });
-
-    it('should handle validation error without details', async () => {
-      const validationError = new Error('Validation failed');
-
-      const result = createValidationErrorResponse(validationError, 400);
-
-      expect(result.status).toBe(400);
-
-      const body = await result.json() as { error: string, details: any };
-      expect(body.error).toBe('Validation failed');
-      expect(body.details).toBeUndefined();
-    });
-
-    it('should use default status when not provided', () => {
-      const validationError = new Error('Validation failed');
-      const result = createValidationErrorResponse(validationError);
-
-      expect(result.status).toBe(400);
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle null response', () => {
-      const result = processResponse(null, mockContext, [], true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('application/json');
-    });
-
-    it('should handle undefined response', () => {
-      const result = processResponse(undefined, mockContext, [], true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('application/json');
-    });
-
-    it('should handle empty object response', async () => {
-      const result = processResponse({}, mockContext, [], true);
-
-      expect(result.status).toBe(200);
-      expect(result.headers.get('content-type')).toBe('application/json');
-      expect(await result.json()).toEqual({});
-    });
-
-    it('should handle response with null values', async () => {
-      const result = processResponse({ data: null, message: 'success' }, mockContext, [], true);
-
-      expect(result.status).toBe(200);
-      expect(await result.json()).toEqual({ data: null, message: 'success' });
-    });
-  });
-});

package/tests/unit/route-matcher.test.ts

@@ -1,181 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import { matchRoute, matchWSRoute } from '../../src/utils/route-matcher';
-import type { Route, WSRoute } from '../../src/types';
-
-describe('Route Matcher', () => {
-  describe('HTTP Route Matching', () => {
-    const routes: Route[] = [
-      { method: 'GET', path: '/', handler: () => 'home' },
-      { method: 'GET', path: '/users', handler: () => 'users' },
-      { method: 'GET', path: '/users/:id', handler: () => 'user' },
-      { method: 'POST', path: '/users', handler: () => 'create' },
-      { method: 'GET', path: '/users/:id/posts', handler: () => 'posts' },
-      { method: 'GET', path: '/users/:id/posts/:postId', handler: () => 'post' },
-      { method: 'GET', path: '/files/*', handler: () => 'files' },
-      { method: 'GET', path: '/docs/**', handler: () => 'docs' },
-      { method: 'GET', path: '/api/v1/users', handler: () => 'api' }
-    ];
-
-    it('should match exact routes', () => {
-      const result = matchRoute('GET', '/', routes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/');
-      expect(result?.params).toEqual({});
-    });
-
-    it('should match routes with parameters', () => {
-      const result = matchRoute('GET', '/users/123', routes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/users/:id');
-      expect(result?.params).toEqual({ id: '123' });
-    });
-
-    it('should match nested routes with parameters', () => {
-      const result = matchRoute('GET', '/users/123/posts/456', routes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/users/:id/posts/:postId');
-      expect(result?.params).toEqual({ id: '123', postId: '456' });
-    });
-
-    it('should match wildcard routes', () => {
-      const result = matchRoute('GET', '/files/image.jpg', routes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/files/*');
-      expect(result?.params).toEqual({ '*0': 'image.jpg' });
-    });
-
-    it('should match double wildcard routes', () => {
-      const result = matchRoute('GET', '/docs/api/reference', routes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/docs/**');
-      expect(result?.params).toEqual({ '**0': 'api/reference' });
-    });
-
-    it('should not match wrong method', () => {
-      const result = matchRoute('PUT', '/users', routes);
-      expect(result).toBeNull();
-    });
-
-    it('should not match non-existent route', () => {
-      const result = matchRoute('GET', '/nonexistent', routes);
-      expect(result).toBeNull();
-    });
-
-    it('should handle complex wildcard scenarios', () => {
-      const complexRoutes: Route[] = [
-        { method: 'GET', path: '/api/**/users/:id', handler: () => 'complex' },
-        { method: 'GET', path: '/api/**/posts/*', handler: () => 'posts' }
-      ];
-
-      const result1 = matchRoute('GET', '/api/v1/admin/users/123', complexRoutes);
-      expect(result1).toBeDefined();
-      expect(result1?.route.path).toBe('/api/**/users/:id');
-      // The double wildcard captures everything up to the next segment
-      expect(result1?.params).toEqual({ '**0': 'v1/admin', id: '123' });
-
-      const result2 = matchRoute('GET', '/api/v1/admin/posts/456', complexRoutes);
-      expect(result2).toBeDefined();
-      expect(result2?.route.path).toBe('/api/**/posts/*');
-      expect(result2?.params).toEqual({ '**0': 'v1/admin', '*1': '456' });
-    });
-
-    it('should handle multiple double wildcards', () => {
-      const multiWildcardRoutes: Route[] = [
-        { method: 'GET', path: '/api/**/users/**/posts/:id', handler: () => 'multi' }
-      ];
-
-      const result = matchRoute('GET', '/api/v1/admin/users/123/active/posts/456', multiWildcardRoutes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/api/**/users/**/posts/:id');
-      // Multiple double wildcards get unique keys
-      expect(result?.params).toEqual({ '**0': 'v1/admin', '**1': '123/active', id: '456' });
-    });
-
-    it('should handle mixed wildcard patterns', () => {
-      const mixedRoutes: Route[] = [
-        { method: 'GET', path: '/api/*/users/**/posts/*', handler: () => 'mixed' }
-      ];
-
-      const result = matchRoute('GET', '/api/v1/users/123/active/posts/456', mixedRoutes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/api/*/users/**/posts/*');
-      // Mixed wildcards get unique keys
-      expect(result?.params).toEqual({ '*0': 'v1', '**1': '123/active', '*2': '456' });
-    });
-  });
-
-  describe('WebSocket Route Matching', () => {
-    const wsRoutes: WSRoute[] = [
-      { path: '/ws', handler: {} },
-      { path: '/ws/chat', handler: {} },
-      { path: '/ws/chat/:roomId', handler: {} },
-      { path: '/ws/files/*', handler: {} },
-      { path: '/ws/docs/**', handler: {} }
-    ];
-
-    it('should match exact WebSocket routes', () => {
-      const result = matchWSRoute('/ws', wsRoutes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/ws');
-      expect(result?.params).toEqual({});
-    });
-
-    it('should match WebSocket routes with parameters', () => {
-      const result = matchWSRoute('/ws/chat/room123', wsRoutes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/ws/chat/:roomId');
-      expect(result?.params).toEqual({ roomId: 'room123' });
-    });
-
-    it('should match WebSocket wildcard routes', () => {
-      const result = matchWSRoute('/ws/files/document.pdf', wsRoutes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/ws/files/*');
-      expect(result?.params).toEqual({ '*0': 'document.pdf' });
-    });
-
-    it('should match WebSocket double wildcard routes', () => {
-      const result = matchWSRoute('/ws/docs/api/v1', wsRoutes);
-      expect(result).toBeDefined();
-      expect(result?.route.path).toBe('/ws/docs/**');
-      expect(result?.params).toEqual({ '**0': 'api/v1' });
-    });
-
-    it('should not match non-existent WebSocket route', () => {
-      const result = matchWSRoute('/ws/nonexistent', wsRoutes);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle empty routes array', () => {
-      const result = matchRoute('GET', '/', []);
-      expect(result).toBeNull();
-    });
-
-    it('should handle routes with empty path', () => {
-      const routes: Route[] = [
-        { method: 'GET', path: '', handler: () => 'empty' }
-      ];
-      const result = matchRoute('GET', '', routes);
-      expect(result).toBeDefined();
-    });
-
-    it('should handle routes with trailing slashes', () => {
-      const routes: Route[] = [
-        { method: 'GET', path: '/users/', handler: () => 'users' }
-      ];
-      const result = matchRoute('GET', '/users/', routes);
-      expect(result).toBeDefined();
-    });
-
-    it('should handle multiple wildcards in same route', () => {
-      const routes: Route[] = [
-        { method: 'GET', path: '/api/*/users/*', handler: () => 'multi' }
-      ];
-      const result = matchRoute('GET', '/api/v1/users/123', routes);
-      expect(result).toBeDefined();
-      expect(result?.params).toEqual({ '*0': 'v1', '*1': '123' }); // Each wildcard gets a unique key
-    });
-  });
-});