@geekmidas/constructs 9.0.2 → 10.0.0-alpha.0

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

@@ -1,211 +0,0 @@
-import { setupServer } from 'msw/node';
-import { afterAll, afterEach, beforeAll, describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import { e } from '../EndpointFactory';
-import { createMswHandlers, TEST_CONTEXT_HEADER } from '../MswEndpointAdaptor';
-
-const BASE_URL = 'http://localhost:3000';
-
-// --- Services ---
-
-interface UserDatabase {
-	listUsers(): { id: string; name: string }[];
-}
-
-const DatabaseService = {
-	serviceName: 'database' as const,
-	register: () => ({ listUsers: () => [] }) as UserDatabase,
-};
-
-// --- Endpoints ---
-
-const listUsers = e
-	.get('/users')
-	.services([DatabaseService])
-	.output(
-		z.object({
-			users: z.array(z.object({ id: z.string(), name: z.string() })),
-		}),
-	)
-	.handle(async ({ services }) => {
-		const users = services.database.listUsers();
-		return { users };
-	});
-
-const createUser = e
-	.post('/users')
-	.body(z.object({ name: z.string().min(1), email: z.string().email() }))
-	.output(z.object({ id: z.string(), name: z.string(), email: z.string() }))
-	.handle(async ({ body }) => ({
-		id: crypto.randomUUID(),
-		name: body.name,
-		email: body.email,
-	}));
-
-const getUser = e
-	.get('/users/:id')
-	.params(z.object({ id: z.string() }))
-	.output(z.object({ id: z.string(), name: z.string() }))
-	.handle(async ({ params }) => ({
-		id: params.id,
-		name: 'Test User',
-	}));
-
-const authorizedEndpoint = e
-	.get('/protected')
-	.output(z.object({ message: z.string() }))
-	.authorize(({ header }) => header('authorization') === 'Bearer valid-token')
-	.handle(async () => ({ message: 'secret' }));
-
-// --- Setup ---
-
-const { handlers, registerContext } = createMswHandlers(
-	[listUsers, createUser, getUser, authorizedEndpoint],
-	{ baseURL: BASE_URL },
-);
-
-const server = setupServer(...handlers);
-
-beforeAll(() => server.listen({ onUnhandledRequest: 'bypass' }));
-afterEach(() => server.resetHandlers());
-afterAll(() => server.close());
-
-// --- Tests ---
-
-describe('MswEndpointAdaptor', () => {
-	it('should handle a simple GET request', async () => {
-		const contextId = crypto.randomUUID();
-		registerContext(contextId, {
-			services: {
-				database: { listUsers: () => [{ id: '1', name: 'Alice' }] },
-			},
-		});
-
-		const response = await fetch(`${BASE_URL}/users`, {
-			headers: { [TEST_CONTEXT_HEADER]: contextId },
-		});
-
-		expect(response.status).toBe(200);
-		const body = await response.json();
-		expect(body.users).toEqual([{ id: '1', name: 'Alice' }]);
-	});
-
-	it('should handle POST with body validation', async () => {
-		const contextId = crypto.randomUUID();
-		registerContext(contextId, {});
-
-		const response = await fetch(`${BASE_URL}/users`, {
-			method: 'POST',
-			headers: {
-				'content-type': 'application/json',
-				[TEST_CONTEXT_HEADER]: contextId,
-			},
-			body: JSON.stringify({ name: 'Bob', email: 'bob@example.com' }),
-		});
-
-		expect(response.status).toBe(200);
-		const body = await response.json();
-		expect(body.name).toBe('Bob');
-		expect(body.email).toBe('bob@example.com');
-		expect(body.id).toBeDefined();
-	});
-
-	it('should reject invalid body with 422', async () => {
-		const contextId = crypto.randomUUID();
-		registerContext(contextId, {});
-
-		const response = await fetch(`${BASE_URL}/users`, {
-			method: 'POST',
-			headers: {
-				'content-type': 'application/json',
-				[TEST_CONTEXT_HEADER]: contextId,
-			},
-			body: JSON.stringify({ name: '', email: 'not-an-email' }),
-		});
-
-		expect(response.status).toBe(422);
-	});
-
-	it('should handle path params', async () => {
-		const contextId = crypto.randomUUID();
-		registerContext(contextId, {});
-
-		const response = await fetch(`${BASE_URL}/users/user-123`, {
-			headers: { [TEST_CONTEXT_HEADER]: contextId },
-		});
-
-		expect(response.status).toBe(200);
-		const body = await response.json();
-		expect(body.id).toBe('user-123');
-		expect(body.name).toBe('Test User');
-	});
-
-	it('should return 403 when authorization fails', async () => {
-		const contextId = crypto.randomUUID();
-		registerContext(contextId, {});
-
-		const response = await fetch(`${BASE_URL}/protected`, {
-			headers: {
-				[TEST_CONTEXT_HEADER]: contextId,
-				authorization: 'Bearer wrong-token',
-			},
-		});
-
-		expect(response.status).toBe(403);
-	});
-
-	it('should return 200 when authorization passes', async () => {
-		const contextId = crypto.randomUUID();
-		registerContext(contextId, {});
-
-		const response = await fetch(`${BASE_URL}/protected`, {
-			headers: {
-				[TEST_CONTEXT_HEADER]: contextId,
-				authorization: 'Bearer valid-token',
-			},
-		});
-
-		expect(response.status).toBe(200);
-		const body = await response.json();
-		expect(body.message).toBe('secret');
-	});
-
-	it('should return 500 when context ID is missing', async () => {
-		const response = await fetch(`${BASE_URL}/users`);
-
-		expect(response.status).toBe(500);
-		const body = await response.json();
-		expect(body.error).toContain('Missing or unknown test context ID');
-	});
-
-	it('should isolate concurrent contexts', async () => {
-		const contextA = crypto.randomUUID();
-		const contextB = crypto.randomUUID();
-
-		registerContext(contextA, {
-			services: {
-				database: { listUsers: () => [{ id: '1', name: 'From A' }] },
-			},
-		});
-		registerContext(contextB, {
-			services: {
-				database: { listUsers: () => [{ id: '2', name: 'From B' }] },
-			},
-		});
-
-		const [responseA, responseB] = await Promise.all([
-			fetch(`${BASE_URL}/users`, {
-				headers: { [TEST_CONTEXT_HEADER]: contextA },
-			}),
-			fetch(`${BASE_URL}/users`, {
-				headers: { [TEST_CONTEXT_HEADER]: contextB },
-			}),
-		]);
-
-		const bodyA = await responseA.json();
-		const bodyB = await responseB.json();
-
-		expect(bodyA.users).toEqual([{ id: '1', name: 'From A' }]);
-		expect(bodyB.users).toEqual([{ id: '2', name: 'From B' }]);
-	});
-});

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

@@ -1,235 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ResponseBuilder, SuccessStatus } from '../Endpoint';
-
-describe('ResponseBuilder', () => {
-	describe('header', () => {
-		it('should set a single header', () => {
-			const builder = new ResponseBuilder();
-			builder.header('X-Custom-Header', 'custom-value');
-
-			const metadata = builder.getMetadata();
-			expect(metadata.headers).toEqual({
-				'X-Custom-Header': 'custom-value',
-			});
-		});
-
-		it('should set multiple headers', () => {
-			const builder = new ResponseBuilder();
-			builder
-				.header('X-Header-1', 'value1')
-				.header('X-Header-2', 'value2')
-				.header('Content-Type', 'application/json');
-
-			const metadata = builder.getMetadata();
-			expect(metadata.headers).toEqual({
-				'X-Header-1': 'value1',
-				'X-Header-2': 'value2',
-				'Content-Type': 'application/json',
-			});
-		});
-
-		it('should allow method chaining', () => {
-			const builder = new ResponseBuilder();
-			const result = builder.header('X-Test', 'value');
-
-			expect(result).toBe(builder);
-		});
-	});
-
-	describe('cookie', () => {
-		it('should set a simple cookie', () => {
-			const builder = new ResponseBuilder();
-			builder.cookie('session', 'abc123');
-
-			const metadata = builder.getMetadata();
-			expect(metadata.cookies?.has('session')).toBe(true);
-			expect(metadata.cookies?.get('session')).toEqual({
-				value: 'abc123',
-				options: undefined,
-			});
-		});
-
-		it('should set cookie with options', () => {
-			const builder = new ResponseBuilder();
-			builder.cookie('session', 'abc123', {
-				httpOnly: true,
-				secure: true,
-				sameSite: 'strict',
-				maxAge: 3600,
-				path: '/',
-			});
-
-			const metadata = builder.getMetadata();
-			const cookie = metadata.cookies?.get('session');
-			expect(cookie).toEqual({
-				value: 'abc123',
-				options: {
-					httpOnly: true,
-					secure: true,
-					sameSite: 'strict',
-					maxAge: 3600,
-					path: '/',
-				},
-			});
-		});
-
-		it('should set multiple cookies', () => {
-			const builder = new ResponseBuilder();
-			builder
-				.cookie('session', 'abc123')
-				.cookie('theme', 'dark')
-				.cookie('lang', 'en');
-
-			const metadata = builder.getMetadata();
-			expect(metadata.cookies?.size).toBe(3);
-			expect(metadata.cookies?.get('session')?.value).toBe('abc123');
-			expect(metadata.cookies?.get('theme')?.value).toBe('dark');
-			expect(metadata.cookies?.get('lang')?.value).toBe('en');
-		});
-
-		it('should allow method chaining', () => {
-			const builder = new ResponseBuilder();
-			const result = builder.cookie('test', 'value');
-
-			expect(result).toBe(builder);
-		});
-	});
-
-	describe('deleteCookie', () => {
-		it('should set cookie with empty value and maxAge 0', () => {
-			const builder = new ResponseBuilder();
-			builder.deleteCookie('session');
-
-			const metadata = builder.getMetadata();
-			const cookie = metadata.cookies?.get('session');
-			expect(cookie?.value).toBe('');
-			expect(cookie?.options?.maxAge).toBe(0);
-			expect(cookie?.options?.expires?.getTime()).toBe(0);
-		});
-
-		it('should preserve domain and path options', () => {
-			const builder = new ResponseBuilder();
-			builder.deleteCookie('session', {
-				domain: '.example.com',
-				path: '/app',
-			});
-
-			const metadata = builder.getMetadata();
-			const cookie = metadata.cookies?.get('session');
-			expect(cookie?.options).toMatchObject({
-				domain: '.example.com',
-				path: '/app',
-				maxAge: 0,
-			});
-		});
-
-		it('should allow method chaining', () => {
-			const builder = new ResponseBuilder();
-			const result = builder.deleteCookie('test');
-
-			expect(result).toBe(builder);
-		});
-	});
-
-	describe('status', () => {
-		it('should set status code', () => {
-			const builder = new ResponseBuilder();
-			builder.status(SuccessStatus.Created);
-
-			const metadata = builder.getMetadata();
-			expect(metadata.status).toBe(201);
-		});
-
-		it('should allow method chaining', () => {
-			const builder = new ResponseBuilder();
-			const result = builder.status(SuccessStatus.OK);
-
-			expect(result).toBe(builder);
-		});
-	});
-
-	describe('send', () => {
-		it('should return data with metadata', () => {
-			const builder = new ResponseBuilder();
-			builder.header('X-Test', 'value').status(SuccessStatus.Created);
-
-			const result = builder.send({ id: '123', name: 'Test' });
-
-			expect(result).toEqual({
-				data: { id: '123', name: 'Test' },
-				metadata: {
-					headers: { 'X-Test': 'value' },
-					cookies: new Map(),
-					status: SuccessStatus.Created,
-				},
-			});
-		});
-
-		it('should work with complex data', () => {
-			const builder = new ResponseBuilder();
-			const complexData = {
-				user: { id: '1', name: 'John' },
-				posts: [{ id: '1', title: 'Post' }],
-			};
-
-			const result = builder.send(complexData);
-
-			expect(result.data).toEqual(complexData);
-			expect(result.metadata).toBeDefined();
-		});
-	});
-
-	describe('fluent API', () => {
-		it('should support full fluent chain', () => {
-			const builder = new ResponseBuilder();
-
-			const result = builder
-				.status(SuccessStatus.Created)
-				.header('Location', '/users/123')
-				.header('X-User-Id', '123')
-				.cookie('session', 'abc123', { httpOnly: true })
-				.cookie('preferences', 'dark-mode')
-				.send({ id: '123', name: 'John' });
-
-			expect(result).toEqual({
-				data: { id: '123', name: 'John' },
-				metadata: {
-					status: 201,
-					headers: {
-						Location: '/users/123',
-						'X-User-Id': '123',
-					},
-					cookies: new Map([
-						['session', { value: 'abc123', options: { httpOnly: true } }],
-						['preferences', { value: 'dark-mode', options: undefined }],
-					]),
-				},
-			});
-		});
-	});
-
-	describe('getMetadata', () => {
-		it('should return current metadata', () => {
-			const builder = new ResponseBuilder();
-			builder.header('X-Test', 'value').cookie('test', 'cookie-value');
-
-			const metadata = builder.getMetadata();
-
-			expect(metadata).toEqual({
-				headers: { 'X-Test': 'value' },
-				cookies: new Map([
-					['test', { value: 'cookie-value', options: undefined }],
-				]),
-			});
-		});
-
-		it('should return empty objects for unused features', () => {
-			const builder = new ResponseBuilder();
-			const metadata = builder.getMetadata();
-
-			expect(metadata.headers).toEqual({});
-			expect(metadata.cookies?.size).toBe(0);
-			expect(metadata.status).toBeUndefined();
-		});
-	});
-});