@geekmidas/constructs 7.0.1 → 10.0.0-alpha.0

package/src/endpoints/__tests__/__snapshots__/HonoEndpointAdaptor.spec.ts.snap

@@ -1,54 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`HonoEndpointAdaptor > addRoute > should return 422 for invalid body 1`] = `
-[
-  {
-    "code": "too_small",
-    "inclusive": true,
-    "message": "Too small: expected string to have >=3 characters",
-    "minimum": 3,
-    "origin": "string",
-    "path": [
-      "name",
-    ],
-  },
-  {
-    "code": "invalid_type",
-    "expected": "number",
-    "message": "Invalid input: expected number, received string",
-    "path": [
-      "age",
-    ],
-  },
-]
-`;
-
-exports[`HonoEndpointAdaptor > addRoute > should return 422 for invalid path parameters 1`] = `
-[
-  {
-    "code": "invalid_format",
-    "format": "uuid",
-    "message": "Invalid UUID",
-    "origin": "string",
-    "path": [
-      "id",
-    ],
-    "pattern": "/^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/",
-  },
-]
-`;
-
-exports[`HonoEndpointAdaptor > addRoute > should return 422 for invalid query parameters 1`] = `
-[
-  {
-    "code": "invalid_format",
-    "format": "regex",
-    "message": "Invalid string: must match pattern /^\\d+$/",
-    "origin": "string",
-    "path": [
-      "page",
-    ],
-    "pattern": "/^\\d+$/",
-  },
-]
-`;

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

@@ -1,88 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-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');
-
-			// These should NOT exist
-			expectTypeOf(ctx).not.toHaveProperty('body');
-			expectTypeOf(ctx).not.toHaveProperty('params');
-			expectTypeOf(ctx).not.toHaveProperty('query');
-
-			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 }>();
-
-				// These should NOT exist
-				expectTypeOf(ctx).not.toHaveProperty('params');
-				expectTypeOf(ctx).not.toHaveProperty('query');
-
-				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 }>();
-
-				// These should NOT exist
-				expectTypeOf(ctx).not.toHaveProperty('body');
-				expectTypeOf(ctx).not.toHaveProperty('query');
-
-				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 }>();
-
-				// These should NOT exist
-				expectTypeOf(ctx).not.toHaveProperty('body');
-				expectTypeOf(ctx).not.toHaveProperty('params');
-
-				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');
-
-				expectTypeOf(ctx.body).toEqualTypeOf<{ name: string }>();
-				expectTypeOf(ctx.params).toEqualTypeOf<{ id: string }>();
-				expectTypeOf(ctx.query).toEqualTypeOf<{ filter: string }>();
-
-				return { success: true };
-			});
-	});
-});

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

@@ -1,37 +0,0 @@
-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

@@ -1,330 +0,0 @@
-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({});
-		});
-	});
-});