serverless-event-orchestrator 1.0.1

package/src/utils/path-matcher.ts

@@ -0,0 +1,79 @@
+/**
+ * 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[] = [];
+  
+  // Escape special regex characters except for our parameter syntax
+  let regexPattern = pattern
+    .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 {
+  return /\{[\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

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

package/tests/dispatcher.test.ts

@@ -0,0 +1,425 @@
+import { dispatchEvent, detectEventType } from '../src/dispatcher';
+import { EventType, RouteSegment } from '../src/types/event-type.enum';
+import { SegmentedHttpRouter, DispatchRoutes, NormalizedEvent } from '../src/types/routes';
+
+describe('detectEventType', () => {
+  it('should detect EventBridge events', () => {
+    const event = { source: 'EVENT_BRIDGE', detail: { operationName: 'test' } };
+    expect(detectEventType(event)).toBe(EventType.EventBridge);
+  });
+
+  it('should detect API Gateway events', () => {
+    const event = { requestContext: { requestId: '123' }, httpMethod: 'GET', path: '/test' };
+    expect(detectEventType(event)).toBe(EventType.ApiGateway);
+  });
+
+  it('should detect Lambda invocation events', () => {
+    const event = { awsRequestId: '1234-5678' };
+    expect(detectEventType(event)).toBe(EventType.Lambda);
+  });
+
+  it('should detect SQS events', () => {
+    const event = {
+      Records: [
+        { eventSource: 'aws:sqs', body: '{}', eventSourceARN: 'arn:aws:sqs:us-east-1:123:my-queue' }
+      ]
+    };
+    expect(detectEventType(event)).toBe(EventType.Sqs);
+  });
+
+  it('should return Unknown for unrecognized events', () => {
+    const event = { foo: 'bar' };
+    expect(detectEventType(event)).toBe(EventType.Unknown);
+  });
+});
+
+describe('dispatchEvent - API Gateway', () => {
+  const mockHandler = jest.fn().mockResolvedValue({ statusCode: 200, body: '{}' });
+
+  beforeEach(() => {
+    mockHandler.mockClear();
+  });
+
+  it('should dispatch to flat HTTP router', async () => {
+    const routes: DispatchRoutes = {
+      apigateway: {
+        get: {
+          '/users': { handler: mockHandler }
+        }
+      }
+    };
+
+    const event = {
+      requestContext: { requestId: '123' },
+      httpMethod: 'GET',
+      resource: '/users',
+      path: '/users',
+      headers: {},
+      queryStringParameters: null,
+      body: null
+    };
+
+    await dispatchEvent(event, routes);
+
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+    expect(mockHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        eventType: EventType.ApiGateway,
+        context: expect.objectContaining({
+          segment: RouteSegment.Public
+        })
+      })
+    );
+  });
+
+  it('should dispatch to segmented router', async () => {
+    const routes: DispatchRoutes = {
+      apigateway: {
+        public: {
+          get: { '/health': { handler: mockHandler } }
+        },
+        private: {
+          get: { '/profile': { handler: mockHandler } }
+        }
+      } as SegmentedHttpRouter
+    };
+
+    const event = {
+      requestContext: { requestId: '123' },
+      httpMethod: 'GET',
+      resource: '/profile',
+      path: '/profile',
+      headers: {},
+      body: null
+    };
+
+    await dispatchEvent(event, routes);
+
+    expect(mockHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        context: expect.objectContaining({
+          segment: RouteSegment.Private
+        })
+      })
+    );
+  });
+
+  it('should match path parameters', async () => {
+    const routes: DispatchRoutes = {
+      apigateway: {
+        get: {
+          '/users/{id}': { handler: mockHandler }
+        }
+      }
+    };
+
+    const event = {
+      requestContext: { requestId: '123' },
+      httpMethod: 'GET',
+      resource: '/users/{id}',
+      path: '/users/123',
+      headers: {},
+      body: null
+    };
+
+    await dispatchEvent(event, routes);
+
+    expect(mockHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        params: { id: '123' }
+      })
+    );
+  });
+
+  it('should parse JSON body', async () => {
+    const routes: DispatchRoutes = {
+      apigateway: {
+        post: {
+          '/users': { handler: mockHandler }
+        }
+      }
+    };
+
+    const event = {
+      requestContext: { requestId: '123' },
+      httpMethod: 'POST',
+      resource: '/users',
+      path: '/users',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'John', email: 'john@example.com' })
+    };
+
+    await dispatchEvent(event, routes);
+
+    expect(mockHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          body: { name: 'John', email: 'john@example.com' }
+        })
+      })
+    );
+  });
+
+  it('should return 404 when route not found', async () => {
+    const routes: DispatchRoutes = {
+      apigateway: {
+        get: {
+          '/users': { handler: mockHandler }
+        }
+      }
+    };
+
+    const event = {
+      requestContext: { requestId: '123' },
+      httpMethod: 'GET',
+      resource: '/nonexistent',
+      path: '/nonexistent',
+      headers: {},
+      body: null
+    };
+
+    const result = await dispatchEvent(event, routes);
+
+    expect(result.statusCode).toBe(404);
+    expect(mockHandler).not.toHaveBeenCalled();
+  });
+
+  it('should execute global middleware', async () => {
+    const middlewareFn = jest.fn().mockImplementation((event: NormalizedEvent) => {
+      return { ...event, payload: { ...event.payload, modified: true } };
+    });
+
+    const routes: DispatchRoutes = {
+      apigateway: {
+        get: { '/test': { handler: mockHandler } }
+      }
+    };
+
+    const event = {
+      requestContext: { requestId: '123' },
+      httpMethod: 'GET',
+      resource: '/test',
+      path: '/test',
+      headers: {},
+      body: null
+    };
+
+    await dispatchEvent(event, routes, {
+      globalMiddleware: [middlewareFn]
+    });
+
+    expect(middlewareFn).toHaveBeenCalledTimes(1);
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('dispatchEvent - EventBridge', () => {
+  const mockHandler = jest.fn().mockResolvedValue({ success: true });
+
+  beforeEach(() => {
+    mockHandler.mockClear();
+  });
+
+  it('should dispatch to named operation handler', async () => {
+    const routes: DispatchRoutes = {
+      eventbridge: {
+        'user.created': mockHandler
+      }
+    };
+
+    const event = {
+      source: 'EVENT_BRIDGE',
+      detail: { operationName: 'user.created', userId: '123' }
+    };
+
+    await dispatchEvent(event, routes);
+
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+  });
+
+  it('should fallback to default handler', async () => {
+    const routes: DispatchRoutes = {
+      eventbridge: {
+        default: mockHandler
+      }
+    };
+
+    const event = {
+      source: 'EVENT_BRIDGE',
+      detail: { operationName: 'unknown.event' }
+    };
+
+    await dispatchEvent(event, routes);
+
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('dispatchEvent - SQS', () => {
+  const mockHandler = jest.fn().mockResolvedValue({ success: true });
+
+  beforeEach(() => {
+    mockHandler.mockClear();
+  });
+
+  it('should dispatch to queue handler', async () => {
+    const routes: DispatchRoutes = {
+      sqs: {
+        'my-queue': mockHandler
+      }
+    };
+
+    const event = {
+      Records: [
+        {
+          eventSource: 'aws:sqs',
+          eventSourceARN: 'arn:aws:sqs:us-east-1:123456789:my-queue',
+          body: JSON.stringify({ message: 'Hello' }),
+          messageId: 'msg-123'
+        }
+      ]
+    };
+
+    await dispatchEvent(event, routes);
+
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+    expect(mockHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({
+          body: { message: 'Hello' }
+        })
+      })
+    );
+  });
+});
+
+describe('dispatchEvent - Lambda', () => {
+  const mockHandler = jest.fn().mockResolvedValue({ result: 'ok' });
+
+  beforeEach(() => {
+    mockHandler.mockClear();
+  });
+
+  it('should dispatch to default Lambda handler', async () => {
+    const routes: DispatchRoutes = {
+      lambda: {
+        default: mockHandler
+      }
+    };
+
+    const event = {
+      awsRequestId: '1234-5678',
+      customData: { foo: 'bar' }
+    };
+
+    await dispatchEvent(event, routes);
+
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('dispatchEvent - User Pool Validation', () => {
+  const mockHandler = jest.fn().mockResolvedValue({ statusCode: 200 });
+
+  beforeEach(() => {
+    mockHandler.mockClear();
+  });
+
+  it('should allow public routes without token', async () => {
+    const routes: DispatchRoutes = {
+      apigateway: {
+        public: {
+          get: { '/health': { handler: mockHandler } }
+        }
+      } as SegmentedHttpRouter
+    };
+
+    const event = {
+      requestContext: { requestId: '123' },
+      httpMethod: 'GET',
+      resource: '/health',
+      path: '/health',
+      headers: {},
+      body: null
+    };
+
+    await dispatchEvent(event, routes, {
+      userPools: {
+        private: 'us-east-1_ABC123'
+      }
+    });
+
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+  });
+
+  it('should reject private routes with wrong User Pool', async () => {
+    const routes: DispatchRoutes = {
+      apigateway: {
+        private: {
+          get: { '/profile': { handler: mockHandler } }
+        }
+      } as SegmentedHttpRouter
+    };
+
+    const event = {
+      requestContext: {
+        requestId: '123',
+        authorizer: {
+          claims: {
+            sub: 'user-123',
+            iss: 'https://cognito-idp.us-east-1.amazonaws.com/us-east-1_WRONG'
+          }
+        }
+      },
+      httpMethod: 'GET',
+      resource: '/profile',
+      path: '/profile',
+      headers: {},
+      body: null
+    };
+
+    const result = await dispatchEvent(event, routes, {
+      userPools: {
+        private: 'us-east-1_ABC123'
+      }
+    });
+
+    expect(result.statusCode).toBe(403);
+    expect(mockHandler).not.toHaveBeenCalled();
+  });
+
+  it('should allow private routes with correct User Pool', async () => {
+    const routes: DispatchRoutes = {
+      apigateway: {
+        private: {
+          get: { '/profile': { handler: mockHandler } }
+        }
+      } as SegmentedHttpRouter
+    };
+
+    const event = {
+      requestContext: {
+        requestId: '123',
+        authorizer: {
+          claims: {
+            sub: 'user-123',
+            iss: 'https://cognito-idp.us-east-1.amazonaws.com/us-east-1_ABC123'
+          }
+        }
+      },
+      httpMethod: 'GET',
+      resource: '/profile',
+      path: '/profile',
+      headers: {},
+      body: null
+    };
+
+    await dispatchEvent(event, routes, {
+      userPools: {
+        private: 'us-east-1_ABC123'
+      }
+    });
+
+    expect(mockHandler).toHaveBeenCalledTimes(1);
+  });
+});