serverless-event-orchestrator 2.0.1 → 2.3.0

package/src/utils/path-matcher.ts

@@ -1,84 +1,84 @@
-/**
- * Path matching utilities for extracting path parameters
- * Supports patterns like /users/{id} and /users/{userId}/posts/{postId}
- */
-
-/**
- * Converts a route pattern to a regex and extracts parameter names
- * @param pattern - Route pattern like /users/{id}
- * @returns Object with regex and parameter names
- */
-export function patternToRegex(pattern: string): { regex: RegExp; paramNames: string[] } {
-  const paramNames: string[] = [];
-
-  // First, handle :paramName format (Express style) BEFORE escaping
-  // This converts :id to {id} for uniform processing
-  let normalizedPattern = pattern.replace(/:(\w+)/g, '{$1}');
-
-  // Escape special regex characters except for our parameter syntax
-  let regexPattern = normalizedPattern
-    .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
-    .replace(/\\\{(\w+)\\\}/g, (_, paramName) => {
-      paramNames.push(paramName);
-      return '([^/]+)';
-    });
-
-  // Ensure exact match
-  regexPattern = `^${regexPattern}$`;
-
-  return {
-    regex: new RegExp(regexPattern),
-    paramNames,
-  };
-}
-
-/**
- * Matches a path against a pattern and extracts parameters
- * @param pattern - Route pattern like /users/{id}
- * @param path - Actual path like /users/123
- * @returns Extracted parameters or null if no match
- */
-export function matchPath(pattern: string, path: string): Record<string, string> | null {
-  const { regex, paramNames } = patternToRegex(pattern);
-  const match = path.match(regex);
-  
-  if (!match) {
-    return null;
-  }
-  
-  const params: Record<string, string> = {};
-  paramNames.forEach((name, index) => {
-    params[name] = match[index + 1];
-  });
-  
-  return params;
-}
-
-/**
- * Checks if a pattern contains path parameters
- * @param pattern - Route pattern to check
- * @returns True if pattern has parameters
- */
-export function hasPathParameters(pattern: string): boolean {
-  // Support both {id} and :id formats
-  return /\{[\w]+\}/.test(pattern) || /:[\w]+/.test(pattern);
-}
-
-/**
- * Normalizes a path by removing trailing slashes and ensuring leading slash
- * @param path - Path to normalize
- * @returns Normalized path
- */
-export function normalizePath(path: string): string {
-  if (!path) return '/';
-  
-  // Ensure leading slash
-  let normalized = path.startsWith('/') ? path : `/${path}`;
-  
-  // Remove trailing slash (except for root)
-  if (normalized.length > 1 && normalized.endsWith('/')) {
-    normalized = normalized.slice(0, -1);
-  }
-  
-  return normalized;
-}
+/**
+ * Path matching utilities for extracting path parameters
+ * Supports patterns like /users/{id} and /users/{userId}/posts/{postId}
+ */
+
+/**
+ * Converts a route pattern to a regex and extracts parameter names
+ * @param pattern - Route pattern like /users/{id}
+ * @returns Object with regex and parameter names
+ */
+export function patternToRegex(pattern: string): { regex: RegExp; paramNames: string[] } {
+  const paramNames: string[] = [];
+
+  // First, handle :paramName format (Express style) BEFORE escaping
+  // This converts :id to {id} for uniform processing
+  let normalizedPattern = pattern.replace(/:(\w+)/g, '{$1}');
+
+  // Escape special regex characters except for our parameter syntax
+  let regexPattern = normalizedPattern
+    .replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+    .replace(/\\\{(\w+)\\\}/g, (_, paramName) => {
+      paramNames.push(paramName);
+      return '([^/]+)';
+    });
+
+  // Ensure exact match
+  regexPattern = `^${regexPattern}$`;
+
+  return {
+    regex: new RegExp(regexPattern),
+    paramNames,
+  };
+}
+
+/**
+ * Matches a path against a pattern and extracts parameters
+ * @param pattern - Route pattern like /users/{id}
+ * @param path - Actual path like /users/123
+ * @returns Extracted parameters or null if no match
+ */
+export function matchPath(pattern: string, path: string): Record<string, string> | null {
+  const { regex, paramNames } = patternToRegex(pattern);
+  const match = path.match(regex);
+  
+  if (!match) {
+    return null;
+  }
+  
+  const params: Record<string, string> = {};
+  paramNames.forEach((name, index) => {
+    params[name] = match[index + 1];
+  });
+  
+  return params;
+}
+
+/**
+ * Checks if a pattern contains path parameters
+ * @param pattern - Route pattern to check
+ * @returns True if pattern has parameters
+ */
+export function hasPathParameters(pattern: string): boolean {
+  // Support both {id} and :id formats
+  return /\{[\w]+\}/.test(pattern) || /:[\w]+/.test(pattern);
+}
+
+/**
+ * Normalizes a path by removing trailing slashes and ensuring leading slash
+ * @param path - Path to normalize
+ * @returns Normalized path
+ */
+export function normalizePath(path: string): string {
+  if (!path) return '/';
+  
+  // Ensure leading slash
+  let normalized = path.startsWith('/') ? path : `/${path}`;
+  
+  // Remove trailing slash (except for root)
+  if (normalized.length > 1 && normalized.endsWith('/')) {
+    normalized = normalized.slice(0, -1);
+  }
+  
+  return normalized;
+}

package/tests/cors.test.ts

@@ -1,133 +1,133 @@
-import {
-  isPreflightRequest,
-  createPreflightResponse,
-  applyCorsHeaders,
-  withCors
-} from '../src/http/cors';
-import { HttpResponse } from '../src/http/response';
-
-describe('isPreflightRequest', () => {
-  it('should return true for OPTIONS request', () => {
-    const event = { httpMethod: 'OPTIONS' };
-    expect(isPreflightRequest(event)).toBe(true);
-  });
-
-  it('should return true for lowercase options', () => {
-    const event = { httpMethod: 'options' };
-    expect(isPreflightRequest(event)).toBe(true);
-  });
-
-  it('should return false for GET request', () => {
-    const event = { httpMethod: 'GET' };
-    expect(isPreflightRequest(event)).toBe(false);
-  });
-
-  it('should return false for POST request', () => {
-    const event = { httpMethod: 'POST' };
-    expect(isPreflightRequest(event)).toBe(false);
-  });
-
-  it('should return false for undefined httpMethod', () => {
-    const event = {};
-    expect(isPreflightRequest(event)).toBe(false);
-  });
-});
-
-describe('createPreflightResponse', () => {
-  it('should return 204 with default CORS headers', () => {
-    const response = createPreflightResponse(true);
-    
-    expect(response.statusCode).toBe(204);
-    expect(response.body).toBe('');
-    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('*');
-    expect(response.headers?.['Access-Control-Allow-Methods']).toContain('GET');
-  });
-
-  it('should use custom CORS config', () => {
-    const response = createPreflightResponse({
-      origins: ['https://myapp.com'],
-      methods: ['GET', 'POST'],
-      credentials: true
-    });
-    
-    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('https://myapp.com');
-    expect(response.headers?.['Access-Control-Allow-Methods']).toBe('GET, POST');
-    expect(response.headers?.['Access-Control-Allow-Credentials']).toBe('true');
-  });
-});
-
-describe('applyCorsHeaders', () => {
-  const originalResponse: HttpResponse = {
-    statusCode: 200,
-    body: JSON.stringify({ data: 'test' }),
-    headers: { 'Content-Type': 'application/json' }
-  };
-
-  it('should add CORS headers to response', () => {
-    const response = applyCorsHeaders(originalResponse, true);
-    
-    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('*');
-    expect(response.headers?.['Content-Type']).toBe('application/json');
-  });
-
-  it('should not modify response when cors is false', () => {
-    const response = applyCorsHeaders(originalResponse, false);
-    
-    expect(response.headers?.['Access-Control-Allow-Origin']).toBeUndefined();
-  });
-
-  it('should use custom CORS config', () => {
-    const response = applyCorsHeaders(originalResponse, {
-      origins: ['https://example.com'],
-      maxAge: 3600
-    });
-    
-    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('https://example.com');
-    expect(response.headers?.['Access-Control-Max-Age']).toBe('3600');
-  });
-});
-
-describe('withCors', () => {
-  const mockHandler = jest.fn().mockResolvedValue({
-    statusCode: 200,
-    body: JSON.stringify({ success: true })
-  });
-
-  beforeEach(() => {
-    mockHandler.mockClear();
-  });
-
-  it('should handle preflight requests without calling handler', async () => {
-    const wrappedHandler = withCors(mockHandler, true);
-    
-    const event = { eventRaw: { httpMethod: 'OPTIONS' } };
-    const response = await wrappedHandler(event);
-    
-    expect(response.statusCode).toBe(204);
-    expect(mockHandler).not.toHaveBeenCalled();
-  });
-
-  it('should call handler and add CORS headers for non-preflight', async () => {
-    const wrappedHandler = withCors(mockHandler, true);
-    
-    const event = { eventRaw: { httpMethod: 'GET' } };
-    const response = await wrappedHandler(event);
-    
-    expect(mockHandler).toHaveBeenCalledTimes(1);
-    expect(response.statusCode).toBe(200);
-    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('*');
-  });
-
-  it('should work with custom CORS config', async () => {
-    const wrappedHandler = withCors(mockHandler, {
-      origins: ['https://myapp.com'],
-      credentials: true
-    });
-    
-    const event = { eventRaw: { httpMethod: 'POST' } };
-    const response = await wrappedHandler(event);
-    
-    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('https://myapp.com');
-    expect(response.headers?.['Access-Control-Allow-Credentials']).toBe('true');
-  });
-});
+import {
+  isPreflightRequest,
+  createPreflightResponse,
+  applyCorsHeaders,
+  withCors
+} from '../src/http/cors';
+import { HttpResponse } from '../src/http/response';
+
+describe('isPreflightRequest', () => {
+  it('should return true for OPTIONS request', () => {
+    const event = { httpMethod: 'OPTIONS' };
+    expect(isPreflightRequest(event)).toBe(true);
+  });
+
+  it('should return true for lowercase options', () => {
+    const event = { httpMethod: 'options' };
+    expect(isPreflightRequest(event)).toBe(true);
+  });
+
+  it('should return false for GET request', () => {
+    const event = { httpMethod: 'GET' };
+    expect(isPreflightRequest(event)).toBe(false);
+  });
+
+  it('should return false for POST request', () => {
+    const event = { httpMethod: 'POST' };
+    expect(isPreflightRequest(event)).toBe(false);
+  });
+
+  it('should return false for undefined httpMethod', () => {
+    const event = {};
+    expect(isPreflightRequest(event)).toBe(false);
+  });
+});
+
+describe('createPreflightResponse', () => {
+  it('should return 204 with default CORS headers', () => {
+    const response = createPreflightResponse(true);
+    
+    expect(response.statusCode).toBe(204);
+    expect(response.body).toBe('');
+    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('*');
+    expect(response.headers?.['Access-Control-Allow-Methods']).toContain('GET');
+  });
+
+  it('should use custom CORS config', () => {
+    const response = createPreflightResponse({
+      origins: ['https://myapp.com'],
+      methods: ['GET', 'POST'],
+      credentials: true
+    });
+    
+    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('https://myapp.com');
+    expect(response.headers?.['Access-Control-Allow-Methods']).toBe('GET, POST');
+    expect(response.headers?.['Access-Control-Allow-Credentials']).toBe('true');
+  });
+});
+
+describe('applyCorsHeaders', () => {
+  const originalResponse: HttpResponse = {
+    statusCode: 200,
+    body: JSON.stringify({ data: 'test' }),
+    headers: { 'Content-Type': 'application/json' }
+  };
+
+  it('should add CORS headers to response', () => {
+    const response = applyCorsHeaders(originalResponse, true);
+    
+    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('*');
+    expect(response.headers?.['Content-Type']).toBe('application/json');
+  });
+
+  it('should not modify response when cors is false', () => {
+    const response = applyCorsHeaders(originalResponse, false);
+    
+    expect(response.headers?.['Access-Control-Allow-Origin']).toBeUndefined();
+  });
+
+  it('should use custom CORS config', () => {
+    const response = applyCorsHeaders(originalResponse, {
+      origins: ['https://example.com'],
+      maxAge: 3600
+    });
+    
+    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('https://example.com');
+    expect(response.headers?.['Access-Control-Max-Age']).toBe('3600');
+  });
+});
+
+describe('withCors', () => {
+  const mockHandler = jest.fn().mockResolvedValue({
+    statusCode: 200,
+    body: JSON.stringify({ success: true })
+  });
+
+  beforeEach(() => {
+    mockHandler.mockClear();
+  });
+
+  it('should handle preflight requests without calling handler', async () => {
+    const wrappedHandler = withCors(mockHandler, true);
+    
+    const event = { eventRaw: { httpMethod: 'OPTIONS' } };
+    const response = await wrappedHandler(event);
+    
+    expect(response.statusCode).toBe(204);
+    expect(mockHandler).not.toHaveBeenCalled();
+  });
+
+  it('should call handler and add CORS headers for non-preflight', async () => {
+    const wrappedHandler = withCors(mockHandler, true);
+    
+    const event = { eventRaw: { httpMethod: 'GET' } };
+    const response = await wrappedHandler(event);
+    
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+    expect(response.statusCode).toBe(200);
+    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('*');
+  });
+
+  it('should work with custom CORS config', async () => {
+    const wrappedHandler = withCors(mockHandler, {
+      origins: ['https://myapp.com'],
+      credentials: true
+    });
+    
+    const event = { eventRaw: { httpMethod: 'POST' } };
+    const response = await wrappedHandler(event);
+    
+    expect(response.headers?.['Access-Control-Allow-Origin']).toBe('https://myapp.com');
+    expect(response.headers?.['Access-Control-Allow-Credentials']).toBe('true');
+  });
+});