@geekmidas/constructs 0.0.6 → 0.0.9

package/src/endpoints/TestEndpointAdaptor.ts

@@ -14,12 +14,55 @@ import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { publishConstructEvents } from '../publisher';
 import type { HttpMethod } from '../types';
 import {
+  type CookieOptions,
   Endpoint,
   type EndpointSchemas,
   ResponseBuilder,
-  type ResponseWithMetadata,
 } from './Endpoint';
 
+export type TestHttpResponse<TBody = any> = {
+  body: TBody;
+  status: number;
+  headers: Record<string, string | string[]>;
+};
+
+/**
+ * Serializes a cookie into a Set-Cookie header string
+ */
+function serializeCookie(
+  name: string,
+  value: string,
+  options?: CookieOptions,
+): string {
+  let cookieString = `${name}=${value}`;
+
+  if (options) {
+    if (options.maxAge !== undefined) {
+      cookieString += `; Max-Age=${options.maxAge}`;
+    }
+    if (options.expires) {
+      cookieString += `; Expires=${options.expires.toUTCString()}`;
+    }
+    if (options.domain) {
+      cookieString += `; Domain=${options.domain}`;
+    }
+    if (options.path) {
+      cookieString += `; Path=${options.path}`;
+    }
+    if (options.httpOnly) {
+      cookieString += '; HttpOnly';
+    }
+    if (options.secure) {
+      cookieString += '; Secure';
+    }
+    if (options.sameSite) {
+      cookieString += `; SameSite=${options.sameSite}`;
+    }
+  }
+
+  return cookieString;
+}
+
 export class TestEndpointAdaptor<
   TRoute extends string,
   TMethod extends HttpMethod,
@@ -77,17 +120,14 @@ export class TestEndpointAdaptor<
     > = TestEndpointAdaptor.getDefaultServiceDiscover(endpoint),
   ) {}
 
-  async request(
+  async fullRequest(
     ctx: TestRequestAdaptor<
       TInput,
       TServices,
       TEventPublisher,
       TEventPublisherServiceName
     >,
-  ): Promise<
-    | InferStandardSchema<TOutSchema>
-    | ResponseWithMetadata<InferStandardSchema<TOutSchema>>
-  > {
+  ): Promise<TestHttpResponse<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(
@@ -138,16 +178,37 @@ export class TestEndpointAdaptor<
 
     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 };
+    // Convert cookies to Set-Cookie headers
+    const headers: Record<string, string | string[]> = {
+      ...(metadata.headers || {}),
+    };
+
+    if (metadata.cookies && metadata.cookies.size > 0) {
+      const setCookieValues: string[] = [];
+      for (const [name, cookie] of metadata.cookies.entries()) {
+        setCookieValues.push(serializeCookie(name, cookie.value, cookie.options));
+      }
+      headers['set-cookie'] = setCookieValues;
     }
 
-    return output;
+    // Return HTTP response format
+    return {
+      body: output,
+      status: metadata.status || 200,
+      headers,
+    };
+  }
+
+  async request(
+    ctx: TestRequestAdaptor<
+      TInput,
+      TServices,
+      TEventPublisher,
+      TEventPublisherServiceName
+    >,
+  ): Promise<InferStandardSchema<TOutSchema>> {
+    const response = await this.fullRequest(ctx);
+    return response.body;
   }
 }
 

package/src/endpoints/__tests__/Endpoint.cookies.spec.ts

@@ -117,4 +117,89 @@ describe('Endpoint.createCookies', () => {
     expect(cookieFn('_ga')).toBe('GA1.2.123456789.1234567890');
     expect(cookieFn('authenticated')).toBe('true');
   });
+
+  describe('cookie() - get all cookies', () => {
+    it('should return all cookies as object when called without arguments', () => {
+      const cookieFn = Endpoint.createCookies(
+        'session=abc123; theme=dark; lang=en',
+      );
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        session: 'abc123',
+        theme: 'dark',
+        lang: 'en',
+      });
+    });
+
+    it('should return empty object when no cookies exist', () => {
+      const cookieFn = Endpoint.createCookies(undefined);
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({});
+    });
+
+    it('should return empty object for empty cookie string', () => {
+      const cookieFn = Endpoint.createCookies('');
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({});
+    });
+
+    it('should decode URL-encoded values in all cookies', () => {
+      const cookieFn = Endpoint.createCookies(
+        'user=John%20Doe; email=john%40example.com',
+      );
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        user: 'John Doe',
+        email: 'john@example.com',
+      });
+    });
+
+    it('should preserve case in cookie names when getting all', () => {
+      const cookieFn = Endpoint.createCookies('Session=abc; session=xyz; TOKEN=123');
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        Session: 'abc',
+        session: 'xyz',
+        TOKEN: '123',
+      });
+    });
+
+    it('should handle cookies with equals sign in values', () => {
+      const cookieFn = Endpoint.createCookies(
+        'data=key=value; token=abc=123=xyz',
+      );
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        data: 'key=value',
+        token: 'abc=123=xyz',
+      });
+    });
+
+    it('should work with complex real-world cookie string', () => {
+      const cookieFn = Endpoint.createCookies(
+        'session=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9; user_id=12345; preferences=%7B%22theme%22%3A%22dark%22%7D; authenticated=true',
+      );
+
+      const allCookies = cookieFn();
+
+      expect(allCookies).toEqual({
+        session: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
+        user_id: '12345',
+        preferences: '{"theme":"dark"}',
+        authenticated: 'true',
+      });
+    });
+  });
 });

package/src/endpoints/__tests__/Endpoint.headers.spec.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it } from 'vitest';
+import { Endpoint } from '../Endpoint';
+
+describe('Endpoint.createHeaders', () => {
+  it('should get single header value', () => {
+    const headerFn = Endpoint.createHeaders({
+      'Content-Type': 'application/json',
+      Host: 'example.com',
+    });
+
+    expect(headerFn('content-type')).toBe('application/json');
+    expect(headerFn('host')).toBe('example.com');
+  });
+
+  it('should be case-insensitive for header names', () => {
+    const headerFn = Endpoint.createHeaders({
+      'Content-Type': 'application/json',
+    });
+
+    expect(headerFn('content-type')).toBe('application/json');
+    expect(headerFn('Content-Type')).toBe('application/json');
+    expect(headerFn('CONTENT-TYPE')).toBe('application/json');
+    expect(headerFn('CoNtEnT-tYpE')).toBe('application/json');
+  });
+
+  it('should return undefined for non-existent header', () => {
+    const headerFn = Endpoint.createHeaders({
+      'Content-Type': 'application/json',
+    });
+
+    expect(headerFn('Authorization')).toBeUndefined();
+  });
+
+  it('should handle empty headers object', () => {
+    const headerFn = Endpoint.createHeaders({});
+
+    expect(headerFn('Content-Type')).toBeUndefined();
+  });
+
+  it('should handle headers with special characters', () => {
+    const headerFn = Endpoint.createHeaders({
+      'X-Custom-Header': 'value-with-dashes',
+      'X-Request-ID': '12345-67890-abcdef',
+    });
+
+    expect(headerFn('x-custom-header')).toBe('value-with-dashes');
+    expect(headerFn('X-REQUEST-ID')).toBe('12345-67890-abcdef');
+  });
+
+  it('should handle standard HTTP headers', () => {
+    const headerFn = Endpoint.createHeaders({
+      'Content-Type': 'application/json',
+      'Content-Length': '1234',
+      Authorization: 'Bearer token123',
+      'User-Agent': 'Mozilla/5.0',
+      Accept: 'application/json',
+      'Accept-Language': 'en-US,en;q=0.9',
+      'Cache-Control': 'no-cache',
+    });
+
+    expect(headerFn('content-type')).toBe('application/json');
+    expect(headerFn('content-length')).toBe('1234');
+    expect(headerFn('authorization')).toBe('Bearer token123');
+    expect(headerFn('user-agent')).toBe('Mozilla/5.0');
+    expect(headerFn('accept')).toBe('application/json');
+    expect(headerFn('accept-language')).toBe('en-US,en;q=0.9');
+    expect(headerFn('cache-control')).toBe('no-cache');
+  });
+
+  it('should handle forwarded headers', () => {
+    const headerFn = Endpoint.createHeaders({
+      'X-Forwarded-For': '203.0.113.1',
+      'X-Forwarded-Proto': 'https',
+      'X-Real-IP': '203.0.113.1',
+    });
+
+    expect(headerFn('x-forwarded-for')).toBe('203.0.113.1');
+    expect(headerFn('x-forwarded-proto')).toBe('https');
+    expect(headerFn('x-real-ip')).toBe('203.0.113.1');
+  });
+
+  describe('header() - get all headers', () => {
+    it('should return all headers as object when called without arguments', () => {
+      const headerFn = Endpoint.createHeaders({
+        'Content-Type': 'application/json',
+        Host: 'example.com',
+        Authorization: 'Bearer token123',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({
+        'content-type': 'application/json',
+        host: 'example.com',
+        authorization: 'Bearer token123',
+      });
+    });
+
+    it('should return empty object when no headers exist', () => {
+      const headerFn = Endpoint.createHeaders({});
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({});
+    });
+
+    it('should normalize all header names to lowercase', () => {
+      const headerFn = Endpoint.createHeaders({
+        'Content-Type': 'application/json',
+        HOST: 'example.com',
+        'X-Custom-Header': 'value',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({
+        'content-type': 'application/json',
+        host: 'example.com',
+        'x-custom-header': 'value',
+      });
+    });
+
+    it('should work with standard HTTP headers', () => {
+      const headerFn = Endpoint.createHeaders({
+        'Content-Type': 'application/json',
+        'Content-Length': '1234',
+        Authorization: 'Bearer token123',
+        'User-Agent': 'Mozilla/5.0',
+        Accept: 'application/json',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({
+        'content-type': 'application/json',
+        'content-length': '1234',
+        authorization: 'Bearer token123',
+        'user-agent': 'Mozilla/5.0',
+        accept: 'application/json',
+      });
+    });
+
+    it('should work with custom and forwarded headers', () => {
+      const headerFn = Endpoint.createHeaders({
+        'X-Forwarded-For': '203.0.113.1',
+        'X-Forwarded-Proto': 'https',
+        'X-Request-ID': 'req-123',
+        'X-Custom-Header': 'custom-value',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toEqual({
+        'x-forwarded-for': '203.0.113.1',
+        'x-forwarded-proto': 'https',
+        'x-request-id': 'req-123',
+        'x-custom-header': 'custom-value',
+      });
+    });
+
+    it('should handle complex real-world headers', () => {
+      const headerFn = Endpoint.createHeaders({
+        'Content-Type': 'application/json; charset=utf-8',
+        Host: 'api.example.com',
+        Connection: 'keep-alive',
+        'User-Agent':
+          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        Accept: '*/*',
+        'Accept-Encoding': 'gzip, deflate, br',
+        'Accept-Language': 'en-US,en;q=0.9',
+        Authorization: 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
+        'Cache-Control': 'no-cache',
+        Origin: 'https://example.com',
+        Referer: 'https://example.com/dashboard',
+        'X-Requested-With': 'XMLHttpRequest',
+      });
+
+      const allHeaders = headerFn();
+
+      expect(allHeaders).toHaveProperty('content-type');
+      expect(allHeaders).toHaveProperty('host');
+      expect(allHeaders).toHaveProperty('authorization');
+      expect(allHeaders).toHaveProperty('user-agent');
+      expect(Object.keys(allHeaders).length).toBe(12);
+    });
+  });
+});

package/src/endpoints/__tests__/Endpoint.manifest.spec.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it } from 'vitest';
+import { Endpoint } from '../Endpoint';
+import { SuccessStatus } from '../Endpoint';
+import { z } from 'zod';
+
+describe('Endpoint manifest fields', () => {
+  it('should store timeout and memorySize', () => {
+    const endpoint = new Endpoint({
+      route: '/users/:id',
+      method: 'GET',
+      fn: async () => ({ id: '123' }),
+      authorize: undefined,
+      description: 'Get user by ID',
+      timeout: 30000,
+      memorySize: 512,
+      input: undefined,
+      output: undefined,
+      services: [],
+      logger: {} as any,
+      getSession: undefined,
+      rateLimit: undefined,
+      status: SuccessStatus.OK,
+    });
+
+    expect(endpoint.timeout).toBe(30000);
+    expect(endpoint.memorySize).toBe(512);
+  });
+
+  it('should store authorizer information', () => {
+    const endpoint = new Endpoint({
+      route: '/admin/users',
+      method: 'POST',
+      fn: async () => ({ success: true }),
+      authorize: undefined,
+      description: 'Create admin user',
+      timeout: undefined,
+      memorySize: undefined,
+      input: undefined,
+      output: undefined,
+      services: [],
+      logger: {} as any,
+      getSession: undefined,
+      rateLimit: undefined,
+      status: SuccessStatus.Created,
+      authorizer: {
+        name: 'iam',
+        type: 'AWS_IAM',
+        description: 'IAM-based authorizer',
+      },
+    });
+
+    expect(endpoint.authorizer).toEqual({
+      name: 'iam',
+      type: 'AWS_IAM',
+      description: 'IAM-based authorizer',
+    });
+  });
+
+  it('should have undefined authorizer when not provided', () => {
+    const endpoint = new Endpoint({
+      route: '/public',
+      method: 'GET',
+      fn: async () => ({ data: 'public' }),
+      authorize: undefined,
+      description: 'Public endpoint',
+      timeout: undefined,
+      memorySize: undefined,
+      input: undefined,
+      output: undefined,
+      services: [],
+      logger: {} as any,
+      getSession: undefined,
+      rateLimit: undefined,
+      status: SuccessStatus.OK,
+    });
+
+    expect(endpoint.authorizer).toBeUndefined();
+  });
+
+  it('should store all manifest fields together', () => {
+    const bodySchema = z.object({ name: z.string() });
+    const outputSchema = z.object({ id: z.string(), name: z.string() });
+
+    const endpoint = new Endpoint({
+      route: '/api/v1/users',
+      method: 'POST',
+      fn: async () => ({ id: '123', name: 'Test User' }),
+      authorize: undefined,
+      description: 'Create a new user',
+      tags: ['users', 'admin'],
+      timeout: 15000,
+      memorySize: 256,
+      input: { body: bodySchema },
+      output: outputSchema,
+      services: [],
+      logger: {} as any,
+      getSession: undefined,
+      rateLimit: undefined,
+      status: SuccessStatus.Created,
+      authorizer: {
+        name: 'jwt-auth0',
+        type: 'JWT',
+        description: 'Auth0 JWT authorizer',
+        metadata: {
+          audience: 'https://api.example.com',
+          issuer: 'https://example.auth0.com/',
+        },
+      },
+    });
+
+    expect(endpoint.route).toBe('/api/v1/users');
+    expect(endpoint.method).toBe('POST');
+    expect(endpoint.description).toBe('Create a new user');
+    expect(endpoint.tags).toEqual(['users', 'admin']);
+    expect(endpoint.timeout).toBe(15000);
+    expect(endpoint.memorySize).toBe(256);
+    expect(endpoint.status).toBe(SuccessStatus.Created);
+    expect(endpoint.authorizer).toEqual({
+      name: 'jwt-auth0',
+      type: 'JWT',
+      description: 'Auth0 JWT authorizer',
+      metadata: {
+        audience: 'https://api.example.com',
+        issuer: 'https://example.auth0.com/',
+      },
+    });
+  });
+
+  it('should preserve authorizer metadata with minimal fields', () => {
+    const endpoint = new Endpoint({
+      route: '/protected',
+      method: 'GET',
+      fn: async () => ({ data: 'secret' }),
+      authorize: undefined,
+      description: undefined,
+      timeout: undefined,
+      memorySize: undefined,
+      input: undefined,
+      output: undefined,
+      services: [],
+      logger: {} as any,
+      getSession: undefined,
+      rateLimit: undefined,
+      status: SuccessStatus.OK,
+      authorizer: {
+        name: 'custom',
+      },
+    });
+
+    expect(endpoint.authorizer).toEqual({ name: 'custom' });
+  });
+
+  it('should handle default timeout and memorySize values', () => {
+    const endpoint = new Endpoint({
+      route: '/default',
+      method: 'GET',
+      fn: async () => ({ data: 'default' }),
+      authorize: undefined,
+      description: undefined,
+      timeout: undefined,
+      memorySize: undefined,
+      input: undefined,
+      output: undefined,
+      services: [],
+      logger: {} as any,
+      getSession: undefined,
+      rateLimit: undefined,
+      status: SuccessStatus.OK,
+    });
+
+    // Default timeout is 30000ms (30 seconds)
+    expect(endpoint.timeout).toBe(30000);
+    // Default memorySize is undefined
+    expect(endpoint.memorySize).toBeUndefined();
+  });
+});