meno-core 1.0.0

package/lib/server/middleware/errorHandler.test.ts

@@ -0,0 +1,208 @@
+import { describe, test, expect } from 'bun:test';
+import { createErrorResponse, handleRouteError, withErrorHandling } from './errorHandler';
+
+describe('errorHandler middleware', () => {
+  describe('createErrorResponse', () => {
+    test('creates error response with Error object', () => {
+      const error = new Error('Test error');
+      const response = createErrorResponse(error);
+      expect(response.status).toBe(500);
+    });
+
+    test('creates error response with string error', async () => {
+      const error = 'Test error message';
+      const response = createErrorResponse(error);
+      const data = await response.json();
+      expect(data.error).toBe('Test error message');
+      expect(data.status).toBe(500);
+    });
+
+    test('uses custom status code', () => {
+      const error = new Error('Not found');
+      const response = createErrorResponse(error, 404);
+      expect(response.status).toBe(404);
+    });
+
+    test('includes custom message', async () => {
+      const error = new Error('Internal error');
+      const response = createErrorResponse(error, 500, 'Custom message');
+      const data = await response.json();
+      expect(data.message).toBe('Custom message');
+    });
+
+    test('sets correct content type', () => {
+      const error = new Error('Test');
+      const response = createErrorResponse(error);
+      expect(response.headers.get('Content-Type')).toBe('application/json');
+    });
+
+    test('response body includes error and status', async () => {
+      const error = new Error('Test error');
+      const response = createErrorResponse(error, 400);
+      const data = await response.json();
+      expect(data.error).toBe('Test error');
+      expect(data.status).toBe(400);
+    });
+
+    test('handles non-Error objects', async () => {
+      const error = { code: 'ERR_001' };
+      const response = createErrorResponse(error);
+      const data = await response.json();
+      expect(data.error).toBe('[object Object]');
+    });
+
+    test('handles null error', async () => {
+      const response = createErrorResponse(null);
+      const data = await response.json();
+      expect(data.error).toBe('null');
+    });
+
+    test('handles undefined error', async () => {
+      const response = createErrorResponse(undefined);
+      const data = await response.json();
+      expect(data.error).toBe('undefined');
+    });
+
+    test('handles number error', async () => {
+      const response = createErrorResponse(404);
+      const data = await response.json();
+      expect(data.error).toBe('404');
+    });
+  });
+
+  describe('handleRouteError', () => {
+    test('returns successful response when no error', async () => {
+      const successResponse = new Response('OK', { status: 200 });
+      const handler = async () => successResponse;
+      const response = await handleRouteError(handler);
+      expect(response).toBe(successResponse);
+      expect(response.status).toBe(200);
+    });
+
+    test('catches and returns error response on failure', async () => {
+      const handler = async () => {
+        throw new Error('Handler failed');
+      };
+      const response = await handleRouteError(handler);
+      expect(response.status).toBe(500);
+      const data = await response.json();
+      expect(data.error).toBe('Handler failed');
+    });
+
+    test('uses default error message', async () => {
+      const handler = async () => {
+        throw new Error('Test');
+      };
+      const response = await handleRouteError(handler);
+      const data = await response.json();
+      expect(data.message).toBe('Internal server error');
+    });
+
+    test('uses custom error message', async () => {
+      const handler = async () => {
+        throw new Error('Test');
+      };
+      const response = await handleRouteError(handler, 'Custom error');
+      const data = await response.json();
+      expect(data.message).toBe('Custom error');
+    });
+
+    test('handles async handler with delay', async () => {
+      const handler = async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return new Response('OK');
+      };
+      const response = await handleRouteError(handler);
+      expect(response.status).toBe(200);
+    });
+
+    test('handles non-Error thrown values', async () => {
+      const handler = async () => {
+        throw 'String error';
+      };
+      const response = await handleRouteError(handler);
+      expect(response.status).toBe(500);
+      const data = await response.json();
+      expect(data.error).toBe('String error');
+    });
+  });
+
+  describe('withErrorHandling', () => {
+    test('returns wrapped handler that handles errors', async () => {
+      const handler = async () => {
+        throw new Error('Test error');
+      };
+      const wrapped = withErrorHandling(handler);
+      const response = await wrapped();
+      expect(response.status).toBe(500);
+    });
+
+    test('wrapped handler passes through successful responses', async () => {
+      const handler = async () => new Response('Success', { status: 200 });
+      const wrapped = withErrorHandling(handler);
+      const response = await wrapped();
+      expect(response.status).toBe(200);
+      expect(await response.text()).toBe('Success');
+    });
+
+    test('wrapped handler uses custom error message', async () => {
+      const handler = async () => {
+        throw new Error('Test');
+      };
+      const wrapped = withErrorHandling(handler, 'Custom error message');
+      const response = await wrapped();
+      const data = await response.json();
+      expect(data.message).toBe('Custom error message');
+    });
+
+    test('wrapped handler passes arguments correctly', async () => {
+      const handler = async (req: Request, id: string) => {
+        return new Response(`Hello ${id}`);
+      };
+      const wrapped = withErrorHandling(handler);
+      const req = new Request('http://localhost/test');
+      const response = await wrapped(req, 'world');
+      expect(await response.text()).toBe('Hello world');
+    });
+
+    test('wrapped handler catches errors with arguments', async () => {
+      const handler = async (req: Request, shouldFail: boolean) => {
+        if (shouldFail) throw new Error('Failed');
+        return new Response('OK');
+      };
+      const wrapped = withErrorHandling(handler);
+      const req = new Request('http://localhost/test');
+
+      const successResponse = await wrapped(req, false);
+      expect(successResponse.status).toBe(200);
+
+      const errorResponse = await wrapped(req, true);
+      expect(errorResponse.status).toBe(500);
+    });
+
+    test('wrapped handler preserves response headers', async () => {
+      const handler = async () => {
+        return new Response('OK', {
+          headers: { 'X-Custom': 'value' }
+        });
+      };
+      const wrapped = withErrorHandling(handler);
+      const response = await wrapped();
+      expect(response.headers.get('X-Custom')).toBe('value');
+    });
+
+    test('multiple wrapped handlers work independently', async () => {
+      const handler1 = async () => new Response('One');
+      const handler2 = async () => { throw new Error('Two'); };
+
+      const wrapped1 = withErrorHandling(handler1);
+      const wrapped2 = withErrorHandling(handler2);
+
+      const response1 = await wrapped1();
+      const response2 = await wrapped2();
+
+      expect(response1.status).toBe(200);
+      expect(response2.status).toBe(500);
+    });
+  });
+});

package/lib/server/middleware/errorHandler.ts

@@ -0,0 +1,63 @@
+/**
+ * Error Handler Middleware
+ * Centralized error handling for routes
+ */
+
+export interface ErrorResponse {
+  error: string;
+  message?: string;
+  status: number;
+}
+
+/**
+ * Create an error response
+ */
+export function createErrorResponse(
+  error: unknown,
+  status: number = 500,
+  message?: string
+): Response {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  const response: ErrorResponse = {
+    error: errorMessage,
+    status,
+  };
+
+  if (message) {
+    response.message = message;
+  }
+
+  return new Response(JSON.stringify(response), {
+    status,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+}
+
+/**
+ * Handle errors in async route handlers
+ */
+export async function handleRouteError(
+  handler: () => Promise<Response>,
+  errorMessage: string = 'Internal server error'
+): Promise<Response> {
+  try {
+    return await handler();
+  } catch (error) {
+    return createErrorResponse(error, 500, errorMessage);
+  }
+}
+
+/**
+ * Wrap a route handler with error handling
+ */
+export function withErrorHandling<T extends unknown[]>(
+  handler: (...args: T) => Promise<Response>,
+  errorMessage?: string
+): (...args: T) => Promise<Response> {
+  return async (...args: T) => {
+    return handleRouteError(() => handler(...args), errorMessage);
+  };
+}
+

package/lib/server/middleware/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Server Middleware
+ * Centralized middleware exports
+ */
+
+export * from './cors';
+export * from './errorHandler';
+export * from './logger';
+

package/lib/server/middleware/logger.test.ts

@@ -0,0 +1,233 @@
+import { describe, test, expect, beforeEach, mock } from 'bun:test';
+import { logRequest, logError, logResponseTime, withLogging, type LogOptions } from './logger';
+
+describe('logger middleware', () => {
+  // Note: These functions don't console.log in the implementation,
+  // so we're testing they execute without errors and honor the options
+
+  describe('logRequest', () => {
+    test('executes without error when enabled', () => {
+      const req = new Request('http://localhost:3000/api/test', {
+        method: 'GET'
+      });
+      expect(() => logRequest(req)).not.toThrow();
+    });
+
+    test('executes without error when disabled', () => {
+      const req = new Request('http://localhost:3000/api/test');
+      const options: LogOptions = { logRequests: false };
+      expect(() => logRequest(req, options)).not.toThrow();
+    });
+
+    test('handles different HTTP methods', () => {
+      const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'];
+      for (const method of methods) {
+        const req = new Request('http://localhost:3000/api/test', { method });
+        expect(() => logRequest(req)).not.toThrow();
+      }
+    });
+
+    test('handles requests with query parameters', () => {
+      const req = new Request('http://localhost:3000/api/test?foo=bar&baz=qux');
+      expect(() => logRequest(req)).not.toThrow();
+    });
+
+    test('handles requests with different paths', () => {
+      const paths = ['/api/test', '/api/users/123', '/health', '/'];
+      for (const path of paths) {
+        const req = new Request(`http://localhost:3000${path}`);
+        expect(() => logRequest(req)).not.toThrow();
+      }
+    });
+
+    test('respects default options', () => {
+      const req = new Request('http://localhost:3000/api/test');
+      expect(() => logRequest(req, {})).not.toThrow();
+    });
+  });
+
+  describe('logError', () => {
+    test('executes without error for Error objects', () => {
+      const error = new Error('Test error');
+      expect(() => logError(error)).not.toThrow();
+    });
+
+    test('executes without error for string errors', () => {
+      expect(() => logError('String error')).not.toThrow();
+    });
+
+    test('executes without error when disabled', () => {
+      const error = new Error('Test');
+      const options: LogOptions = { logErrors: false };
+      expect(() => logError(error, undefined, options)).not.toThrow();
+    });
+
+    test('handles error with context', () => {
+      const error = new Error('Test error');
+      expect(() => logError(error, 'API Handler')).not.toThrow();
+    });
+
+    test('handles error without context', () => {
+      const error = new Error('Test error');
+      expect(() => logError(error)).not.toThrow();
+    });
+
+    test('handles Error with stack trace', () => {
+      const error = new Error('Test error');
+      error.stack = 'Error: Test error\n    at test.ts:10:5';
+      expect(() => logError(error)).not.toThrow();
+    });
+
+    test('handles non-Error objects', () => {
+      expect(() => logError({ message: 'Custom error' })).not.toThrow();
+      expect(() => logError(null)).not.toThrow();
+      expect(() => logError(undefined)).not.toThrow();
+      expect(() => logError(42)).not.toThrow();
+    });
+
+    test('respects default options', () => {
+      const error = new Error('Test');
+      expect(() => logError(error, undefined, {})).not.toThrow();
+    });
+  });
+
+  describe('logResponseTime', () => {
+    test('executes without error when enabled', () => {
+      const startTime = Date.now();
+      const req = new Request('http://localhost:3000/api/test');
+      expect(() => logResponseTime(startTime, req)).not.toThrow();
+    });
+
+    test('executes without error when disabled', () => {
+      const startTime = Date.now();
+      const req = new Request('http://localhost:3000/api/test');
+      const options: LogOptions = { logResponseTime: false };
+      expect(() => logResponseTime(startTime, req, options)).not.toThrow();
+    });
+
+    test('handles past start time', () => {
+      const startTime = Date.now() - 1000; // 1 second ago
+      const req = new Request('http://localhost:3000/api/test');
+      expect(() => logResponseTime(startTime, req)).not.toThrow();
+    });
+
+    test('handles current start time', () => {
+      const startTime = Date.now();
+      const req = new Request('http://localhost:3000/api/test');
+      expect(() => logResponseTime(startTime, req)).not.toThrow();
+    });
+
+    test('respects default options', () => {
+      const startTime = Date.now();
+      const req = new Request('http://localhost:3000/api/test');
+      expect(() => logResponseTime(startTime, req, {})).not.toThrow();
+    });
+  });
+
+  describe('withLogging', () => {
+    test('wrapped handler returns successful response', async () => {
+      const handler = async () => new Response('OK', { status: 200 });
+      const wrapped = withLogging(handler);
+      const req = new Request('http://localhost:3000/api/test');
+      const response = await wrapped(req);
+      expect(response.status).toBe(200);
+    });
+
+    test('wrapped handler logs and rethrows errors', async () => {
+      const handler = async () => {
+        throw new Error('Handler error');
+      };
+      const wrapped = withLogging(handler);
+      const req = new Request('http://localhost:3000/api/test');
+
+      await expect(wrapped(req)).rejects.toThrow('Handler error');
+    });
+
+    test('wrapped handler passes arguments correctly', async () => {
+      const handler = async (req: Request, id: string) => {
+        return new Response(`ID: ${id}`);
+      };
+      const wrapped = withLogging(handler);
+      const req = new Request('http://localhost:3000/api/test');
+      const response = await wrapped(req, '123');
+      expect(await response.text()).toBe('ID: 123');
+    });
+
+    test('wrapped handler with custom options', async () => {
+      const handler = async () => new Response('OK');
+      const options: LogOptions = {
+        logRequests: false,
+        logErrors: false,
+        logResponseTime: false
+      };
+      const wrapped = withLogging(handler, options);
+      const req = new Request('http://localhost:3000/api/test');
+      const response = await wrapped(req);
+      expect(response.status).toBe(200);
+    });
+
+    test('wrapped handler preserves response headers', async () => {
+      const handler = async () => {
+        return new Response('OK', {
+          headers: { 'X-Custom': 'value' }
+        });
+      };
+      const wrapped = withLogging(handler);
+      const req = new Request('http://localhost:3000/api/test');
+      const response = await wrapped(req);
+      expect(response.headers.get('X-Custom')).toBe('value');
+    });
+
+    test('wrapped handler with multiple arguments', async () => {
+      const handler = async (req: Request, a: number, b: number) => {
+        return new Response(`Sum: ${a + b}`);
+      };
+      const wrapped = withLogging(handler);
+      const req = new Request('http://localhost:3000/api/test');
+      const response = await wrapped(req, 5, 10);
+      expect(await response.text()).toBe('Sum: 15');
+    });
+
+    test('wrapped handler logs on success and error', async () => {
+      const successHandler = async () => new Response('OK');
+      const errorHandler = async () => { throw new Error('Failed'); };
+
+      const wrappedSuccess = withLogging(successHandler);
+      const wrappedError = withLogging(errorHandler);
+
+      const req = new Request('http://localhost:3000/api/test');
+
+      const successResponse = await wrappedSuccess(req);
+      expect(successResponse.status).toBe(200);
+
+      await expect(wrappedError(req)).rejects.toThrow('Failed');
+    });
+
+    test('wrapped handler handles async operations', async () => {
+      const handler = async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+        return new Response('Delayed OK');
+      };
+      const wrapped = withLogging(handler);
+      const req = new Request('http://localhost:3000/api/test');
+      const response = await wrapped(req);
+      expect(await response.text()).toBe('Delayed OK');
+    });
+
+    test('multiple wrapped handlers work independently', async () => {
+      const handler1 = async () => new Response('One');
+      const handler2 = async () => new Response('Two');
+
+      const wrapped1 = withLogging(handler1);
+      const wrapped2 = withLogging(handler2);
+
+      const req = new Request('http://localhost:3000/api/test');
+
+      const response1 = await wrapped1(req);
+      const response2 = await wrapped2(req);
+
+      expect(await response1.text()).toBe('One');
+      expect(await response2.text()).toBe('Two');
+    });
+  });
+});

package/lib/server/middleware/logger.ts

@@ -0,0 +1,99 @@
+/**
+ * Logger Middleware
+ * Request logging for development and debugging
+ */
+
+export interface LogOptions {
+  logRequests?: boolean;
+  logErrors?: boolean;
+  logResponseTime?: boolean;
+}
+
+const DEFAULT_OPTIONS: LogOptions = {
+  logRequests: true,
+  logErrors: true,
+  logResponseTime: true,
+};
+
+/**
+ * Log a request
+ */
+export function logRequest(
+  req: Request,
+  options: LogOptions = {}
+): void {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  
+  if (!opts.logRequests) {
+    return;
+  }
+
+  const url = new URL(req.url);
+  const timestamp = new Date().toISOString();
+}
+
+/**
+ * Log an error
+ */
+export function logError(
+  error: unknown,
+  context?: string,
+  options: LogOptions = {}
+): void {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  
+  if (!opts.logErrors) {
+    return;
+  }
+
+  const timestamp = new Date().toISOString();
+  const contextStr = context ? ` [${context}]` : '';
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  
+  if (error instanceof Error && error.stack) {
+  }
+}
+
+/**
+ * Log response time
+ */
+export function logResponseTime(
+  startTime: number,
+  req: Request,
+  options: LogOptions = {}
+): void {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  
+  if (!opts.logResponseTime) {
+    return;
+  }
+
+  const url = new URL(req.url);
+  const duration = Date.now() - startTime;
+}
+
+/**
+ * Wrap a route handler with logging
+ */
+export function withLogging<T extends unknown[]>(
+  handler: (...args: T) => Promise<Response>,
+  options: LogOptions = {}
+): (...args: T) => Promise<Response> {
+  return async (...args: T) => {
+    const startTime = Date.now();
+    const req = args[0] as Request;
+    
+    logRequest(req, options);
+    
+    try {
+      const response = await handler(...args);
+      logResponseTime(startTime, req, options);
+      return response;
+    } catch (error) {
+      logError(error, req.method, options);
+      logResponseTime(startTime, req, options);
+      throw error;
+    }
+  };
+}
+