@geekmidas/constructs 0.3.2 → 0.6.0

package/src/endpoints/__tests__/AmazonApiGatewayV2EndpointAdaptor.factory-publisher.spec.ts

@@ -11,286 +11,286 @@ import { e } from '../EndpointFactory';
 
 // Test event types
 type TestEvent =
-  | PublishableMessage<'user.created', { userId: string; email: string }>
-  | PublishableMessage<'user.updated', { userId: string; changes: string[] }>;
+	| PublishableMessage<'user.created', { userId: string; email: string }>
+	| PublishableMessage<'user.updated', { userId: string; changes: string[] }>;
 
 describe('AmazonApiGatewayV2Endpoint Factory Publisher Pattern', () => {
-  let mockLogger: Logger;
-  let envParser: EnvironmentParser<{}>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockLogger = createMockLogger();
-    envParser = new EnvironmentParser({});
-  });
-
-  it('should publish events when using factory.publisher() pattern', async () => {
-    // Create mock publisher exactly as user would
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const EventsService: Service<'EventsService', EventPublisher<TestEvent>> = {
-      serviceName: 'EventsService' as const,
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    // Create factory with publisher exactly as user described
-    const r = e.logger(mockLogger).services([]).publisher(EventsService);
-
-    // Create endpoint from factory
-    const endpoint = r
-      .post('/orders')
-      .body(z.object({ productId: z.string(), quantity: z.number() }))
-      .output(z.object({ orderId: z.string(), amount: z.number() }))
-      .event({
-        type: 'user.created',
-        payload: (response) => ({
-          userId: response.orderId,
-          email: `order-${response.orderId}@example.com`,
-        }),
-      })
-      .handle(async () => ({
-        orderId: 'order-123',
-        amount: 99.99,
-      }));
-
-    // Verify publisher is set on endpoint
-    expect(endpoint.publisherService).toBeDefined();
-    expect(endpoint.publisherService?.serviceName).toBe('EventsService');
-
-    // Create adapter and test
-    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
-    const handler = adapter.handler;
-
-    const event = createMockV2Event({
-      requestContext: {
-        ...createMockV2Event().requestContext,
-        http: {
-          method: 'POST',
-          path: '/orders',
-          protocol: 'HTTP/1.1',
-          sourceIp: '127.0.0.1',
-          userAgent: 'test-agent',
-        },
-      },
-      body: JSON.stringify({ productId: 'prod-456', quantity: 2 }),
-    });
-    const context = createMockContext();
-
-    const response = await handler(event, context);
-
-    // Verify successful response
-    expect(response.statusCode).toBe(200);
-    expect(response.body).toBe(
-      JSON.stringify({ orderId: 'order-123', amount: 99.99 }),
-    );
-
-    // Verify publisher was called correctly
-    expect(EventsService.register).toHaveBeenCalled();
-    expect(mockPublisher.publish).toHaveBeenCalledWith([
-      {
-        type: 'user.created',
-        payload: {
-          userId: 'order-123',
-          email: 'order-order-123@example.com',
-        },
-      },
-    ]);
-  });
-
-  it('should handle factory publisher with conditional events', async () => {
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const ConditionalEventsService: Service<
-      'ConditionalEventsService',
-      EventPublisher<TestEvent>
-    > = {
-      serviceName: 'ConditionalEventsService' as const,
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    const factory = e.logger(mockLogger).publisher(ConditionalEventsService);
-
-    const endpoint = factory
-      .put('/orders/:id')
-      .params(z.object({ id: z.string() }))
-      .body(z.object({ status: z.enum(['pending', 'completed', 'cancelled']) }))
-      .output(
-        z.object({
-          orderId: z.string(),
-          status: z.string(),
-          isNew: z.boolean(),
-        }),
-      )
-      .event({
-        type: 'user.created',
-        payload: (response) => ({
-          userId: response.orderId,
-          email: `new-${response.orderId}@example.com`,
-        }),
-        when: (response) => response.isNew === true,
-      })
-      .event({
-        type: 'user.updated',
-        payload: (response) => ({
-          userId: response.orderId,
-          changes: ['status'],
-        }),
-        when: (response) => response.isNew === false,
-      })
-      .handle(async ({ params }) => ({
-        orderId: params.id,
-        status: 'completed',
-        isNew: false, // Existing order
-      }));
-
-    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
-    const handler = adapter.handler;
-
-    const event = createMockV2Event({
-      requestContext: {
-        ...createMockV2Event().requestContext,
-        http: {
-          method: 'PUT',
-          path: '/orders/order-789',
-          protocol: 'HTTP/1.1',
-          sourceIp: '127.0.0.1',
-          userAgent: 'test-agent',
-        },
-      },
-      pathParameters: { id: 'order-789' },
-      body: JSON.stringify({ status: 'completed' }),
-    });
-    const context = createMockContext();
-
-    const response = await handler(event, context);
-
-    // Should succeed
-    expect(response.statusCode).toBe(200);
-
-    // Only user.updated should be published (isNew = false)
-    expect(mockPublisher.publish).toHaveBeenCalledWith([
-      {
-        type: 'user.updated',
-        payload: { userId: 'order-789', changes: ['status'] },
-      },
-    ]);
-  });
-
-  it('should work with multiple factory publisher endpoints', async () => {
-    const mockPublisher: EventPublisher<TestEvent> = {
-      publish: vi.fn().mockResolvedValue(undefined),
-    };
-
-    const SharedEventsService: Service<
-      'SharedEventsService',
-      EventPublisher<TestEvent>
-    > = {
-      serviceName: 'SharedEventsService' as const,
-      register: vi.fn().mockResolvedValue(mockPublisher),
-    };
-
-    // Create shared factory
-    const factory = e.logger(mockLogger).publisher(SharedEventsService);
-
-    // Create multiple endpoints from same factory
-    const createEndpoint = factory
-      .post('/orders')
-      .output(z.object({ orderId: z.string() }))
-      .event({
-        type: 'user.created',
-        payload: (response) => ({
-          userId: response.orderId,
-          email: 'create@example.com',
-        }),
-      })
-      .handle(async () => ({ orderId: 'create-order' }));
-
-    const updateEndpoint = factory
-      .put('/orders/:id')
-      .params(z.object({ id: z.string() }))
-      .output(z.object({ orderId: z.string() }))
-      .event({
-        type: 'user.updated',
-        payload: (response) => ({
-          userId: response.orderId,
-          changes: ['status'],
-        }),
-      })
-      .handle(async ({ params }) => ({ orderId: params.id }));
-
-    // Both endpoints should have the shared publisher
-    expect(createEndpoint.publisherService?.serviceName).toBe(
-      'SharedEventsService',
-    );
-    expect(updateEndpoint.publisherService?.serviceName).toBe(
-      'SharedEventsService',
-    );
-
-    // Test create endpoint
-    const createAdapter = new AmazonApiGatewayV2Endpoint(
-      envParser,
-      createEndpoint,
-    );
-    const createHandler = createAdapter.handler;
-
-    const createEvent = createMockV2Event({
-      requestContext: {
-        ...createMockV2Event().requestContext,
-        http: {
-          method: 'POST',
-          path: '/orders',
-          protocol: 'HTTP/1.1',
-          sourceIp: '127.0.0.1',
-          userAgent: 'test-agent',
-        },
-      },
-    });
-
-    await createHandler(createEvent, createMockContext());
-
-    expect(mockPublisher.publish).toHaveBeenCalledWith([
-      {
-        type: 'user.created',
-        payload: { userId: 'create-order', email: 'create@example.com' },
-      },
-    ]);
-
-    // Reset mock
-    vi.clearAllMocks();
-    (SharedEventsService.register as any).mockResolvedValue(mockPublisher);
-
-    // Test update endpoint
-    const updateAdapter = new AmazonApiGatewayV2Endpoint(
-      envParser,
-      updateEndpoint,
-    );
-    const updateHandler = updateAdapter.handler;
-
-    const updateEvent = createMockV2Event({
-      requestContext: {
-        ...createMockV2Event().requestContext,
-        http: {
-          method: 'PUT',
-          path: '/orders/update-order',
-          protocol: 'HTTP/1.1',
-          sourceIp: '127.0.0.1',
-          userAgent: 'test-agent',
-        },
-      },
-      pathParameters: { id: 'update-order' },
-    });
-
-    await updateHandler(updateEvent, createMockContext());
-
-    expect(mockPublisher.publish).toHaveBeenCalledWith([
-      {
-        type: 'user.updated',
-        payload: { userId: 'update-order', changes: ['status'] },
-      },
-    ]);
-  });
+	let mockLogger: Logger;
+	let envParser: EnvironmentParser<{}>;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockLogger = createMockLogger();
+		envParser = new EnvironmentParser({});
+	});
+
+	it('should publish events when using factory.publisher() pattern', async () => {
+		// Create mock publisher exactly as user would
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const EventsService: Service<'EventsService', EventPublisher<TestEvent>> = {
+			serviceName: 'EventsService' as const,
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		// Create factory with publisher exactly as user described
+		const r = e.logger(mockLogger).services([]).publisher(EventsService);
+
+		// Create endpoint from factory
+		const endpoint = r
+			.post('/orders')
+			.body(z.object({ productId: z.string(), quantity: z.number() }))
+			.output(z.object({ orderId: z.string(), amount: z.number() }))
+			.event({
+				type: 'user.created',
+				payload: (response) => ({
+					userId: response.orderId,
+					email: `order-${response.orderId}@example.com`,
+				}),
+			})
+			.handle(async () => ({
+				orderId: 'order-123',
+				amount: 99.99,
+			}));
+
+		// Verify publisher is set on endpoint
+		expect(endpoint.publisherService).toBeDefined();
+		expect(endpoint.publisherService?.serviceName).toBe('EventsService');
+
+		// Create adapter and test
+		const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
+		const handler = adapter.handler;
+
+		const event = createMockV2Event({
+			requestContext: {
+				...createMockV2Event().requestContext,
+				http: {
+					method: 'POST',
+					path: '/orders',
+					protocol: 'HTTP/1.1',
+					sourceIp: '127.0.0.1',
+					userAgent: 'test-agent',
+				},
+			},
+			body: JSON.stringify({ productId: 'prod-456', quantity: 2 }),
+		});
+		const context = createMockContext();
+
+		const response = await handler(event, context);
+
+		// Verify successful response
+		expect(response.statusCode).toBe(200);
+		expect(response.body).toBe(
+			JSON.stringify({ orderId: 'order-123', amount: 99.99 }),
+		);
+
+		// Verify publisher was called correctly
+		expect(EventsService.register).toHaveBeenCalled();
+		expect(mockPublisher.publish).toHaveBeenCalledWith([
+			{
+				type: 'user.created',
+				payload: {
+					userId: 'order-123',
+					email: 'order-order-123@example.com',
+				},
+			},
+		]);
+	});
+
+	it('should handle factory publisher with conditional events', async () => {
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const ConditionalEventsService: Service<
+			'ConditionalEventsService',
+			EventPublisher<TestEvent>
+		> = {
+			serviceName: 'ConditionalEventsService' as const,
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		const factory = e.logger(mockLogger).publisher(ConditionalEventsService);
+
+		const endpoint = factory
+			.put('/orders/:id')
+			.params(z.object({ id: z.string() }))
+			.body(z.object({ status: z.enum(['pending', 'completed', 'cancelled']) }))
+			.output(
+				z.object({
+					orderId: z.string(),
+					status: z.string(),
+					isNew: z.boolean(),
+				}),
+			)
+			.event({
+				type: 'user.created',
+				payload: (response) => ({
+					userId: response.orderId,
+					email: `new-${response.orderId}@example.com`,
+				}),
+				when: (response) => response.isNew === true,
+			})
+			.event({
+				type: 'user.updated',
+				payload: (response) => ({
+					userId: response.orderId,
+					changes: ['status'],
+				}),
+				when: (response) => response.isNew === false,
+			})
+			.handle(async ({ params }) => ({
+				orderId: params.id,
+				status: 'completed',
+				isNew: false, // Existing order
+			}));
+
+		const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint);
+		const handler = adapter.handler;
+
+		const event = createMockV2Event({
+			requestContext: {
+				...createMockV2Event().requestContext,
+				http: {
+					method: 'PUT',
+					path: '/orders/order-789',
+					protocol: 'HTTP/1.1',
+					sourceIp: '127.0.0.1',
+					userAgent: 'test-agent',
+				},
+			},
+			pathParameters: { id: 'order-789' },
+			body: JSON.stringify({ status: 'completed' }),
+		});
+		const context = createMockContext();
+
+		const response = await handler(event, context);
+
+		// Should succeed
+		expect(response.statusCode).toBe(200);
+
+		// Only user.updated should be published (isNew = false)
+		expect(mockPublisher.publish).toHaveBeenCalledWith([
+			{
+				type: 'user.updated',
+				payload: { userId: 'order-789', changes: ['status'] },
+			},
+		]);
+	});
+
+	it('should work with multiple factory publisher endpoints', async () => {
+		const mockPublisher: EventPublisher<TestEvent> = {
+			publish: vi.fn().mockResolvedValue(undefined),
+		};
+
+		const SharedEventsService: Service<
+			'SharedEventsService',
+			EventPublisher<TestEvent>
+		> = {
+			serviceName: 'SharedEventsService' as const,
+			register: vi.fn().mockResolvedValue(mockPublisher),
+		};
+
+		// Create shared factory
+		const factory = e.logger(mockLogger).publisher(SharedEventsService);
+
+		// Create multiple endpoints from same factory
+		const createEndpoint = factory
+			.post('/orders')
+			.output(z.object({ orderId: z.string() }))
+			.event({
+				type: 'user.created',
+				payload: (response) => ({
+					userId: response.orderId,
+					email: 'create@example.com',
+				}),
+			})
+			.handle(async () => ({ orderId: 'create-order' }));
+
+		const updateEndpoint = factory
+			.put('/orders/:id')
+			.params(z.object({ id: z.string() }))
+			.output(z.object({ orderId: z.string() }))
+			.event({
+				type: 'user.updated',
+				payload: (response) => ({
+					userId: response.orderId,
+					changes: ['status'],
+				}),
+			})
+			.handle(async ({ params }) => ({ orderId: params.id }));
+
+		// Both endpoints should have the shared publisher
+		expect(createEndpoint.publisherService?.serviceName).toBe(
+			'SharedEventsService',
+		);
+		expect(updateEndpoint.publisherService?.serviceName).toBe(
+			'SharedEventsService',
+		);
+
+		// Test create endpoint
+		const createAdapter = new AmazonApiGatewayV2Endpoint(
+			envParser,
+			createEndpoint,
+		);
+		const createHandler = createAdapter.handler;
+
+		const createEvent = createMockV2Event({
+			requestContext: {
+				...createMockV2Event().requestContext,
+				http: {
+					method: 'POST',
+					path: '/orders',
+					protocol: 'HTTP/1.1',
+					sourceIp: '127.0.0.1',
+					userAgent: 'test-agent',
+				},
+			},
+		});
+
+		await createHandler(createEvent, createMockContext());
+
+		expect(mockPublisher.publish).toHaveBeenCalledWith([
+			{
+				type: 'user.created',
+				payload: { userId: 'create-order', email: 'create@example.com' },
+			},
+		]);
+
+		// Reset mock
+		vi.clearAllMocks();
+		(SharedEventsService.register as any).mockResolvedValue(mockPublisher);
+
+		// Test update endpoint
+		const updateAdapter = new AmazonApiGatewayV2Endpoint(
+			envParser,
+			updateEndpoint,
+		);
+		const updateHandler = updateAdapter.handler;
+
+		const updateEvent = createMockV2Event({
+			requestContext: {
+				...createMockV2Event().requestContext,
+				http: {
+					method: 'PUT',
+					path: '/orders/update-order',
+					protocol: 'HTTP/1.1',
+					sourceIp: '127.0.0.1',
+					userAgent: 'test-agent',
+				},
+			},
+			pathParameters: { id: 'update-order' },
+		});
+
+		await updateHandler(updateEvent, createMockContext());
+
+		expect(mockPublisher.publish).toHaveBeenCalledWith([
+			{
+				type: 'user.updated',
+				payload: { userId: 'update-order', changes: ['status'] },
+			},
+		]);
+	});
 });