@geekmidas/constructs 0.3.1 → 0.5.0

package/src/endpoints/__tests__/endpoint-types.test.ts

@@ -3,86 +3,86 @@ import { z } from 'zod';
 import { e } from '../EndpointFactory';
 
 describe('Endpoint type inference', () => {
-  it('should not include body/params/query when not defined', () => {
-    const endpoint = e.get('/test').handle((ctx) => {
-      expectTypeOf(ctx).toHaveProperty('services');
-      expectTypeOf(ctx).toHaveProperty('logger');
-      expectTypeOf(ctx).toHaveProperty('header');
-      expectTypeOf(ctx).toHaveProperty('session');
+	it('should not include body/params/query when not defined', () => {
+		const _endpoint = e.get('/test').handle((ctx) => {
+			expectTypeOf(ctx).toHaveProperty('services');
+			expectTypeOf(ctx).toHaveProperty('logger');
+			expectTypeOf(ctx).toHaveProperty('header');
+			expectTypeOf(ctx).toHaveProperty('session');
 
-      // These should NOT exist
-      expectTypeOf(ctx).not.toHaveProperty('body');
-      expectTypeOf(ctx).not.toHaveProperty('params');
-      expectTypeOf(ctx).not.toHaveProperty('query');
+			// These should NOT exist
+			expectTypeOf(ctx).not.toHaveProperty('body');
+			expectTypeOf(ctx).not.toHaveProperty('params');
+			expectTypeOf(ctx).not.toHaveProperty('query');
 
-      return { success: true };
-    });
-  });
+			return { success: true };
+		});
+	});
 
-  it('should include body when defined', () => {
-    const endpoint = e
-      .post('/test')
-      .body(z.object({ name: z.string() }))
-      .handle((ctx) => {
-        expectTypeOf(ctx).toHaveProperty('body');
-        expectTypeOf(ctx.body).toEqualTypeOf<{ name: string }>();
+	it('should include body when defined', () => {
+		const _endpoint = e
+			.post('/test')
+			.body(z.object({ name: z.string() }))
+			.handle((ctx) => {
+				expectTypeOf(ctx).toHaveProperty('body');
+				expectTypeOf(ctx.body).toEqualTypeOf<{ name: string }>();
 
-        // These should NOT exist
-        expectTypeOf(ctx).not.toHaveProperty('params');
-        expectTypeOf(ctx).not.toHaveProperty('query');
+				// These should NOT exist
+				expectTypeOf(ctx).not.toHaveProperty('params');
+				expectTypeOf(ctx).not.toHaveProperty('query');
 
-        return { success: true };
-      });
-  });
+				return { success: true };
+			});
+	});
 
-  it('should include params when defined', () => {
-    const endpoint = e
-      .get('/test/:id')
-      .params(z.object({ id: z.string() }))
-      .handle((ctx) => {
-        expectTypeOf(ctx).toHaveProperty('params');
-        expectTypeOf(ctx.params).toEqualTypeOf<{ id: string }>();
+	it('should include params when defined', () => {
+		const _endpoint = e
+			.get('/test/:id')
+			.params(z.object({ id: z.string() }))
+			.handle((ctx) => {
+				expectTypeOf(ctx).toHaveProperty('params');
+				expectTypeOf(ctx.params).toEqualTypeOf<{ id: string }>();
 
-        // These should NOT exist
-        expectTypeOf(ctx).not.toHaveProperty('body');
-        expectTypeOf(ctx).not.toHaveProperty('query');
+				// These should NOT exist
+				expectTypeOf(ctx).not.toHaveProperty('body');
+				expectTypeOf(ctx).not.toHaveProperty('query');
 
-        return { success: true };
-      });
-  });
+				return { success: true };
+			});
+	});
 
-  it('should include query when defined', () => {
-    const endpoint = e
-      .get('/test')
-      .query(z.object({ filter: z.string() }))
-      .handle((ctx) => {
-        expectTypeOf(ctx).toHaveProperty('query');
-        expectTypeOf(ctx.query).toEqualTypeOf<{ filter: string }>();
+	it('should include query when defined', () => {
+		const _endpoint = e
+			.get('/test')
+			.query(z.object({ filter: z.string() }))
+			.handle((ctx) => {
+				expectTypeOf(ctx).toHaveProperty('query');
+				expectTypeOf(ctx.query).toEqualTypeOf<{ filter: string }>();
 
-        // These should NOT exist
-        expectTypeOf(ctx).not.toHaveProperty('body');
-        expectTypeOf(ctx).not.toHaveProperty('params');
+				// These should NOT exist
+				expectTypeOf(ctx).not.toHaveProperty('body');
+				expectTypeOf(ctx).not.toHaveProperty('params');
 
-        return { success: true };
-      });
-  });
+				return { success: true };
+			});
+	});
 
-  it('should include all properties when all are defined', () => {
-    const endpoint = e
-      .post('/test/:id')
-      .body(z.object({ name: z.string() }))
-      .params(z.object({ id: z.string() }))
-      .query(z.object({ filter: z.string() }))
-      .handle((ctx) => {
-        expectTypeOf(ctx).toHaveProperty('body');
-        expectTypeOf(ctx).toHaveProperty('params');
-        expectTypeOf(ctx).toHaveProperty('query');
+	it('should include all properties when all are defined', () => {
+		const _endpoint = e
+			.post('/test/:id')
+			.body(z.object({ name: z.string() }))
+			.params(z.object({ id: z.string() }))
+			.query(z.object({ filter: z.string() }))
+			.handle((ctx) => {
+				expectTypeOf(ctx).toHaveProperty('body');
+				expectTypeOf(ctx).toHaveProperty('params');
+				expectTypeOf(ctx).toHaveProperty('query');
 
-        expectTypeOf(ctx.body).toEqualTypeOf<{ name: string }>();
-        expectTypeOf(ctx.params).toEqualTypeOf<{ id: string }>();
-        expectTypeOf(ctx.query).toEqualTypeOf<{ filter: string }>();
+				expectTypeOf(ctx.body).toEqualTypeOf<{ name: string }>();
+				expectTypeOf(ctx.params).toEqualTypeOf<{ id: string }>();
+				expectTypeOf(ctx.query).toEqualTypeOf<{ filter: string }>();
 
-        return { success: true };
-      });
-  });
+				return { success: true };
+			});
+	});
 });

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

@@ -0,0 +1,37 @@
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { getProjectRoot } from '../helpers';
+
+describe('helpers', () => {
+	describe('getProjectRoot', () => {
+		it('should find project root from current directory', async () => {
+			const cwd = process.cwd();
+			const root = await getProjectRoot(cwd);
+			// Should find the toolbox root which has pnpm-lock.yaml
+			expect(root).toBe(cwd);
+		});
+
+		it('should find project root from nested directory', async () => {
+			const cwd = process.cwd();
+			const nested = path.join(cwd, 'packages', 'constructs', 'src');
+			const root = await getProjectRoot(nested);
+			// Should find the toolbox root
+			expect(root).toBe(cwd);
+		});
+
+		it('should return root when reaching filesystem root', async () => {
+			// This tests the base case - when we reach '/', return '/'
+			const root = await getProjectRoot('/');
+			expect(root).toBe('/');
+		});
+
+		it('should handle directory with no lock file', async () => {
+			// Create a temp directory path that definitely has no lock file
+			// It should traverse up until it finds one or reaches root
+			const tempPath = '/tmp/test-no-lock-file-12345';
+			const root = await getProjectRoot(tempPath);
+			// Should eventually reach '/' or find a project root
+			expect(typeof root).toBe('string');
+		});
+	});
+});

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

@@ -0,0 +1,330 @@
+import { describe, expect, it } from 'vitest';
+import {
+	createApiGatewayCookies,
+	createApiGatewayHeaders,
+	createCookieHeaderAccessor,
+	createNoopCookies,
+	createNoopHeaders,
+	createObjectHeaders,
+} from '../lazyAccessors';
+
+describe('lazyAccessors', () => {
+	describe('createApiGatewayHeaders', () => {
+		it('should return undefined for single key lookup with null headers', () => {
+			const header = createApiGatewayHeaders(null);
+			expect(header('content-type')).toBeUndefined();
+		});
+
+		it('should return undefined for single key lookup with undefined headers', () => {
+			const header = createApiGatewayHeaders(undefined);
+			expect(header('content-type')).toBeUndefined();
+		});
+
+		it('should return empty object for all headers when headers is null', () => {
+			const header = createApiGatewayHeaders(null);
+			expect(header()).toEqual({});
+		});
+
+		it('should return header value for direct key lookup', () => {
+			const header = createApiGatewayHeaders({
+				'content-type': 'application/json',
+				authorization: 'Bearer token',
+			});
+			expect(header('content-type')).toBe('application/json');
+			expect(header('authorization')).toBe('Bearer token');
+		});
+
+		it('should handle case-insensitive lookups', () => {
+			const header = createApiGatewayHeaders({
+				'Content-Type': 'application/json',
+			});
+			expect(header('content-type')).toBe('application/json');
+			expect(header('CONTENT-TYPE')).toBe('application/json');
+		});
+
+		it('should return all headers normalized to lowercase', () => {
+			const header = createApiGatewayHeaders({
+				'Content-Type': 'application/json',
+				Authorization: 'Bearer token',
+			});
+			const all = header();
+			expect(all).toEqual({
+				'content-type': 'application/json',
+				authorization: 'Bearer token',
+			});
+		});
+
+		it('should cache normalized headers', () => {
+			const headers = {
+				'Content-Type': 'application/json',
+			};
+			const header = createApiGatewayHeaders(headers);
+
+			// First call should normalize
+			const first = header();
+			// Second call should return cached
+			const second = header();
+
+			expect(first).toBe(second);
+		});
+
+		it('should skip undefined header values', () => {
+			const header = createApiGatewayHeaders({
+				'content-type': 'application/json',
+				'x-custom': undefined,
+			});
+			const all = header();
+			expect(all).toEqual({
+				'content-type': 'application/json',
+			});
+			expect(header('x-custom')).toBeUndefined();
+		});
+
+		it('should handle mixed case lookups with fallback to normalized', () => {
+			const header = createApiGatewayHeaders({
+				'X-Custom-Header': 'value',
+			});
+			// Direct lookup fails, fallback to normalized
+			expect(header('x-custom-header')).toBe('value');
+		});
+	});
+
+	describe('createApiGatewayCookies', () => {
+		it('should parse cookies from array format (API Gateway v2)', () => {
+			const cookie = createApiGatewayCookies(
+				['session=abc123', 'user=john'],
+				undefined,
+			);
+			expect(cookie('session')).toBe('abc123');
+			expect(cookie('user')).toBe('john');
+		});
+
+		it('should return all cookies when called without arguments', () => {
+			const cookie = createApiGatewayCookies(
+				['session=abc123', 'user=john'],
+				undefined,
+			);
+			expect(cookie()).toEqual({
+				session: 'abc123',
+				user: 'john',
+			});
+		});
+
+		it('should fall back to cookie header when cookies array is undefined', () => {
+			const cookie = createApiGatewayCookies(
+				undefined,
+				'session=abc123; user=john',
+			);
+			expect(cookie('session')).toBe('abc123');
+			expect(cookie('user')).toBe('john');
+		});
+
+		it('should decode URL-encoded values', () => {
+			const cookie = createApiGatewayCookies(
+				['name=John%20Doe', 'path=%2Fhome'],
+				undefined,
+			);
+			expect(cookie('name')).toBe('John Doe');
+			expect(cookie('path')).toBe('/home');
+		});
+
+		it('should decode URL-encoded values from cookie header', () => {
+			const cookie = createApiGatewayCookies(
+				undefined,
+				'name=John%20Doe; path=%2Fhome',
+			);
+			expect(cookie('name')).toBe('John Doe');
+			expect(cookie('path')).toBe('/home');
+		});
+
+		it('should return undefined for missing cookie', () => {
+			const cookie = createApiGatewayCookies(['session=abc123'], undefined);
+			expect(cookie('missing')).toBeUndefined();
+		});
+
+		it('should return empty object when no cookies present', () => {
+			const cookie = createApiGatewayCookies(undefined, undefined);
+			expect(cookie()).toEqual({});
+		});
+
+		it('should cache parsed cookies', () => {
+			const cookie = createApiGatewayCookies(['session=abc123'], undefined);
+			const first = cookie();
+			const second = cookie();
+			expect(first).toBe(second);
+		});
+
+		it('should skip malformed cookies in array', () => {
+			const cookie = createApiGatewayCookies(
+				['valid=value', 'malformed', '=nokey'],
+				undefined,
+			);
+			expect(cookie()).toEqual({
+				valid: 'value',
+			});
+		});
+
+		it('should skip malformed cookies in header', () => {
+			const cookie = createApiGatewayCookies(
+				undefined,
+				'valid=value; malformed; =nokey',
+			);
+			expect(cookie()).toEqual({
+				valid: 'value',
+			});
+		});
+	});
+
+	describe('createObjectHeaders', () => {
+		it('should return header value for direct lookup', () => {
+			const header = createObjectHeaders({
+				'content-type': 'application/json',
+			});
+			expect(header('content-type')).toBe('application/json');
+		});
+
+		it('should handle case-insensitive lookups', () => {
+			const header = createObjectHeaders({
+				'Content-Type': 'application/json',
+			});
+			expect(header('content-type')).toBe('application/json');
+			expect(header('CONTENT-TYPE')).toBe('application/json');
+		});
+
+		it('should return all headers when called without arguments', () => {
+			const header = createObjectHeaders({
+				'Content-Type': 'application/json',
+				Authorization: 'Bearer token',
+			});
+			expect(header()).toEqual({
+				'content-type': 'application/json',
+				authorization: 'Bearer token',
+			});
+		});
+
+		it('should return undefined for missing header', () => {
+			const header = createObjectHeaders({
+				'content-type': 'application/json',
+			});
+			expect(header('missing')).toBeUndefined();
+		});
+
+		it('should return empty object for undefined headers', () => {
+			const header = createObjectHeaders(undefined);
+			expect(header()).toEqual({});
+		});
+
+		it('should return undefined for key lookup with undefined headers', () => {
+			const header = createObjectHeaders(undefined);
+			expect(header('content-type')).toBeUndefined();
+		});
+
+		it('should cache normalized headers', () => {
+			const header = createObjectHeaders({
+				'Content-Type': 'application/json',
+			});
+			const first = header();
+			const second = header();
+			expect(first).toBe(second);
+		});
+
+		it('should normalize headers on single key lookup that requires fallback', () => {
+			const header = createObjectHeaders({
+				'X-Custom': 'value',
+			});
+			// First lookup triggers normalization
+			expect(header('x-custom')).toBe('value');
+			// Subsequent lookups use cached normalized version
+			expect(header('X-CUSTOM')).toBe('value');
+		});
+	});
+
+	describe('createCookieHeaderAccessor', () => {
+		it('should parse cookies from header string', () => {
+			const cookie = createCookieHeaderAccessor('session=abc123; user=john');
+			expect(cookie('session')).toBe('abc123');
+			expect(cookie('user')).toBe('john');
+		});
+
+		it('should return all cookies when called without arguments', () => {
+			const cookie = createCookieHeaderAccessor('session=abc123; user=john');
+			expect(cookie()).toEqual({
+				session: 'abc123',
+				user: 'john',
+			});
+		});
+
+		it('should decode URL-encoded values', () => {
+			const cookie = createCookieHeaderAccessor(
+				'name=John%20Doe; path=%2Fhome',
+			);
+			expect(cookie('name')).toBe('John Doe');
+			expect(cookie('path')).toBe('/home');
+		});
+
+		it('should return undefined for missing cookie', () => {
+			const cookie = createCookieHeaderAccessor('session=abc123');
+			expect(cookie('missing')).toBeUndefined();
+		});
+
+		it('should return empty object for undefined cookie header', () => {
+			const cookie = createCookieHeaderAccessor(undefined);
+			expect(cookie()).toEqual({});
+		});
+
+		it('should cache parsed cookies', () => {
+			const cookie = createCookieHeaderAccessor('session=abc123');
+			const first = cookie();
+			const second = cookie();
+			expect(first).toBe(second);
+		});
+
+		it('should skip malformed cookies', () => {
+			const cookie = createCookieHeaderAccessor(
+				'valid=value; malformed; =nokey',
+			);
+			expect(cookie()).toEqual({
+				valid: 'value',
+			});
+		});
+
+		it('should handle cookies with equals signs in value', () => {
+			const cookie = createCookieHeaderAccessor('token=abc=def=ghi');
+			expect(cookie('token')).toBe('abc=def=ghi');
+		});
+
+		it('should handle extra whitespace', () => {
+			const cookie = createCookieHeaderAccessor(
+				'  session=abc123  ;   user=john  ',
+			);
+			expect(cookie('session')).toBe('abc123');
+			expect(cookie('user')).toBe('john');
+		});
+	});
+
+	describe('createNoopHeaders', () => {
+		it('should return undefined for any key lookup', () => {
+			const header = createNoopHeaders();
+			expect(header('content-type')).toBeUndefined();
+			expect(header('any-header')).toBeUndefined();
+		});
+
+		it('should return empty object when called without arguments', () => {
+			const header = createNoopHeaders();
+			expect(header()).toEqual({});
+		});
+	});
+
+	describe('createNoopCookies', () => {
+		it('should return undefined for any name lookup', () => {
+			const cookie = createNoopCookies();
+			expect(cookie('session')).toBeUndefined();
+			expect(cookie('any-cookie')).toBeUndefined();
+		});
+
+		it('should return empty object when called without arguments', () => {
+			const cookie = createNoopCookies();
+			expect(cookie()).toEqual({});
+		});
+	});
+});