@geekmidas/constructs 0.0.1

package/src/endpoints/__tests__/AmazonApiGatewayV2EndpointAdaptor.events.spec.ts

@@ -0,0 +1,721 @@
+import { EnvironmentParser } from '@geekmidas/envkit';
+import type {
+  EventPublisher,
+  MappedEvent,
+  PublishableMessage,
+} from '@geekmidas/events';
+import type { Logger } from '@geekmidas/logger';
+import type { Service } from '@geekmidas/services';
+import { createMockContext, createMockV2Event } from '@geekmidas/testkit/aws';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+import { AmazonApiGatewayV2Endpoint } from '../AmazonApiGatewayV2EndpointAdaptor';
+import { Endpoint } from '../Endpoint';
+
+// Test event types
+type TestEvent =
+  | PublishableMessage<'user.created', { userId: string; email: string }>
+  | PublishableMessage<'user.updated', { userId: string; changes: string[] }>
+  | PublishableMessage<'notification.sent', { userId: string; type: string }>;
+
+// Mock logger
+const createMockLogger = (): Logger => {
+  const logger: Logger = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    fatal: vi.fn(),
+    trace: vi.fn(),
+    child: vi.fn(() => logger),
+  };
+  return logger;
+};
+
+describe('AmazonApiGatewayV2Endpoint Events', () => {
+  let mockLogger: Logger;
+  let envParser: EnvironmentParser<{}>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockLogger = createMockLogger();
+    envParser = new EnvironmentParser({});
+  });
+
+  it('should publish events after successful endpoint execution', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<
+      'publisher',
+      EventPublisher<TestEvent>
+    > = {
+      serviceName: 'publisher' as const,
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const events: MappedEvent<
+      EventPublisher<TestEvent>,
+      typeof outputSchema
+    >[] = [
+      {
+        type: 'user.created',
+        payload: (response) => ({ userId: response.id, email: response.email }),
+      },
+    ];
+
+    const endpoint = new Endpoint({
+      route: '/users',
+      method: 'POST',
+      fn: async () => ({ id: '123', email: 'test@example.com' }),
+      input: undefined,
+      output: outputSchema,
+      services: [],
+      logger: mockLogger,
+      timeout: undefined,
+      status: 200,
+      getSession: undefined,
+      authorize: undefined,
+      description: undefined,
+      events,
+      publisherService: mockPublisherService,
+    });
+
+    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint as any);
+    const handler = adapter.handler;
+
+    const event = createMockV2Event({
+      requestContext: {
+        ...createMockV2Event().requestContext,
+        http: {
+          method: 'POST',
+          path: '/users',
+          protocol: 'HTTP/1.1',
+          sourceIp: '192.168.1.1',
+          userAgent: 'test-agent',
+        },
+      },
+      body: JSON.stringify({}),
+    });
+    const context = createMockContext();
+    const response = await handler(event, context);
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toBe(
+      JSON.stringify({ id: '123', email: 'test@example.com' }),
+    );
+
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.created',
+        payload: { userId: '123', email: 'test@example.com' },
+      },
+    ]);
+  });
+
+  it('should publish multiple events after successful endpoint execution', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const events: MappedEvent<
+      EventPublisher<TestEvent>,
+      typeof outputSchema
+    >[] = [
+      {
+        type: 'user.created',
+        payload: (response) => ({ userId: response.id, email: response.email }),
+      },
+      {
+        type: 'notification.sent',
+        payload: (response) => ({ userId: response.id, type: 'welcome' }),
+      },
+    ];
+
+    const endpoint = new Endpoint({
+      route: '/users',
+      method: 'POST',
+      fn: async () => ({ id: '456', email: 'user@example.com' }),
+      input: undefined,
+      output: outputSchema,
+      services: [],
+      logger: mockLogger,
+      timeout: undefined,
+      status: 201,
+      getSession: undefined,
+      authorize: undefined,
+      description: undefined,
+      events,
+      publisherService: mockPublisherService,
+    });
+
+    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint as any);
+    const handler = adapter.handler;
+
+    const event = createMockV2Event({
+      requestContext: {
+        ...createMockV2Event().requestContext,
+        http: {
+          method: 'POST',
+          path: '/users',
+          protocol: 'HTTP/1.1',
+          sourceIp: '192.168.1.1',
+          userAgent: 'test-agent',
+        },
+      },
+      body: JSON.stringify({}),
+    });
+    const context = createMockContext();
+    const response = await handler(event, context);
+
+    expect(response.statusCode).toBe(201);
+    expect(response.body).toBe(
+      JSON.stringify({ id: '456', email: 'user@example.com' }),
+    );
+
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.created',
+        payload: { userId: '456', email: 'user@example.com' },
+      },
+      {
+        type: 'notification.sent',
+        payload: { userId: '456', type: 'welcome' },
+      },
+    ]);
+  });
+
+  it('should respect when conditions for events', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({
+      id: z.string(),
+      email: z.string(),
+      isNew: z.boolean(),
+    });
+
+    const events: MappedEvent<
+      EventPublisher<TestEvent>,
+      typeof outputSchema
+    >[] = [
+      {
+        type: 'user.created',
+        payload: (response) => ({ userId: response.id, email: response.email }),
+        when: (response) => response.isNew === true,
+      },
+      {
+        type: 'user.updated',
+        payload: (response) => ({ userId: response.id, changes: ['email'] }),
+        when: (response) => response.isNew === false,
+      },
+    ];
+
+    const endpoint = new Endpoint({
+      route: '/users/:id',
+      method: 'PUT',
+      fn: async () => ({
+        id: '789',
+        email: 'updated@example.com',
+        isNew: false,
+      }),
+      input: undefined,
+      output: outputSchema,
+      services: [],
+      logger: mockLogger,
+      timeout: undefined,
+      status: 200,
+      getSession: undefined,
+      authorize: undefined,
+      description: undefined,
+      events,
+      publisherService: mockPublisherService,
+    });
+
+    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint as any);
+    const handler = adapter.handler;
+
+    const event = createMockV2Event({
+      requestContext: {
+        ...createMockV2Event().requestContext,
+        http: {
+          method: 'PUT',
+          path: '/users/789',
+          protocol: 'HTTP/1.1',
+          sourceIp: '192.168.1.1',
+          userAgent: 'test-agent',
+        },
+      },
+      pathParameters: { id: '789' },
+      body: JSON.stringify({}),
+    });
+    const context = createMockContext();
+    const response = await handler(event, context);
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toBe(
+      JSON.stringify({
+        id: '789',
+        email: 'updated@example.com',
+        isNew: false,
+      }),
+    );
+
+    // Only user.updated event should be published due to when condition
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.updated',
+        payload: { userId: '789', changes: ['email'] },
+      },
+    ]);
+  });
+
+  it('should not publish events when no publisher is configured', async () => {
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const events: MappedEvent<
+      EventPublisher<TestEvent>,
+      typeof outputSchema
+    >[] = [
+      {
+        type: 'user.created',
+        payload: (response) => ({ userId: response.id, email: response.email }),
+      },
+    ];
+
+    const endpoint = new Endpoint({
+      route: '/users',
+      method: 'POST',
+      fn: async () => ({ id: '999', email: 'test@example.com' }),
+      input: undefined,
+      output: outputSchema,
+      services: [],
+      logger: mockLogger,
+      timeout: undefined,
+      status: 200,
+      getSession: undefined,
+      authorize: undefined,
+      description: undefined,
+      events,
+      publisherService: undefined, // No publisher service
+    });
+
+    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint as any);
+    const handler = adapter.handler;
+
+    const event = createMockV2Event({
+      requestContext: {
+        ...createMockV2Event().requestContext,
+        http: {
+          method: 'POST',
+          path: '/users',
+          protocol: 'HTTP/1.1',
+          sourceIp: '192.168.1.1',
+          userAgent: 'test-agent',
+        },
+      },
+      body: JSON.stringify({}),
+    });
+    const context = createMockContext();
+    const response = await handler(event, context);
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toBe(
+      JSON.stringify({ id: '999', email: 'test@example.com' }),
+    );
+
+    // No publisher calls should be made
+    expect(mockLogger.warn).toHaveBeenCalledWith(
+      'No publisher service available',
+    );
+  });
+
+  it('should not publish events when no events are configured', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const endpoint = new Endpoint({
+      route: '/users',
+      method: 'POST',
+      fn: async () => ({ id: '111', email: 'test@example.com' }),
+      input: undefined,
+      output: outputSchema,
+      services: [],
+      logger: mockLogger,
+      timeout: undefined,
+      status: 200,
+      getSession: undefined,
+      authorize: undefined,
+      description: undefined,
+      events: undefined, // No events
+      publisherService: mockPublisherService,
+    });
+
+    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint as any);
+    const handler = adapter.handler;
+
+    const event = createMockV2Event({
+      requestContext: {
+        ...createMockV2Event().requestContext,
+        http: {
+          method: 'POST',
+          path: '/users',
+          protocol: 'HTTP/1.1',
+          sourceIp: '192.168.1.1',
+          userAgent: 'test-agent',
+        },
+      },
+      body: JSON.stringify({}),
+    });
+    const context = createMockContext();
+    const response = await handler(event, context);
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toBe(
+      JSON.stringify({ id: '111', email: 'test@example.com' }),
+    );
+
+    // No events should be published
+    expect(mockPublisher.publish).not.toHaveBeenCalled();
+    expect(mockLogger.debug).toHaveBeenCalledWith('No events to publish');
+  });
+
+  it('should continue processing even when event publishing fails', async () => {
+    const publishError = new Error('Event bus connection failed');
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockRejectedValue(publishError),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const events: MappedEvent<
+      EventPublisher<TestEvent>,
+      typeof outputSchema
+    >[] = [
+      {
+        type: 'user.created',
+        payload: (response) => ({ userId: response.id, email: response.email }),
+      },
+    ];
+
+    const endpoint = new Endpoint({
+      route: '/users',
+      method: 'POST',
+      fn: async () => ({ id: '888', email: 'error@example.com' }),
+      input: undefined,
+      output: outputSchema,
+      services: [],
+      logger: mockLogger,
+      timeout: undefined,
+      status: 200,
+      getSession: undefined,
+      authorize: undefined,
+      description: undefined,
+      events,
+      publisherService: mockPublisherService,
+    });
+
+    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint as any);
+    const handler = adapter.handler;
+
+    const event = createMockV2Event({
+      requestContext: {
+        ...createMockV2Event().requestContext,
+        http: {
+          method: 'POST',
+          path: '/users',
+          protocol: 'HTTP/1.1',
+          sourceIp: '192.168.1.1',
+          userAgent: 'test-agent',
+        },
+      },
+      body: JSON.stringify({}),
+    });
+    const context = createMockContext();
+    const response = await handler(event, context);
+
+    // The endpoint should still succeed despite event publishing failure
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toBe(
+      JSON.stringify({ id: '888', email: 'error@example.com' }),
+    );
+
+    expect(mockPublisher.publish).toHaveBeenCalled();
+    expect(mockLogger.error).toHaveBeenCalledWith(
+      publishError,
+      'Failed to publish events',
+    );
+  });
+
+  it('should publish events with input data context', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const bodySchema = z.object({ name: z.string(), email: z.string() });
+    const outputSchema = z.object({
+      id: z.string(),
+      name: z.string(),
+      email: z.string(),
+    });
+
+    const events: MappedEvent<
+      EventPublisher<TestEvent>,
+      typeof outputSchema
+    >[] = [
+      {
+        type: 'user.created',
+        payload: (response) => ({ userId: response.id, email: response.email }),
+      },
+    ];
+
+    const endpoint = new Endpoint({
+      route: '/users',
+      method: 'POST',
+      fn: async ({ body }) => ({
+        id: '777',
+        name: body.name,
+        email: body.email,
+      }),
+      input: { body: bodySchema },
+      output: outputSchema,
+      services: [],
+      logger: mockLogger,
+      timeout: undefined,
+      status: 201,
+      getSession: undefined,
+      authorize: undefined,
+      description: undefined,
+      events,
+      publisherService: mockPublisherService,
+    });
+
+    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint as any);
+    const handler = adapter.handler;
+
+    const event = createMockV2Event({
+      requestContext: {
+        ...createMockV2Event().requestContext,
+        http: {
+          method: 'POST',
+          path: '/users',
+          protocol: 'HTTP/1.1',
+          sourceIp: '192.168.1.1',
+          userAgent: 'test-agent',
+        },
+      },
+      body: JSON.stringify({ name: 'John Doe', email: 'john@example.com' }),
+    });
+    const context = createMockContext();
+    const response = await handler(event, context);
+
+    expect(response.statusCode).toBe(201);
+    expect(response.body).toBe(
+      JSON.stringify({
+        id: '777',
+        name: 'John Doe',
+        email: 'john@example.com',
+      }),
+    );
+
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.created',
+        payload: { userId: '777', email: 'john@example.com' },
+      },
+    ]);
+  });
+
+  it('should not publish events when handler throws an error', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const outputSchema = z.object({ id: z.string(), email: z.string() });
+
+    const events: MappedEvent<
+      EventPublisher<TestEvent>,
+      typeof outputSchema
+    >[] = [
+      {
+        type: 'user.created',
+        payload: (response) => ({ userId: response.id, email: response.email }),
+      },
+    ];
+
+    const endpoint = new Endpoint({
+      route: '/users',
+      method: 'POST',
+      fn: async () => {
+        throw new Error('Database connection failed');
+      },
+      input: undefined,
+      output: outputSchema,
+      services: [],
+      logger: mockLogger,
+      timeout: undefined,
+      status: 200,
+      getSession: undefined,
+      authorize: undefined,
+      description: undefined,
+      events,
+      publisherService: mockPublisherService,
+    });
+
+    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint as any);
+    const handler = adapter.handler;
+
+    const event = createMockV2Event({
+      requestContext: {
+        ...createMockV2Event().requestContext,
+        http: {
+          method: 'POST',
+          path: '/users',
+          protocol: 'HTTP/1.1',
+          sourceIp: '192.168.1.1',
+          userAgent: 'test-agent',
+        },
+      },
+      body: JSON.stringify({}),
+    });
+    const context = createMockContext();
+    const response = await handler(event, context);
+
+    // The endpoint should return an error response
+    expect(response.statusCode).toBe(500);
+
+    // Events should not be published when handler fails
+    expect(mockPublisher.publish).not.toHaveBeenCalled();
+  });
+
+  it('should handle comma-separated array query parameters', async () => {
+    const mockPublisher: EventPublisher<TestEvent> = {
+      publish: vi.fn().mockResolvedValue(undefined),
+    };
+
+    const mockPublisherService: Service<string, EventPublisher<TestEvent>> = {
+      serviceName: Math.random().toString(),
+      register: vi.fn().mockResolvedValue(mockPublisher),
+    };
+
+    const querySchema = z.object({
+      tags: z.array(z.string()),
+    });
+    const outputSchema = z.object({
+      id: z.string(),
+      tags: z.array(z.string()),
+    });
+
+    const events: MappedEvent<
+      EventPublisher<TestEvent>,
+      typeof outputSchema
+    >[] = [
+      {
+        type: 'user.updated',
+        payload: (response) => ({
+          userId: response.id,
+          changes: response.tags.map((tag) => `tag:${tag}`),
+        }),
+      },
+    ];
+
+    const endpoint = new Endpoint({
+      route: '/users/:id/tags',
+      method: 'PUT',
+      fn: async ({ query }) => ({
+        id: '123',
+        tags: query.tags,
+      }),
+      input: { query: querySchema },
+      output: outputSchema,
+      services: [],
+      logger: mockLogger,
+      timeout: undefined,
+      status: 200,
+      getSession: undefined,
+      authorize: undefined,
+      description: undefined,
+      events,
+      publisherService: mockPublisherService,
+    });
+
+    const adapter = new AmazonApiGatewayV2Endpoint(envParser, endpoint as any);
+    const handler = adapter.handler;
+
+    const event = createMockV2Event({
+      requestContext: {
+        ...createMockV2Event().requestContext,
+        http: {
+          method: 'PUT',
+          path: '/users/123/tags',
+          protocol: 'HTTP/1.1',
+          sourceIp: '192.168.1.1',
+          userAgent: 'test-agent',
+        },
+      },
+      pathParameters: { id: '123' },
+      queryStringParameters: {
+        tags: 'javascript, typescript, nodejs', // V2 handles arrays as comma-separated
+      },
+    });
+    const context = createMockContext();
+    const response = await handler(event, context);
+
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toBe(
+      JSON.stringify({
+        id: '123',
+        tags: ['javascript', 'typescript', 'nodejs'],
+      }),
+    );
+
+    expect(mockPublisher.publish).toHaveBeenCalledWith([
+      {
+        type: 'user.updated',
+        payload: {
+          userId: '123',
+          changes: ['tag:javascript', 'tag:typescript', 'tag:nodejs'],
+        },
+      },
+    ]);
+  });
+});