@geekmidas/constructs 0.0.2 → 0.0.4

package/src/endpoints/TestEndpointAdaptor.ts

@@ -13,7 +13,12 @@ import {
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { publishConstructEvents } from '../publisher';
 import type { HttpMethod } from '../types';
-import { Endpoint, type EndpointSchemas } from './Endpoint';
+import {
+  Endpoint,
+  type EndpointSchemas,
+  ResponseBuilder,
+  type ResponseWithMetadata,
+} from './Endpoint';
 
 export class TestEndpointAdaptor<
   TRoute extends string,
@@ -79,7 +84,10 @@ export class TestEndpointAdaptor<
       TEventPublisher,
       TEventPublisherServiceName
     >,
-  ): Promise<InferStandardSchema<TOutSchema>> {
+  ): Promise<
+    | InferStandardSchema<TOutSchema>
+    | ResponseWithMetadata<InferStandardSchema<TOutSchema>>
+  > {
     const body = await this.endpoint.parseInput((ctx as any).body, 'body');
     const query = await this.endpoint.parseInput((ctx as any).query, 'query');
     const params = await this.endpoint.parseInput(
@@ -88,6 +96,7 @@ export class TestEndpointAdaptor<
     );
 
     const header = Endpoint.createHeaders(ctx.headers);
+    const cookie = Endpoint.createCookies(ctx.headers.cookie);
     const logger = this.endpoint.logger.child({
       route: this.endpoint.route,
       host: ctx.headers.host,
@@ -97,23 +106,47 @@ export class TestEndpointAdaptor<
       logger,
       services: ctx.services,
       header,
+      cookie,
     });
 
-    const response = await this.endpoint.handler({
-      body,
-      query,
-      params,
-      session,
-      services: ctx.services,
-      logger,
-      header,
-    } as any);
+    const responseBuilder = new ResponseBuilder();
+    const response = await this.endpoint.handler(
+      {
+        body,
+        query,
+        params,
+        session,
+        services: ctx.services,
+        logger,
+        header,
+        cookie,
+      } as any,
+      responseBuilder,
+    );
+
+    // Check if response has metadata
+    let data = response;
+    let metadata = responseBuilder.getMetadata();
 
-    const output = await this.endpoint.parseOutput(response);
+    if (Endpoint.hasMetadata(response)) {
+      data = response.data;
+      metadata = response.metadata;
+    }
+
+    const output = await this.endpoint.parseOutput(data);
     ctx.publisher && (await this.serviceDiscovery.register([ctx.publisher]));
 
     await publishConstructEvents(this.endpoint, output, this.serviceDiscovery);
 
+    // Return with metadata if any was set
+    if (
+      (metadata.headers && Object.keys(metadata.headers).length > 0) ||
+      (metadata.cookies && metadata.cookies.size > 0) ||
+      metadata.status
+    ) {
+      return { data: output, metadata };
+    }
+
     return output;
   }
 }

package/src/endpoints/__tests__/AmazonApiGatewayV1EndpointAdaptor.spec.ts

@@ -924,4 +924,244 @@ describe('AmazonApiGatewayV1Endpoint', () => {
       );
     });
   });
+
+  describe('response metadata', () => {
+    it('should set response cookies', async () => {
+      const endpoint = new Endpoint({
+        route: '/test',
+        method: 'GET',
+        fn: async (_, response) => {
+          response.cookie('session', 'abc123', {
+            httpOnly: true,
+            secure: true,
+          });
+          return { success: true };
+        },
+        input: {},
+        output: z.object({ success: z.boolean() }),
+        services: [],
+        logger: mockLogger,
+        timeout: undefined,
+        status: undefined,
+        getSession: undefined,
+        authorize: undefined,
+        description: 'Test endpoint',
+      });
+
+      const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+      const handler = adapter.handler;
+
+      const event = createMockV1Event();
+      const context = createMockContext();
+      const response = await handler(event, context);
+
+      expect(response.multiValueHeaders?.['Set-Cookie']).toEqual([
+        'session=abc123; HttpOnly; Secure',
+      ]);
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toBe(JSON.stringify({ success: true }));
+    });
+
+    it('should set custom headers', async () => {
+      const endpoint = new Endpoint({
+        route: '/test',
+        method: 'GET',
+        fn: async (_, response) => {
+          response.header('X-Custom-Header', 'custom-value');
+          response.header('X-Request-Id', '12345');
+          return { success: true };
+        },
+        input: {},
+        output: z.object({ success: z.boolean() }),
+        services: [],
+        logger: mockLogger,
+        timeout: undefined,
+        status: undefined,
+        getSession: undefined,
+        authorize: undefined,
+        description: 'Test endpoint',
+      });
+
+      const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+      const handler = adapter.handler;
+
+      const event = createMockV1Event();
+      const context = createMockContext();
+      const response = await handler(event, context);
+
+      expect(response.headers).toEqual({
+        'X-Custom-Header': 'custom-value',
+        'X-Request-Id': '12345',
+      });
+    });
+
+    it('should set custom status code', async () => {
+      const endpoint = new Endpoint({
+        route: '/test',
+        method: 'POST',
+        fn: async (_, response) => {
+          response.status(201);
+          return { id: '123' };
+        },
+        input: {},
+        output: z.object({ id: z.string() }),
+        services: [],
+        logger: mockLogger,
+        timeout: undefined,
+        status: undefined,
+        getSession: undefined,
+        authorize: undefined,
+        description: 'Test endpoint',
+      });
+
+      const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+      const handler = adapter.handler;
+
+      const event = createMockV1Event({ httpMethod: 'POST' });
+      const context = createMockContext();
+      const response = await handler(event, context);
+
+      expect(response.statusCode).toBe(201);
+    });
+
+    it('should combine cookies, headers, and status', async () => {
+      const endpoint = new Endpoint({
+        route: '/test',
+        method: 'POST',
+        fn: async (_, response) => {
+          response
+            .status(201)
+            .header('Location', '/test/123')
+            .cookie('session', 'abc123', { httpOnly: true })
+            .cookie('theme', 'dark');
+          return { id: '123' };
+        },
+        input: {},
+        output: z.object({ id: z.string() }),
+        services: [],
+        logger: mockLogger,
+        timeout: undefined,
+        status: undefined,
+        getSession: undefined,
+        authorize: undefined,
+        description: 'Test endpoint',
+      });
+
+      const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+      const handler = adapter.handler;
+
+      const event = createMockV1Event({ httpMethod: 'POST' });
+      const context = createMockContext();
+      const response = await handler(event, context);
+
+      expect(response.statusCode).toBe(201);
+      expect(response.headers).toEqual({ Location: '/test/123' });
+      expect(response.multiValueHeaders?.['Set-Cookie']).toEqual([
+        'session=abc123; HttpOnly',
+        'theme=dark',
+      ]);
+    });
+
+    it('should delete cookies', async () => {
+      const endpoint = new Endpoint({
+        route: '/test',
+        method: 'GET',
+        fn: async (_, response) => {
+          response.deleteCookie('session', {
+            path: '/',
+            domain: '.example.com',
+          });
+          return { success: true };
+        },
+        input: {},
+        output: z.object({ success: z.boolean() }),
+        services: [],
+        logger: mockLogger,
+        timeout: undefined,
+        status: undefined,
+        getSession: undefined,
+        authorize: undefined,
+        description: 'Test endpoint',
+      });
+
+      const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+      const handler = adapter.handler;
+
+      const event = createMockV1Event();
+      const context = createMockContext();
+      const response = await handler(event, context);
+
+      expect(response.multiValueHeaders?.['Set-Cookie']).toEqual([
+        'session=; Domain=.example.com; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0',
+      ]);
+    });
+
+    it('should use send() method with metadata', async () => {
+      const endpoint = new Endpoint({
+        route: '/test',
+        method: 'GET',
+        fn: async (_, response) => {
+          return response
+            .status(201)
+            .header('X-Custom', 'value')
+            .cookie('session', 'abc123')
+            .send({ id: '123' });
+        },
+        input: {},
+        output: z.object({ id: z.string() }),
+        services: [],
+        logger: mockLogger,
+        timeout: undefined,
+        status: undefined,
+        getSession: undefined,
+        authorize: undefined,
+        description: 'Test endpoint',
+      });
+
+      const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+      const handler = adapter.handler;
+
+      const event = createMockV1Event();
+      const context = createMockContext();
+      const response = await handler(event, context);
+
+      expect(response.statusCode).toBe(201);
+      expect(response.headers).toEqual({ 'X-Custom': 'value' });
+      expect(response.multiValueHeaders?.['Set-Cookie']).toEqual([
+        'session=abc123',
+      ]);
+      expect(response.body).toBe(JSON.stringify({ id: '123' }));
+    });
+
+    it('should return simple response without metadata when not using response builder', async () => {
+      const endpoint = new Endpoint({
+        route: '/test',
+        method: 'GET',
+        fn: async () => ({ success: true }),
+        input: {},
+        output: z.object({ success: z.boolean() }),
+        services: [],
+        logger: mockLogger,
+        timeout: undefined,
+        status: undefined,
+        getSession: undefined,
+        authorize: undefined,
+        description: 'Test endpoint',
+      });
+
+      const adapter = new AmazonApiGatewayV1Endpoint(envParser, endpoint);
+      const handler = adapter.handler;
+
+      const event = createMockV1Event();
+      const context = createMockContext();
+      const response = await handler(event, context);
+
+      expect(response).toEqual({
+        statusCode: 200,
+        body: JSON.stringify({ success: true }),
+      });
+      expect(response.headers).toBeUndefined();
+      expect(response.multiValueHeaders).toBeUndefined();
+    });
+  });
 });