serverless-event-orchestrator 1.0.1

package/tests/headers.test.ts

@@ -0,0 +1,99 @@
+import { normalizeHeaders, getHeader, getCorsHeaders } from '../src/utils/headers';
+
+describe('normalizeHeaders', () => {
+  it('should convert all header keys to lowercase', () => {
+    const headers = {
+      'Content-Type': 'application/json',
+      'X-Custom-Header': 'value',
+      'AUTHORIZATION': 'Bearer token'
+    };
+
+    const normalized = normalizeHeaders(headers);
+
+    expect(normalized['content-type']).toBe('application/json');
+    expect(normalized['x-custom-header']).toBe('value');
+    expect(normalized['authorization']).toBe('Bearer token');
+  });
+
+  it('should return empty object for undefined headers', () => {
+    expect(normalizeHeaders(undefined)).toEqual({});
+  });
+
+  it('should return empty object for empty headers', () => {
+    expect(normalizeHeaders({})).toEqual({});
+  });
+});
+
+describe('getHeader', () => {
+  const headers = {
+    'Content-Type': 'application/json',
+    'X-Request-ID': '12345'
+  };
+
+  it('should get header case-insensitively', () => {
+    expect(getHeader(headers, 'content-type')).toBe('application/json');
+    expect(getHeader(headers, 'Content-Type')).toBe('application/json');
+    expect(getHeader(headers, 'CONTENT-TYPE')).toBe('application/json');
+  });
+
+  it('should return undefined for missing header', () => {
+    expect(getHeader(headers, 'Authorization')).toBeUndefined();
+  });
+
+  it('should return undefined for undefined headers', () => {
+    expect(getHeader(undefined, 'Content-Type')).toBeUndefined();
+  });
+});
+
+describe('getCorsHeaders', () => {
+  it('should return default CORS headers without config', () => {
+    const corsHeaders = getCorsHeaders();
+
+    expect(corsHeaders['Access-Control-Allow-Origin']).toBe('*');
+    expect(corsHeaders['Access-Control-Allow-Methods']).toContain('GET');
+    expect(corsHeaders['Access-Control-Allow-Methods']).toContain('POST');
+    expect(corsHeaders['Access-Control-Allow-Headers']).toContain('Content-Type');
+  });
+
+  it('should use custom origins', () => {
+    const corsHeaders = getCorsHeaders({
+      origins: ['https://example.com', 'https://app.example.com']
+    });
+
+    expect(corsHeaders['Access-Control-Allow-Origin']).toBe('https://example.com, https://app.example.com');
+  });
+
+  it('should use wildcard origin', () => {
+    const corsHeaders = getCorsHeaders({ origins: '*' });
+
+    expect(corsHeaders['Access-Control-Allow-Origin']).toBe('*');
+  });
+
+  it('should set credentials header', () => {
+    const corsHeaders = getCorsHeaders({ credentials: true });
+
+    expect(corsHeaders['Access-Control-Allow-Credentials']).toBe('true');
+  });
+
+  it('should set max age header', () => {
+    const corsHeaders = getCorsHeaders({ maxAge: 86400 });
+
+    expect(corsHeaders['Access-Control-Max-Age']).toBe('86400');
+  });
+
+  it('should use custom methods', () => {
+    const corsHeaders = getCorsHeaders({
+      methods: ['GET', 'POST']
+    });
+
+    expect(corsHeaders['Access-Control-Allow-Methods']).toBe('GET, POST');
+  });
+
+  it('should use custom headers', () => {
+    const corsHeaders = getCorsHeaders({
+      headers: ['X-Custom-Header', 'X-Another-Header']
+    });
+
+    expect(corsHeaders['Access-Control-Allow-Headers']).toBe('X-Custom-Header, X-Another-Header');
+  });
+});

package/tests/identity.test.ts

@@ -0,0 +1,171 @@
+import {
+  extractIdentity,
+  extractUserPoolId,
+  validateIssuer,
+  hasAnyGroup,
+  hasAllGroups
+} from '../src/identity/extractor';
+import { IdentityContext } from '../src/types/routes';
+
+describe('extractIdentity', () => {
+  it('should return undefined when no claims present', () => {
+    const event = { requestContext: {} };
+    expect(extractIdentity(event)).toBeUndefined();
+  });
+
+  it('should return undefined when event has no requestContext', () => {
+    const event = {};
+    expect(extractIdentity(event)).toBeUndefined();
+  });
+
+  it('should extract identity from Cognito claims', () => {
+    const event = {
+      requestContext: {
+        authorizer: {
+          claims: {
+            sub: 'user-123',
+            email: 'user@example.com',
+            'cognito:groups': 'Admin,User',
+            iss: 'https://cognito-idp.us-east-1.amazonaws.com/us-east-1_ABC123'
+          }
+        }
+      }
+    };
+
+    const identity = extractIdentity(event);
+
+    expect(identity).toEqual({
+      userId: 'user-123',
+      email: 'user@example.com',
+      groups: ['Admin', 'User'],
+      issuer: 'https://cognito-idp.us-east-1.amazonaws.com/us-east-1_ABC123',
+      claims: event.requestContext.authorizer.claims
+    });
+  });
+
+  it('should handle cognito:username as userId fallback', () => {
+    const event = {
+      requestContext: {
+        authorizer: {
+          claims: {
+            'cognito:username': 'john_doe'
+          }
+        }
+      }
+    };
+
+    const identity = extractIdentity(event);
+    expect(identity?.userId).toBe('john_doe');
+  });
+
+  it('should handle groups as array', () => {
+    const event = {
+      requestContext: {
+        authorizer: {
+          claims: {
+            sub: 'user-123',
+            'cognito:groups': ['Admin', 'User']
+          }
+        }
+      }
+    };
+
+    const identity = extractIdentity(event);
+    expect(identity?.groups).toEqual(['Admin', 'User']);
+  });
+});
+
+describe('extractUserPoolId', () => {
+  it('should extract User Pool ID from issuer URL', () => {
+    const issuer = 'https://cognito-idp.us-east-1.amazonaws.com/us-east-1_ABC123';
+    expect(extractUserPoolId(issuer)).toBe('us-east-1_ABC123');
+  });
+
+  it('should return undefined for undefined issuer', () => {
+    expect(extractUserPoolId(undefined)).toBeUndefined();
+  });
+
+  it('should handle issuer with trailing slash', () => {
+    const issuer = 'https://cognito-idp.us-east-1.amazonaws.com/us-east-1_XYZ789';
+    expect(extractUserPoolId(issuer)).toBe('us-east-1_XYZ789');
+  });
+});
+
+describe('validateIssuer', () => {
+  const validIdentity: IdentityContext = {
+    userId: 'user-123',
+    issuer: 'https://cognito-idp.us-east-1.amazonaws.com/us-east-1_ABC123'
+  };
+
+  it('should return true when User Pool matches', () => {
+    expect(validateIssuer(validIdentity, 'us-east-1_ABC123')).toBe(true);
+  });
+
+  it('should return false when User Pool does not match', () => {
+    expect(validateIssuer(validIdentity, 'us-east-1_WRONG')).toBe(false);
+  });
+
+  it('should return false when identity is undefined', () => {
+    expect(validateIssuer(undefined, 'us-east-1_ABC123')).toBe(false);
+  });
+
+  it('should return false when issuer is missing', () => {
+    const identity: IdentityContext = { userId: 'user-123' };
+    expect(validateIssuer(identity, 'us-east-1_ABC123')).toBe(false);
+  });
+});
+
+describe('hasAnyGroup', () => {
+  const identity: IdentityContext = {
+    userId: 'user-123',
+    groups: ['User', 'Premium']
+  };
+
+  it('should return true if user has any of the allowed groups', () => {
+    expect(hasAnyGroup(identity, ['Admin', 'Premium'])).toBe(true);
+    expect(hasAnyGroup(identity, ['User'])).toBe(true);
+  });
+
+  it('should return false if user has none of the allowed groups', () => {
+    expect(hasAnyGroup(identity, ['Admin', 'SuperAdmin'])).toBe(false);
+  });
+
+  it('should return false for undefined identity', () => {
+    expect(hasAnyGroup(undefined, ['Admin'])).toBe(false);
+  });
+
+  it('should return false for identity with no groups', () => {
+    const noGroupsIdentity: IdentityContext = { userId: 'user-123' };
+    expect(hasAnyGroup(noGroupsIdentity, ['Admin'])).toBe(false);
+  });
+
+  it('should return false for empty groups array', () => {
+    const emptyGroupsIdentity: IdentityContext = { userId: 'user-123', groups: [] };
+    expect(hasAnyGroup(emptyGroupsIdentity, ['Admin'])).toBe(false);
+  });
+});
+
+describe('hasAllGroups', () => {
+  const identity: IdentityContext = {
+    userId: 'user-123',
+    groups: ['User', 'Premium', 'Verified']
+  };
+
+  it('should return true if user has all required groups', () => {
+    expect(hasAllGroups(identity, ['User', 'Premium'])).toBe(true);
+    expect(hasAllGroups(identity, ['Verified'])).toBe(true);
+  });
+
+  it('should return false if user is missing any required group', () => {
+    expect(hasAllGroups(identity, ['User', 'Admin'])).toBe(false);
+  });
+
+  it('should return false for undefined identity', () => {
+    expect(hasAllGroups(undefined, ['Admin'])).toBe(false);
+  });
+
+  it('should return false for identity with no groups', () => {
+    const noGroupsIdentity: IdentityContext = { userId: 'user-123' };
+    expect(hasAllGroups(noGroupsIdentity, ['Admin'])).toBe(false);
+  });
+});

package/tests/path-matcher.test.ts

@@ -0,0 +1,102 @@
+import { 
+  matchPath, 
+  patternToRegex, 
+  hasPathParameters, 
+  normalizePath 
+} from '../src/utils/path-matcher';
+
+describe('patternToRegex', () => {
+  it('should convert simple pattern without parameters', () => {
+    const { regex, paramNames } = patternToRegex('/users');
+    expect(paramNames).toEqual([]);
+    expect(regex.test('/users')).toBe(true);
+    expect(regex.test('/users/')).toBe(false);
+    expect(regex.test('/other')).toBe(false);
+  });
+
+  it('should extract single parameter name', () => {
+    const { regex, paramNames } = patternToRegex('/users/{id}');
+    expect(paramNames).toEqual(['id']);
+    expect(regex.test('/users/123')).toBe(true);
+    expect(regex.test('/users/abc-def')).toBe(true);
+    expect(regex.test('/users/')).toBe(false);
+  });
+
+  it('should extract multiple parameter names', () => {
+    const { regex, paramNames } = patternToRegex('/users/{userId}/posts/{postId}');
+    expect(paramNames).toEqual(['userId', 'postId']);
+    expect(regex.test('/users/123/posts/456')).toBe(true);
+  });
+
+  it('should escape special regex characters', () => {
+    const { regex } = patternToRegex('/api/v1.0/users');
+    expect(regex.test('/api/v1.0/users')).toBe(true);
+    expect(regex.test('/api/v1X0/users')).toBe(false);
+  });
+});
+
+describe('matchPath', () => {
+  it('should return null for non-matching paths', () => {
+    expect(matchPath('/users', '/posts')).toBeNull();
+    expect(matchPath('/users/{id}', '/posts/123')).toBeNull();
+  });
+
+  it('should return empty params for exact match without parameters', () => {
+    const result = matchPath('/users', '/users');
+    expect(result).toEqual({});
+  });
+
+  it('should extract single path parameter', () => {
+    const result = matchPath('/users/{id}', '/users/123');
+    expect(result).toEqual({ id: '123' });
+  });
+
+  it('should extract multiple path parameters', () => {
+    const result = matchPath('/users/{userId}/posts/{postId}', '/users/abc/posts/xyz');
+    expect(result).toEqual({ userId: 'abc', postId: 'xyz' });
+  });
+
+  it('should handle parameters with special characters', () => {
+    const result = matchPath('/users/{id}', '/users/user-123_abc');
+    expect(result).toEqual({ id: 'user-123_abc' });
+  });
+
+  it('should not match partial paths', () => {
+    expect(matchPath('/users/{id}', '/users/123/extra')).toBeNull();
+    expect(matchPath('/users/{id}/posts', '/users/123')).toBeNull();
+  });
+});
+
+describe('hasPathParameters', () => {
+  it('should return true for patterns with parameters', () => {
+    expect(hasPathParameters('/users/{id}')).toBe(true);
+    expect(hasPathParameters('/users/{userId}/posts/{postId}')).toBe(true);
+  });
+
+  it('should return false for patterns without parameters', () => {
+    expect(hasPathParameters('/users')).toBe(false);
+    expect(hasPathParameters('/users/list')).toBe(false);
+  });
+});
+
+describe('normalizePath', () => {
+  it('should add leading slash if missing', () => {
+    expect(normalizePath('users')).toBe('/users');
+  });
+
+  it('should remove trailing slash', () => {
+    expect(normalizePath('/users/')).toBe('/users');
+  });
+
+  it('should keep root path as is', () => {
+    expect(normalizePath('/')).toBe('/');
+  });
+
+  it('should handle empty string', () => {
+    expect(normalizePath('')).toBe('/');
+  });
+
+  it('should normalize complex paths', () => {
+    expect(normalizePath('users/123/')).toBe('/users/123');
+  });
+});

package/tests/response.test.ts

@@ -0,0 +1,155 @@
+import {
+  HttpStatus,
+  DefaultResponseCode,
+  createStandardResponse,
+  successResponse,
+  createdResponse,
+  badRequestResponse,
+  unauthorizedResponse,
+  forbiddenResponse,
+  notFoundResponse,
+  conflictResponse,
+  validationErrorResponse,
+  internalErrorResponse,
+  customErrorResponse
+} from '../src/http/response';
+
+describe('createStandardResponse', () => {
+  it('should create response with data', () => {
+    const response = createStandardResponse(200, { user: { id: 1 } });
+    const body = JSON.parse(response.body);
+    
+    expect(response.statusCode).toBe(200);
+    expect(body.status).toBe(200);
+    expect(body.code).toBe(DefaultResponseCode.SUCCESS);
+    expect(body.data).toEqual({ user: { id: 1 } });
+  });
+
+  it('should create response with custom code', () => {
+    const response = createStandardResponse(200, null, 'CUSTOM_CODE');
+    const body = JSON.parse(response.body);
+    
+    expect(body.code).toBe('CUSTOM_CODE');
+  });
+
+  it('should create response with message', () => {
+    const response = createStandardResponse(400, undefined, undefined, 'Error message');
+    const body = JSON.parse(response.body);
+    
+    expect(body.message).toBe('Error message');
+  });
+
+  it('should include custom headers', () => {
+    const response = createStandardResponse(200, null, undefined, undefined, {
+      'X-Custom-Header': 'value'
+    });
+    
+    expect(response.headers?.['X-Custom-Header']).toBe('value');
+    expect(response.headers?.['Content-Type']).toBe('application/json');
+  });
+});
+
+describe('successResponse', () => {
+  it('should return 200 with data', () => {
+    const response = successResponse({ items: [1, 2, 3] });
+    const body = JSON.parse(response.body);
+    
+    expect(response.statusCode).toBe(200);
+    expect(body.code).toBe(DefaultResponseCode.SUCCESS);
+    expect(body.data).toEqual({ items: [1, 2, 3] });
+  });
+
+  it('should return 200 without data', () => {
+    const response = successResponse();
+    expect(response.statusCode).toBe(200);
+  });
+});
+
+describe('createdResponse', () => {
+  it('should return 201 with data', () => {
+    const response = createdResponse({ id: 123 });
+    const body = JSON.parse(response.body);
+    
+    expect(response.statusCode).toBe(201);
+    expect(body.code).toBe(DefaultResponseCode.CREATED);
+    expect(body.data).toEqual({ id: 123 });
+  });
+});
+
+describe('error responses', () => {
+  it('badRequestResponse should return 400', () => {
+    const response = badRequestResponse('Invalid input');
+    const body = JSON.parse(response.body);
+    
+    expect(response.statusCode).toBe(400);
+    expect(body.code).toBe(DefaultResponseCode.BAD_REQUEST);
+    expect(body.message).toBe('Invalid input');
+  });
+
+  it('unauthorizedResponse should return 401', () => {
+    const response = unauthorizedResponse('Token expired');
+    
+    expect(response.statusCode).toBe(401);
+  });
+
+  it('forbiddenResponse should return 403', () => {
+    const response = forbiddenResponse('Access denied');
+    
+    expect(response.statusCode).toBe(403);
+  });
+
+  it('notFoundResponse should return 404', () => {
+    const response = notFoundResponse('User not found');
+    
+    expect(response.statusCode).toBe(404);
+  });
+
+  it('conflictResponse should return 409', () => {
+    const response = conflictResponse('Email already exists');
+    
+    expect(response.statusCode).toBe(409);
+  });
+
+  it('validationErrorResponse should return 422', () => {
+    const response = validationErrorResponse('Invalid email format');
+    
+    expect(response.statusCode).toBe(422);
+  });
+
+  it('internalErrorResponse should return 500', () => {
+    const response = internalErrorResponse('Something went wrong');
+    
+    expect(response.statusCode).toBe(500);
+  });
+});
+
+describe('customErrorResponse', () => {
+  enum MyErrorCodes {
+    USER_SUSPENDED = 'USER_SUSPENDED',
+    QUOTA_EXCEEDED = 'QUOTA_EXCEEDED'
+  }
+
+  const codeToStatus: Record<MyErrorCodes, HttpStatus> = {
+    [MyErrorCodes.USER_SUSPENDED]: HttpStatus.FORBIDDEN,
+    [MyErrorCodes.QUOTA_EXCEEDED]: HttpStatus.UNPROCESSABLE_ENTITY
+  };
+
+  it('should map custom code to correct status', () => {
+    const response = customErrorResponse(
+      MyErrorCodes.USER_SUSPENDED,
+      'Account suspended',
+      codeToStatus
+    );
+    const body = JSON.parse(response.body);
+    
+    expect(response.statusCode).toBe(403);
+    expect(body.code).toBe('USER_SUSPENDED');
+    expect(body.message).toBe('Account suspended');
+  });
+
+  it('should default to 500 for unmapped codes', () => {
+    const response = customErrorResponse('UNKNOWN_CODE', 'Unknown error');
+    
+    expect(response.statusCode).toBe(500);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}