@geekmidas/cli 2.0.2 → 10.0.0-alpha.0

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

@@ -1,410 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import {
-	type Subscriber,
-	SubscriberBuilder,
-} from '@geekmidas/constructs/subscribers';
-
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-	cleanupDir,
-	createMockBuildContext,
-	createTempDir,
-} from '../../__tests__/test-helpers';
-import type { GeneratedConstruct } from '../Generator';
-import { SubscriberGenerator } from '../SubscriberGenerator';
-
-describe('SubscriberGenerator', () => {
-	let tempDir: string;
-	let outputDir: string;
-	let generator: SubscriberGenerator;
-	let context: ReturnType<typeof createMockBuildContext>;
-
-	beforeEach(async () => {
-		tempDir = await createTempDir();
-		outputDir = join(tempDir, 'output');
-		generator = new SubscriberGenerator();
-		context = createMockBuildContext();
-	});
-
-	afterEach(async () => {
-		await cleanupDir(tempDir);
-	});
-
-	describe('isConstruct', () => {
-		it('should identify valid subscribers', async () => {
-			const testSubscriber = new SubscriberBuilder()
-				.subscribe(['user.created'] as any)
-				.handle(async ({ events, logger }) => {
-					logger.info({ eventCount: events.length }, 'Processing events');
-				});
-
-			expect(generator.isConstruct(testSubscriber)).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 createSubscriberConstruct = (
-			key: string,
-			subscribedEvents: string[],
-			timeout: number = 30000,
-		): GeneratedConstruct<Subscriber<any, any, any, any, any, any>> => {
-			const subscriber = new SubscriberBuilder()
-				.subscribe(subscribedEvents as any)
-				.timeout(timeout)
-				.handle(async ({ events, logger }) => {
-					logger.info({ eventCount: events.length }, 'Processing events');
-				});
-
-			return {
-				key,
-				name: key.toLowerCase(),
-				construct: subscriber,
-				path: {
-					absolute: join(tempDir, `${key}.ts`),
-					relative: `${key}.ts`,
-				},
-			};
-		};
-
-		it('should generate subscriber handlers', async () => {
-			const constructs = [
-				createSubscriberConstruct('userEventSubscriber', [
-					'user.created',
-					'user.updated',
-				]),
-				createSubscriberConstruct('orderEventSubscriber', ['order.placed']),
-			];
-
-			const subscriberInfos = await generator.build(
-				context,
-				constructs,
-				outputDir,
-				{ provider: 'aws-lambda' },
-			);
-
-			expect(subscriberInfos).toHaveLength(2);
-			expect(subscriberInfos[0]).toMatchObject({
-				name: 'userEventSubscriber',
-				handler: expect.stringContaining(
-					'subscribers/userEventSubscriber.handler',
-				),
-				subscribedEvents: ['user.created', 'user.updated'],
-				timeout: 30000,
-			});
-			expect(subscriberInfos[1]).toMatchObject({
-				name: 'orderEventSubscriber',
-				handler: expect.stringContaining(
-					'subscribers/orderEventSubscriber.handler',
-				),
-				subscribedEvents: ['order.placed'],
-				timeout: 30000,
-			});
-
-			// Check that handler files were created
-			const userHandlerPath = join(
-				outputDir,
-				'subscribers',
-				'userEventSubscriber.ts',
-			);
-			const userContent = await readFile(userHandlerPath, 'utf-8');
-			expect(userContent).toContain('AWSLambdaSubscriber');
-			expect(userContent).toContain('import { userEventSubscriber }');
-			expect(userContent).toContain('import envParser');
-
-			const orderHandlerPath = join(
-				outputDir,
-				'subscribers',
-				'orderEventSubscriber.ts',
-			);
-			const orderContent = await readFile(orderHandlerPath, 'utf-8');
-			expect(orderContent).toContain('AWSLambdaSubscriber');
-			expect(orderContent).toContain('import { orderEventSubscriber }');
-		});
-
-		it('should generate correct relative import paths', async () => {
-			const subscriber = new SubscriberBuilder()
-				.subscribe(['event.type'] as any)
-				.timeout(45000)
-				.handle(async ({ events, logger }) => {
-					logger.info({ eventCount: events.length }, 'Processing events');
-				});
-
-			const construct: GeneratedConstruct<
-				Subscriber<any, any, any, any, any, any>
-			> = {
-				key: 'deepSubscriber',
-				name: 'deep-subscriber',
-				construct: subscriber,
-				path: {
-					absolute: join(tempDir, 'src/subscribers/deep/processor.ts'),
-					relative: 'src/subscribers/deep/processor.ts',
-				},
-			};
-
-			await generator.build(context, [construct], outputDir);
-
-			const handlerPath = join(outputDir, 'subscribers', 'deepSubscriber.ts');
-			const handlerContent = await readFile(handlerPath, 'utf-8');
-
-			// Check relative imports are correct
-			expect(handlerContent).toMatch(
-				/from ['"].*src\/subscribers\/deep\/processor\.js['"]/,
-			);
-			expect(handlerContent).toMatch(/from ['"].*\/env['"]/);
-		});
-
-		it('should handle subscribers with different timeout values', async () => {
-			const constructs = [
-				createSubscriberConstruct('quickSubscriber', ['fast.event'], 15000),
-				createSubscriberConstruct('slowSubscriber', ['slow.event'], 300000),
-			];
-
-			const subscriberInfos = await generator.build(
-				context,
-				constructs,
-				outputDir,
-			);
-
-			expect(subscriberInfos[0].timeout).toBe(15000);
-			expect(subscriberInfos[1].timeout).toBe(300000);
-		});
-
-		it('should handle subscribers with no subscribed events', async () => {
-			const subscriber = new SubscriberBuilder()
-				.timeout(30000)
-				.handle(async ({ events, logger }) => {
-					logger.info({ eventCount: events.length }, 'Processing all events');
-				});
-
-			const construct: GeneratedConstruct<
-				Subscriber<any, any, any, any, any, any>
-			> = {
-				key: 'catchAllSubscriber',
-				name: 'catch-all-subscriber',
-				construct: subscriber,
-				path: {
-					absolute: join(tempDir, 'catchAllSubscriber.ts'),
-					relative: 'catchAllSubscriber.ts',
-				},
-			};
-
-			const subscriberInfos = await generator.build(
-				context,
-				[construct],
-				outputDir,
-			);
-
-			expect(subscriberInfos[0].subscribedEvents).toEqual([]);
-		});
-
-		it('should handle subscribers with multiple event types', async () => {
-			const constructs = [
-				createSubscriberConstruct('multiEventSubscriber', [
-					'user.created',
-					'user.updated',
-					'user.deleted',
-					'order.placed',
-				]),
-			];
-
-			const subscriberInfos = await generator.build(
-				context,
-				constructs,
-				outputDir,
-			);
-
-			expect(subscriberInfos[0].subscribedEvents).toEqual([
-				'user.created',
-				'user.updated',
-				'user.deleted',
-				'order.placed',
-			]);
-		});
-
-		it('should log generation progress', async () => {
-			const logSpy = vi.spyOn(console, 'log');
-
-			const constructs = [
-				createSubscriberConstruct('testSubscriber', ['test.event']),
-			];
-
-			await generator.build(context, constructs, outputDir);
-
-			expect(logSpy).toHaveBeenCalledWith(
-				'Generated subscriber handler: testSubscriber',
-			);
-
-			logSpy.mockRestore();
-		});
-
-		it('should return empty array for empty constructs', async () => {
-			const subscriberInfos = await generator.build(context, [], outputDir);
-			expect(subscriberInfos).toEqual([]);
-		});
-
-		it('should generate subscribers.ts file for server provider even with no subscribers', async () => {
-			const subscriberInfos = await generator.build(context, [], outputDir, {
-				provider: 'server',
-			});
-
-			expect(subscriberInfos).toEqual([]);
-
-			// Check that subscribers.ts was generated
-			const subscribersPath = join(outputDir, 'subscribers.ts');
-			const subscribersContent = await readFile(subscribersPath, 'utf-8');
-
-			expect(subscribersContent).toContain(
-				'export async function setupSubscribers',
-			);
-			expect(subscribersContent).toContain('const subscribers = [');
-			expect(subscribersContent).toContain('import type { EnvironmentParser }');
-			expect(subscribersContent).toContain('import type { Logger }');
-		});
-
-		it('should generate subscribers.ts file for server provider with subscribers', async () => {
-			const constructs = [
-				createSubscriberConstruct('userEventSubscriber', [
-					'user.created',
-					'user.updated',
-				]),
-				createSubscriberConstruct('orderEventSubscriber', ['order.placed']),
-			];
-
-			const subscriberInfos = await generator.build(
-				context,
-				constructs,
-				outputDir,
-				{ provider: 'server' },
-			);
-
-			expect(subscriberInfos).toEqual([]);
-
-			// Check that subscribers.ts was generated
-			const subscribersPath = join(outputDir, 'subscribers.ts');
-			const subscribersContent = await readFile(subscribersPath, 'utf-8');
-
-			expect(subscribersContent).toContain(
-				'export async function setupSubscribers',
-			);
-			expect(subscribersContent).toContain('import { userEventSubscriber }');
-			expect(subscribersContent).toContain('import { orderEventSubscriber }');
-			expect(subscribersContent).toContain('const subscribers = [');
-			expect(subscribersContent).toContain('userEventSubscriber');
-			expect(subscribersContent).toContain('orderEventSubscriber');
-			expect(subscribersContent).toContain(
-				'Setting up subscribers in polling mode',
-			);
-		});
-
-		it('should handle subscribers with custom environment parser patterns', async () => {
-			const customContext = {
-				...context,
-				envParserImportPattern: '{ customParser as envParser }',
-			};
-
-			const constructs = [
-				createSubscriberConstruct('customSubscriber', ['custom.event']),
-			];
-
-			await generator.build(customContext, constructs, outputDir);
-
-			const handlerPath = join(outputDir, 'subscribers', 'customSubscriber.ts');
-			const handlerContent = await readFile(handlerPath, 'utf-8');
-
-			expect(handlerContent).toContain('import { customParser as envParser }');
-		});
-
-		it('should create subscribers directory if it does not exist', async () => {
-			const constructs = [
-				createSubscriberConstruct('firstSubscriber', ['first.event']),
-			];
-
-			// outputDir does not exist yet
-			await generator.build(context, constructs, outputDir);
-
-			const subscribersDir = join(outputDir, 'subscribers');
-			const handlerPath = join(subscribersDir, 'firstSubscriber.ts');
-
-			// Should be able to read the file, meaning the directory was created
-			const content = await readFile(handlerPath, 'utf-8');
-			expect(content).toContain('AWSLambdaSubscriber');
-		});
-
-		it('should handle exported subscriber with custom name', async () => {
-			const subscriber = new SubscriberBuilder()
-				.subscribe(['custom.event'] as any)
-				.handle(async ({ events, logger }) => {
-					logger.info({ eventCount: events.length }, 'Processing events');
-				});
-
-			const construct: GeneratedConstruct<
-				Subscriber<any, any, any, any, any, any>
-			> = {
-				key: 'myCustomSubscriberName',
-				name: 'custom-name',
-				construct: subscriber,
-				path: {
-					absolute: join(tempDir, 'subscriber.ts'),
-					relative: 'subscriber.ts',
-				},
-			};
-
-			await generator.build(context, [construct], outputDir);
-
-			const handlerPath = join(
-				outputDir,
-				'subscribers',
-				'myCustomSubscriberName.ts',
-			);
-			const handlerContent = await readFile(handlerPath, 'utf-8');
-
-			expect(handlerContent).toContain(
-				'import { myCustomSubscriberName } from',
-			);
-			expect(handlerContent).toContain(
-				'new AWSLambdaSubscriber(envParser, myCustomSubscriberName)',
-			);
-		});
-
-		it('should return empty array for unsupported provider', async () => {
-			const constructs = [
-				createSubscriberConstruct('testSubscriber', ['test.event']),
-			];
-
-			const subscriberInfos = await generator.build(
-				context,
-				constructs,
-				outputDir,
-				{ provider: 'unsupported' as any },
-			);
-
-			expect(subscriberInfos).toEqual([]);
-		});
-
-		it('should generate handler files that can be imported', async () => {
-			const constructs = [
-				createSubscriberConstruct('validSubscriber', ['valid.event']),
-			];
-
-			await generator.build(context, constructs, outputDir);
-
-			const handlerPath = join(outputDir, 'subscribers', 'validSubscriber.ts');
-			const handlerContent = await readFile(handlerPath, 'utf-8');
-
-			// Check that the generated file has proper structure
-			expect(handlerContent).toContain(
-				"import { AWSLambdaSubscriber } from '@geekmidas/constructs/aws'",
-			);
-			expect(handlerContent).toContain(
-				'export const handler = adapter.handler',
-			);
-		});
-	});
-});

package/src/generators/index.ts

@@ -1,11 +0,0 @@
-export { CronGenerator } from './CronGenerator';
-export { EndpointGenerator } from './EndpointGenerator';
-export { FunctionGenerator } from './FunctionGenerator';
-export {
-	ConstructGenerator,
-	type GeneratedConstruct,
-	type GeneratorOptions,
-} from './Generator';
-export { QueueGenerator } from './QueueGenerator';
-export { SubscriberGenerator } from './SubscriberGenerator';
-export { TopicGenerator } from './TopicGenerator';