@geekmidas/cli 9.0.2 → 10.0.0-alpha.1

package/src/generators/__tests__/FunctionGenerator.spec.ts

@@ -1,256 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { Function } from '@geekmidas/constructs/functions';
-import { f } from '@geekmidas/constructs/functions';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { z } from 'zod';
-import {
-	cleanupDir,
-	createMockBuildContext,
-	createTempDir,
-} from '../../__tests__/test-helpers';
-import { FunctionGenerator } from '../FunctionGenerator';
-import type { GeneratedConstruct } from '../Generator';
-
-describe('FunctionGenerator', () => {
-	let tempDir: string;
-	let outputDir: string;
-	let generator: FunctionGenerator;
-	let context: ReturnType<typeof createMockBuildContext>;
-
-	beforeEach(async () => {
-		tempDir = await createTempDir();
-		outputDir = join(tempDir, 'output');
-		generator = new FunctionGenerator();
-		context = createMockBuildContext();
-	});
-
-	afterEach(async () => {
-		await cleanupDir(tempDir);
-	});
-
-	describe('isConstruct', () => {
-		it('should identify valid functions', () => {
-			const testFunction = f
-				.input(z.object({ name: z.string() }))
-				.output(z.object({ greeting: z.string() }))
-				.timeout(30)
-				.handle(async ({ input }) => ({
-					greeting: `Hello, ${input.name}!`,
-				}));
-
-			expect(generator.isConstruct(testFunction)).toBe(true);
-		});
-
-		it('should reject invalid constructs', () => {
-			expect(generator.isConstruct({})).toBe(false);
-			expect(generator.isConstruct('string')).toBe(false);
-			expect(generator.isConstruct(null)).toBe(false);
-		});
-	});
-
-	describe('build', () => {
-		const createTestFunctionConstruct = (
-			key: string,
-			timeout: number = 30,
-		): GeneratedConstruct<Function<any, any, any, any>> => {
-			const func = f
-				.timeout(timeout)
-				.handle(async () => ({ greeting: 'Hello!' }));
-
-			return {
-				key,
-				name: key.toLowerCase(),
-				construct: func,
-				path: {
-					absolute: join(tempDir, `${key}.ts`),
-					relative: `${key}.ts`,
-				},
-			};
-		};
-
-		describe('aws-lambda provider', () => {
-			it('should generate function handlers', async () => {
-				const constructs = [
-					createTestFunctionConstruct('processData', 60),
-					createTestFunctionConstruct('sendEmail', 30),
-				];
-
-				const functionInfos = await generator.build(
-					context,
-					constructs,
-					outputDir,
-					{ provider: 'aws-lambda' },
-				);
-
-				expect(functionInfos).toHaveLength(2);
-				expect(functionInfos[0]).toMatchObject({
-					name: 'processData',
-					handler: expect.stringContaining('functions/processData.handler'),
-					timeout: 60,
-				});
-				expect(functionInfos[1]).toMatchObject({
-					name: 'sendEmail',
-					handler: expect.stringContaining('functions/sendEmail.handler'),
-					timeout: 30,
-				});
-
-				// Check that handler files were created
-				const processDataHandlerPath = join(
-					outputDir,
-					'functions',
-					'processData.ts',
-				);
-				const processDataContent = await readFile(
-					processDataHandlerPath,
-					'utf-8',
-				);
-				expect(processDataContent).toContain('AWSLambdaFunction');
-				expect(processDataContent).toContain('import { processData }');
-				expect(processDataContent).toContain('import envParser');
-				expect(processDataContent).toContain('import logger');
-
-				const sendEmailHandlerPath = join(
-					outputDir,
-					'functions',
-					'sendEmail.ts',
-				);
-				const sendEmailContent = await readFile(sendEmailHandlerPath, 'utf-8');
-				expect(sendEmailContent).toContain('AWSLambdaFunction');
-				expect(sendEmailContent).toContain('import { sendEmail }');
-			});
-
-			it('should generate correct relative import paths', async () => {
-				const construct: GeneratedConstruct<Function<any, any, any, any>> = {
-					key: 'deepFunction',
-					name: 'deep-function',
-					construct: createTestFunctionConstruct('deepFunction', 45).construct,
-					path: {
-						absolute: join(tempDir, 'src/functions/deep/processor.ts'),
-						relative: 'src/functions/deep/processor.ts',
-					},
-				};
-
-				await generator.build(context, [construct], outputDir, {
-					provider: 'aws-lambda',
-				});
-
-				const handlerPath = join(outputDir, 'functions', 'deepFunction.ts');
-				const handlerContent = await readFile(handlerPath, 'utf-8');
-
-				// Check relative imports are correct - the path will be relative from outputDir
-				expect(handlerContent).toMatch(
-					/from ['"].*src\/functions\/deep\/processor\.js['"]/,
-				);
-				expect(handlerContent).toMatch(/from ['"].*\/env['"]/);
-				expect(handlerContent).toMatch(/from ['"].*\/logger['"]/);
-			});
-
-			it('should log generation progress', async () => {
-				const logSpy = vi.spyOn(console, 'log');
-
-				const constructs = [createTestFunctionConstruct('testFunction', 30)];
-
-				await generator.build(context, constructs, outputDir, {
-					provider: 'aws-lambda',
-				});
-
-				expect(logSpy).toHaveBeenCalledWith(
-					'Generated function handler: testFunction',
-				);
-
-				logSpy.mockRestore();
-			});
-		});
-
-		describe('non aws-lambda provider', () => {
-			it('should return empty array for server provider', async () => {
-				const constructs = [createTestFunctionConstruct('testFunction', 30)];
-
-				const functionInfos = await generator.build(
-					context,
-					constructs,
-					outputDir,
-					{ provider: 'server' },
-				);
-
-				expect(functionInfos).toEqual([]);
-			});
-
-			it('should return empty array for aws-apigatewayv1 provider', async () => {
-				const constructs = [createTestFunctionConstruct('testFunction', 30)];
-
-				const functionInfos = await generator.build(
-					context,
-					constructs,
-					outputDir,
-					{ provider: 'aws-apigatewayv1' },
-				);
-
-				expect(functionInfos).toEqual([]);
-			});
-		});
-
-		it('should return empty array for empty constructs', async () => {
-			const functionInfos = await generator.build(context, [], outputDir, {
-				provider: 'aws-lambda',
-			});
-			expect(functionInfos).toEqual([]);
-		});
-
-		it('should use default provider when none specified', async () => {
-			const constructs = [createTestFunctionConstruct('defaultFunction', 30)];
-
-			const functionInfos = await generator.build(
-				context,
-				constructs,
-				outputDir,
-			);
-
-			expect(functionInfos).toHaveLength(1);
-			expect(functionInfos[0].name).toBe('defaultFunction');
-
-			// Check that handler was created (default is aws-lambda)
-			const handlerPath = join(outputDir, 'functions', 'defaultFunction.ts');
-			const handlerContent = await readFile(handlerPath, 'utf-8');
-			expect(handlerContent).toContain('AWSLambdaFunction');
-		});
-
-		it('should handle functions with different timeout values', async () => {
-			const constructs = [
-				createTestFunctionConstruct('quickFunction', 15),
-				createTestFunctionConstruct('slowFunction', 300),
-			];
-
-			const functionInfos = await generator.build(
-				context,
-				constructs,
-				outputDir,
-				{ provider: 'aws-lambda' },
-			);
-
-			expect(functionInfos[0].timeout).toBe(15);
-			expect(functionInfos[1].timeout).toBe(300);
-		});
-
-		it('should handle functions with custom environment parser patterns', async () => {
-			const customContext = {
-				...context,
-				envParserImportPattern: '{ customParser as envParser }',
-				loggerImportPattern: '{ customLogger as logger }',
-			};
-
-			const constructs = [createTestFunctionConstruct('customFunction', 30)];
-
-			await generator.build(customContext, constructs, outputDir, {
-				provider: 'aws-lambda',
-			});
-
-			const handlerPath = join(outputDir, 'functions', 'customFunction.ts');
-			const handlerContent = await readFile(handlerPath, 'utf-8');
-
-			expect(handlerContent).toContain('import { customParser as envParser }');
-			expect(handlerContent).toContain('import { customLogger as logger }');
-		});
-	});
-});

package/src/generators/__tests__/Generator.bustCache.spec.ts

@@ -1,72 +0,0 @@
-import { writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { itWithDir } from '@geekmidas/testkit/os';
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod/v4';
-import { EndpointGenerator } from '../EndpointGenerator';
-import { clearZodGlobalRegistry } from '../Generator';
-
-describe('clearZodGlobalRegistry', () => {
-	it('removes an id from the global registry so the same id can be re-registered', () => {
-		// Register once — succeeds
-		z.object({ x: z.string() }).meta({ id: 'BustCacheSchema_A' });
-
-		// Re-registering without clearing throws
-		expect(() =>
-			z.object({ y: z.string() }).meta({ id: 'BustCacheSchema_A' }),
-		).toThrow(/already exists in the registry/);
-
-		// After clearing, the id can be registered again
-		clearZodGlobalRegistry();
-		expect(() =>
-			z.object({ z: z.string() }).meta({ id: 'BustCacheSchema_A' }),
-		).not.toThrow();
-	});
-
-	it('is a no-op when the registry has not been initialised', () => {
-		// Temporarily remove the global registry
-		const g = globalThis as { __zod_globalRegistry?: unknown };
-		const saved = g.__zod_globalRegistry;
-		delete g.__zod_globalRegistry;
-
-		try {
-			// Should not throw even though the registry does not exist
-			expect(() => clearZodGlobalRegistry()).not.toThrow();
-		} finally {
-			g.__zod_globalRegistry = saved;
-		}
-	});
-});
-
-describe('Generator.load — bustCache integration smoke test', () => {
-	itWithDir(
-		'loads an endpoint with .meta({ id }) across multiple cache-busted reloads without throwing',
-		async ({ dir }) => {
-			// Mirrors the real scenario: endpoint output schema registers an
-			// id. Reloading on file change must not throw a duplicate-id error.
-			const endpointFile = join(dir, 'getRentalAgreement.ts');
-			await writeFile(
-				endpointFile,
-				`
-import { e } from '@geekmidas/constructs/endpoints';
-import { z } from 'zod/v4';
-
-export const getRentalAgreement = e
-  .get('/rental-agreement')
-  .output(z.object({ content: z.string() }).meta({ id: 'RentalAgreementOutput' }))
-  .handle(async () => ({ content: 'pdf-content' }));
-`,
-			);
-
-			const generator = new EndpointGenerator();
-			const patterns = join(dir, '**/*.ts');
-
-			// Simulates multiple `gkm dev` reloads
-			for (let i = 0; i < 3; i++) {
-				const loaded = await generator.load(patterns, process.cwd(), true);
-				expect(loaded).toHaveLength(1);
-				expect(loaded[0].key).toBe('getRentalAgreement');
-			}
-		},
-	);
-});

package/src/generators/__tests__/OpenApiTsGenerator.registry.spec.ts

@@ -1,98 +0,0 @@
-import { e } from '@geekmidas/constructs/endpoints';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { z } from 'zod/v4';
-import { OpenApiTsGenerator } from '../OpenApiTsGenerator';
-
-describe('OpenApiTsGenerator — zod global registry', () => {
-	beforeEach(() => {
-		z.globalRegistry.clear();
-	});
-
-	afterEach(() => {
-		z.globalRegistry.clear();
-	});
-
-	it('emits a named interface for a registered schema even when no endpoint references it directly', async () => {
-		const UserSchema = z
-			.object({
-				id: z.string(),
-				email: z.string(),
-				name: z.string(),
-			})
-			.meta({ id: 'User' });
-
-		const UserResponseSchema = UserSchema.pick({
-			id: true,
-			name: true,
-			email: true,
-		});
-
-		const endpoint = e
-			.get('/users/:id')
-			.output(UserResponseSchema)
-			.handle(async () => ({ id: '1', name: 'a', email: 'a@b.c' }));
-
-		const generator = new OpenApiTsGenerator();
-		const content = await generator.generate([endpoint as any]);
-
-		expect(content).toMatch(/export interface User\b/);
-	});
-
-	it('does not duplicate when the same id is also produced by an endpoint', async () => {
-		const UserSchema = z
-			.object({
-				id: z.string(),
-				email: z.string(),
-				name: z.string(),
-			})
-			.meta({ id: 'User' });
-
-		const endpoint = e
-			.get('/users/:id')
-			.output(UserSchema)
-			.handle(async () => ({ id: '1', name: 'a', email: 'a@b.c' }));
-
-		const generator = new OpenApiTsGenerator();
-		const content = await generator.generate([endpoint as any]);
-
-		const occurrences = content.match(/export interface User\b/g) ?? [];
-		expect(occurrences.length).toBe(1);
-	});
-
-	it('emits multiple registered schemas', async () => {
-		z.object({ id: z.string() }).meta({ id: 'Foo' });
-		z.object({ id: z.string() }).meta({ id: 'Bar' });
-
-		const endpoint = e
-			.get('/ping')
-			.output(z.object({ ok: z.boolean() }))
-			.handle(async () => ({ ok: true }));
-
-		const generator = new OpenApiTsGenerator();
-		const content = await generator.generate([endpoint as any]);
-
-		expect(content).toMatch(/export interface Foo\b/);
-		expect(content).toMatch(/export interface Bar\b/);
-	});
-
-	it('references one registered schema from another via the parent type', async () => {
-		const UserSchema = z
-			.object({ id: z.string(), email: z.string() })
-			.meta({ id: 'User' });
-
-		z.object({ user: UserSchema, role: z.string() }).meta({ id: 'UserRole' });
-
-		const endpoint = e
-			.get('/ping')
-			.output(z.object({ ok: z.boolean() }))
-			.handle(async () => ({ ok: true }));
-
-		const generator = new OpenApiTsGenerator();
-		const content = await generator.generate([endpoint as any]);
-
-		expect(content).toMatch(/export interface User\b/);
-		expect(content).toMatch(/export interface UserRole\b/);
-		// `user` inside UserRole should reference the named User type, not inline.
-		expect(content).toMatch(/user:\s*User\b/);
-	});
-});

package/src/generators/__tests__/OpenApiTsGenerator.responseType.spec.ts

@@ -1,56 +0,0 @@
-import { e } from '@geekmidas/constructs/endpoints';
-import { describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import { OpenApiTsGenerator } from '../OpenApiTsGenerator';
-
-describe('OpenApiTsGenerator — responseType', () => {
-	it("emits 'application/json' in paths when responseType is default", async () => {
-		const endpoint = e
-			.get('/users')
-			.output(z.object({ id: z.string() }))
-			.handle(async () => ({ id: '1' }));
-
-		const generator = new OpenApiTsGenerator();
-		const content = await generator.generate([endpoint as any]);
-
-		// Default JSON content-type in the paths interface
-		expect(content).toContain("'application/json':");
-	});
-
-	it("emits 'text/html' when the endpoint declares responseType('text/html')", async () => {
-		const endpoint = e
-			.get('/checkout-page')
-			.output(z.string())
-			.responseType('text/html')
-			.handle(async () => '<html></html>');
-
-		const generator = new OpenApiTsGenerator();
-		const content = await generator.generate([endpoint as any]);
-
-		// Paths interface should reference text/html, not application/json,
-		// for this endpoint's 200 response
-		expect(content).toContain("'text/html':");
-	});
-
-	it('keeps JSON content-type for other endpoints when one uses a custom responseType', async () => {
-		const htmlEndpoint = e
-			.get('/page')
-			.output(z.string())
-			.responseType('text/html')
-			.handle(async () => '<html></html>');
-
-		const jsonEndpoint = e
-			.get('/users')
-			.output(z.object({ id: z.string() }))
-			.handle(async () => ({ id: '1' }));
-
-		const generator = new OpenApiTsGenerator();
-		const content = await generator.generate([
-			htmlEndpoint as any,
-			jsonEndpoint as any,
-		]);
-
-		expect(content).toContain("'text/html':");
-		expect(content).toContain("'application/json':");
-	});
-});

package/src/generators/__tests__/QueueGenerator.spec.ts

@@ -1,141 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { type Queue, QueueBuilder } from '@geekmidas/constructs/queue';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { z } from 'zod';
-import {
-	cleanupDir,
-	createMockBuildContext,
-	createTempDir,
-} from '../../__tests__/test-helpers';
-import type { GeneratedConstruct } from '../Generator';
-import { QueueGenerator } from '../QueueGenerator';
-
-const schema = z.object({ orderId: z.string() });
-
-describe('QueueGenerator', () => {
-	let tempDir: string;
-	let outputDir: string;
-	let generator: QueueGenerator;
-	let context: ReturnType<typeof createMockBuildContext>;
-
-	beforeEach(async () => {
-		tempDir = await createTempDir();
-		outputDir = join(tempDir, 'output');
-		generator = new QueueGenerator();
-		context = createMockBuildContext();
-	});
-
-	afterEach(async () => {
-		await cleanupDir(tempDir);
-	});
-
-	const createQueueConstruct = (
-		key: string,
-		name: string,
-	): GeneratedConstruct<Queue<any, any, any, any>> => {
-		const queue = new QueueBuilder()
-			.queue(name)
-			.batchSize(5)
-			.message(schema)
-			.handle(async () => {});
-
-		return {
-			key,
-			name: key.toLowerCase(),
-			construct: queue,
-			path: {
-				absolute: join(tempDir, `${key}.ts`),
-				relative: `${key}.ts`,
-			},
-		};
-	};
-
-	describe('isConstruct', () => {
-		it('identifies queues and rejects everything else', () => {
-			const queue = new QueueBuilder()
-				.queue('orders')
-				.message(schema)
-				.handle(async () => {});
-
-			expect(generator.isConstruct(queue)).toBe(true);
-			expect(generator.isConstruct({})).toBe(false);
-			expect(generator.isConstruct(null)).toBe(false);
-		});
-	});
-
-	describe('aws-lambda provider', () => {
-		it('generates one AWSLambdaQueue handler per queue', async () => {
-			const constructs = [
-				createQueueConstruct('ordersQueue', 'orders'),
-				createQueueConstruct('emailsQueue', 'emails'),
-			];
-
-			const infos = await generator.build(context, constructs, outputDir, {
-				provider: 'aws-lambda',
-			});
-
-			expect(infos).toHaveLength(2);
-			expect(infos[0]).toMatchObject({
-				name: 'orders',
-				handler: expect.stringContaining('queues/ordersQueue.handler'),
-				batchSize: 5,
-			});
-			// Env requirement from the (sniffed) producer flows nowhere here, but the
-			// consumer queue's own services would; assert the field exists.
-			expect(infos[0].environment).toBeDefined();
-
-			const handler = await readFile(
-				join(outputDir, 'queues', 'ordersQueue.ts'),
-				'utf-8',
-			);
-			expect(handler).toContain(
-				"import { AWSLambdaQueue } from '@geekmidas/constructs/aws'",
-			);
-			expect(handler).toContain('import { ordersQueue }');
-			expect(handler).toContain('new AWSLambdaQueue(envParser, ordersQueue)');
-			expect(handler).toContain('export const handler = adapter.handler');
-		});
-
-		it('returns an empty array for no queues', async () => {
-			const infos = await generator.build(context, [], outputDir, {
-				provider: 'aws-lambda',
-			});
-			expect(infos).toEqual([]);
-		});
-	});
-
-	describe('server provider', () => {
-		it('generates queues.ts with the setupQueues poller even when empty', async () => {
-			const infos = await generator.build(context, [], outputDir, {
-				provider: 'server',
-			});
-
-			expect(infos).toEqual([]);
-
-			const content = await readFile(join(outputDir, 'queues.ts'), 'utf-8');
-			expect(content).toContain('export async function setupQueues');
-			expect(content).toContain('const queues = [');
-			expect(content).toContain('EVENT_SUBSCRIBER_CONNECTION_STRING');
-		});
-
-		it('subscribes each queue by its name and validates the payload', async () => {
-			const constructs = [
-				createQueueConstruct('ordersQueue', 'orders'),
-				createQueueConstruct('emailsQueue', 'emails'),
-			];
-
-			await generator.build(context, constructs, outputDir, {
-				provider: 'server',
-			});
-
-			const content = await readFile(join(outputDir, 'queues.ts'), 'utf-8');
-			expect(content).toContain('import { ordersQueue }');
-			expect(content).toContain('import { emailsQueue }');
-			// A queue subscribes to a single "type" — its own name.
-			expect(content).toContain('eventSubscriber.subscribe([queue.name]');
-			expect(content).toContain("queue.messageSchema['~standard'].validate");
-			expect(content).toContain('messages: [validation.value]');
-		});
-	});
-});