@geekmidas/cli 2.0.2 → 10.0.0-alpha.0

package/src/generators/QueueGenerator.ts

@@ -1,245 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname, join, relative } from 'node:path';
-import { Queue } from '@geekmidas/constructs/queue';
-import type { BuildContext } from '../build/types';
-import type { QueueInfo } from '../types';
-import {
-	ConstructGenerator,
-	type GeneratedConstruct,
-	type GeneratorOptions,
-} from './Generator';
-
-/**
- * Generates the runtime for `q` queue workers.
- *
- * - **server** (`gkm dev`): a single `queues.ts` exposing `setupQueues()` that
- *   runs an in-process pg-boss poller alongside the Hono server — no SQS/Lambda.
- *   Each queue subscribes by its **name** on the shared event connection.
- * - **aws-lambda**: one handler file per queue wrapping `AWSLambdaQueue`, backed
- *   by an SQS event-source mapping.
- */
-export class QueueGenerator extends ConstructGenerator<
-	Queue<any, any, any, any>,
-	QueueInfo[]
-> {
-	isConstruct(value: any): value is Queue<any, any, any, any> {
-		return Queue.isQueue(value);
-	}
-
-	async build(
-		context: BuildContext,
-		constructs: GeneratedConstruct<Queue<any, any, any, any>>[],
-		outputDir: string,
-		options?: GeneratorOptions,
-	): Promise<QueueInfo[]> {
-		const provider = options?.provider || 'aws-lambda';
-		const logger = console;
-		const queueInfos: QueueInfo[] = [];
-
-		if (provider === 'server') {
-			// Generate queues.ts for in-process polling (even if empty, so the
-			// server entry can always import setupQueues).
-			await this.generateServerQueuesFile(outputDir, constructs);
-			logger.log(
-				`Generated server queues file with ${constructs.length} queues (polling mode)`,
-			);
-			return queueInfos;
-		}
-
-		if (constructs.length === 0 || provider !== 'aws-lambda') {
-			return queueInfos;
-		}
-
-		const queuesDir = join(outputDir, 'queues');
-		await mkdir(queuesDir, { recursive: true });
-
-		for (const { key, construct, path } of constructs) {
-			const handlerFile = await this.generateQueueHandler(
-				queuesDir,
-				path.relative,
-				key,
-				context,
-			);
-
-			queueInfos.push({
-				name: construct.name,
-				handler: relative(process.cwd(), handlerFile).replace(
-					/\.ts$/,
-					'.handler',
-				),
-				batchSize: construct.batchSize,
-				fifo: construct.fifo,
-				timeout: construct.timeout,
-				environment: await construct.getEnvironment({
-					markOptional: context.markOptional,
-				}),
-			});
-
-			logger.log(`Generated queue handler: ${key}`);
-		}
-
-		return queueInfos;
-	}
-
-	private async generateQueueHandler(
-		outputDir: string,
-		sourceFile: string,
-		exportName: string,
-		context: BuildContext,
-	): Promise<string> {
-		const handlerPath = join(outputDir, `${exportName}.ts`);
-		const importPath = relative(dirname(handlerPath), sourceFile).replace(
-			/\.ts$/,
-			'.js',
-		);
-		const relativeEnvParserPath = relative(
-			dirname(handlerPath),
-			context.envParserPath,
-		);
-
-		const content = `import { AWSLambdaQueue } from '@geekmidas/constructs/aws';
-import { ${exportName} } from '${importPath}';
-import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
-
-const adapter = new AWSLambdaQueue(envParser, ${exportName});
-
-export const handler = adapter.handler;
-`;
-
-		await writeFile(handlerPath, content);
-		return handlerPath;
-	}
-
-	private async generateServerQueuesFile(
-		outputDir: string,
-		queues: GeneratedConstruct<Queue<any, any, any, any>>[],
-	): Promise<string> {
-		await mkdir(outputDir, { recursive: true });
-
-		const queuesPath = join(outputDir, 'queues.ts');
-
-		// Group imports by file
-		const importsByFile = new Map<string, string[]>();
-		for (const { path, key } of queues) {
-			const importPath = relative(dirname(queuesPath), path.relative).replace(
-				/\.ts$/,
-				'.js',
-			);
-			if (!importsByFile.has(importPath)) {
-				importsByFile.set(importPath, []);
-			}
-			importsByFile.get(importPath)?.push(key);
-		}
-
-		const imports = Array.from(importsByFile.entries())
-			.map(
-				([importPath, exports]) =>
-					`import { ${exports.join(', ')} } from '${importPath}';`,
-			)
-			.join('\n');
-
-		const allExportNames = queues.map(({ key }) => key);
-
-		const content = `/**
- * Generated queue workers setup
- *
- * ⚠️  WARNING: This is for LOCAL DEVELOPMENT ONLY
- * This runs an in-process pg-boss poller alongside the HTTP server. Each queue
- * subscribes by its name on the shared event connection
- * (EVENT_SUBSCRIBER_CONNECTION_STRING), so producers using
- * <NAME>_PUBLISHER_CONNECTION_STRING (pgboss:// locally) reach it.
- *
- * For production, queues run as AWS Lambda with SQS event-source mappings.
- */
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import type { Logger } from '@geekmidas/logger';
-import { EventConnectionFactory, Subscriber } from '@geekmidas/events';
-import type { EventConnection, EventSubscriber } from '@geekmidas/events';
-import { ServiceDiscovery } from '@geekmidas/services';
-${imports}
-
-const queues = [
-  ${allExportNames.join(',\n  ')}
-];
-
-const activeSubscribers: EventSubscriber<any>[] = [];
-
-export async function setupQueues(
-  envParser: EnvironmentParser<any>,
-  logger: Logger,
-): Promise<void> {
-  if (queues.length === 0) {
-    return;
-  }
-
-  logger.info('Setting up queue workers in polling mode (local development)');
-
-  const config = envParser.create((get) => ({
-    connectionString: get('EVENT_SUBSCRIBER_CONNECTION_STRING').string(),
-  })).parse();
-
-  const serviceDiscovery = ServiceDiscovery.getInstance(envParser);
-
-  let connection: EventConnection;
-  try {
-    connection = await EventConnectionFactory.fromConnectionString(config.connectionString);
-    const connectionType = new URL(config.connectionString).protocol.replace(':', '');
-    logger.info({ connectionType }, 'Created shared event connection for queues');
-  } catch (error) {
-    logger.error({ error }, 'Failed to create event connection for queues');
-    return;
-  }
-
-  for (const queue of queues) {
-    try {
-      const eventSubscriber = await Subscriber.fromConnection(connection);
-
-      const services = queue.services.length > 0
-        ? await serviceDiscovery.register(queue.services)
-        : {};
-
-      // A queue subscribes to a single "type" — its own name.
-      await eventSubscriber.subscribe([queue.name], async (message) => {
-        try {
-          const validation = await queue.messageSchema['~standard'].validate(message.payload);
-          if (validation.issues) {
-            logger.error({ issues: validation.issues, queue: queue.name }, 'Queue message failed validation');
-            return;
-          }
-
-          await queue.handler({
-            messages: [validation.value],
-            services: services,
-            logger: queue.logger,
-          });
-
-          logger.debug({ queue: queue.name }, 'Successfully processed queue message');
-        } catch (error) {
-          logger.error({ error, queue: queue.name }, 'Failed to process queue message');
-          // Message will become visible again for retry.
-        }
-      });
-
-      activeSubscribers.push(eventSubscriber);
-      logger.info({ queue: queue.name }, 'Queue worker started polling');
-    } catch (error) {
-      logger.error({ error, queue: queue.name }, 'Failed to setup queue worker');
-    }
-  }
-
-  const shutdown = () => {
-    logger.info('Stopping all queue workers');
-    for (const _ of activeSubscribers) {
-      connection.stop();
-    }
-  };
-
-  process.on('SIGTERM', shutdown);
-  process.on('SIGINT', shutdown);
-}
-`;
-
-		await writeFile(queuesPath, content);
-		return queuesPath;
-	}
-}

package/src/generators/SubscriberGenerator.ts

@@ -1,282 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { dirname, join, relative } from 'node:path';
-import { Subscriber } from '@geekmidas/constructs/subscribers';
-import type { BuildContext } from '../build/types';
-import type { SubscriberInfo } from '../types';
-import {
-	ConstructGenerator,
-	type GeneratedConstruct,
-	type GeneratorOptions,
-} from './Generator';
-
-export class SubscriberGenerator extends ConstructGenerator<
-	Subscriber<any, any, any, any, any, any>,
-	SubscriberInfo[]
-> {
-	isConstruct(value: any): value is Subscriber<any, any, any, any, any, any> {
-		return Subscriber.isSubscriber(value);
-	}
-
-	async build(
-		context: BuildContext,
-		constructs: GeneratedConstruct<Subscriber<any, any, any, any, any, any>>[],
-		outputDir: string,
-		options?: GeneratorOptions,
-	): Promise<SubscriberInfo[]> {
-		const provider = options?.provider || 'aws-lambda';
-		const logger = console;
-		const subscriberInfos: SubscriberInfo[] = [];
-
-		if (provider === 'server') {
-			// Generate subscribers.ts for server-based polling (even if empty)
-			await this.generateServerSubscribersFile(outputDir, constructs);
-
-			logger.log(
-				`Generated server subscribers file with ${constructs.length} subscribers (polling mode)`,
-			);
-
-			// Return empty array as server subscribers don't have individual handlers
-			return subscriberInfos;
-		}
-
-		if (constructs.length === 0) {
-			return subscriberInfos;
-		}
-
-		if (provider !== 'aws-lambda') {
-			return subscriberInfos;
-		}
-
-		// Create subscribers subdirectory
-		const subscribersDir = join(outputDir, 'subscribers');
-		await mkdir(subscribersDir, { recursive: true });
-
-		// Generate subscriber handlers
-		for (const { key, construct, path } of constructs) {
-			const handlerFile = await this.generateSubscriberHandler(
-				subscribersDir,
-				path.relative,
-				key,
-				construct,
-				context,
-			);
-
-			subscriberInfos.push({
-				name: key,
-				handler: relative(process.cwd(), handlerFile).replace(
-					/\.ts$/,
-					'.handler',
-				),
-				subscribedEvents: construct.subscribedEvents || [],
-				// A subscriber bound to a topic (via `s.topic(topic)`) records the
-				// binding so infra wires the SNS subscription.
-				...(construct.topicName
-					? { transport: 'topic' as const, topic: construct.topicName }
-					: {}),
-				timeout: construct.timeout,
-				memorySize: construct.memorySize,
-				environment: await construct.getEnvironment({
-					markOptional: context.markOptional,
-				}),
-			});
-
-			logger.log(`Generated subscriber handler: ${key}`);
-		}
-
-		return subscriberInfos;
-	}
-
-	private async generateSubscriberHandler(
-		outputDir: string,
-		sourceFile: string,
-		exportName: string,
-		_subscriber: Subscriber<any, any, any, any, any, any>,
-		context: BuildContext,
-	): Promise<string> {
-		const handlerFileName = `${exportName}.ts`;
-		const handlerPath = join(outputDir, handlerFileName);
-
-		const relativePath = relative(dirname(handlerPath), sourceFile);
-		const importPath = relativePath.replace(/\.ts$/, '.js');
-
-		const relativeEnvParserPath = relative(
-			dirname(handlerPath),
-			context.envParserPath,
-		);
-
-		const content = `import { AWSLambdaSubscriber } from '@geekmidas/constructs/aws';
-import { ${exportName} } from '${importPath}';
-import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
-
-const adapter = new AWSLambdaSubscriber(envParser, ${exportName});
-
-export const handler = adapter.handler;
-`;
-
-		await writeFile(handlerPath, content);
-		return handlerPath;
-	}
-
-	private async generateServerSubscribersFile(
-		outputDir: string,
-		subscribers: GeneratedConstruct<Subscriber<any, any, any, any, any, any>>[],
-	): Promise<string> {
-		// Ensure output directory exists
-		await mkdir(outputDir, { recursive: true });
-
-		const subscribersFileName = 'subscribers.ts';
-		const subscribersPath = join(outputDir, subscribersFileName);
-
-		// Group imports by file
-		const importsByFile = new Map<string, string[]>();
-
-		for (const { path, key } of subscribers) {
-			const relativePath = relative(dirname(subscribersPath), path.relative);
-			const importPath = relativePath.replace(/\.ts$/, '.js');
-
-			if (!importsByFile.has(importPath)) {
-				importsByFile.set(importPath, []);
-			}
-			importsByFile.get(importPath)?.push(key);
-		}
-
-		// Generate import statements
-		const imports = Array.from(importsByFile.entries())
-			.map(
-				([importPath, exports]) =>
-					`import { ${exports.join(', ')} } from '${importPath}';`,
-			)
-			.join('\n');
-
-		const allExportNames = subscribers.map(({ key }) => key);
-
-		const content = `/**
- * Generated subscribers setup
- *
- * ⚠️  WARNING: This is for LOCAL DEVELOPMENT ONLY
- * This uses event polling which is not suitable for production.
- *
- * For production, use AWS Lambda with SQS/SNS event source mappings.
- * Lambda automatically:
- * - Scales based on queue depth
- * - Handles batch processing and retries
- * - Manages dead letter queues
- * - Provides better cost optimization
- *
- * This polling implementation is useful for:
- * - Local development and testing
- * - Understanding event flow without Lambda deployment
- *
- * Supported connection strings:
- * - sqs://region/account-id/queue-name (SQS queue)
- * - sns://region/account-id/topic-name (SNS topic)
- * - rabbitmq://host:port/queue-name (RabbitMQ)
- * - pgboss://user:pass@host:port/database (pg-boss / PostgreSQL)
- * - basic://in-memory (In-memory for testing)
- */
-import type { EnvironmentParser } from '@geekmidas/envkit';
-import type { Logger } from '@geekmidas/logger';
-import { EventConnectionFactory, Subscriber } from '@geekmidas/events';
-import type { EventConnection, EventSubscriber } from '@geekmidas/events';
-import { ServiceDiscovery } from '@geekmidas/services';
-${imports}
-
-const subscribers = [
-  ${allExportNames.join(',\n  ')}
-];
-
-const activeSubscribers: EventSubscriber<any>[] = [];
-
-export async function setupSubscribers(
-  envParser: EnvironmentParser<any>,
-  logger: Logger,
-): Promise<void> {
-  if (subscribers.length === 0) {
-    return;
-  }
-
-  logger.info('Setting up subscribers in polling mode (local development)');
-
-  const config = envParser.create((get) => ({
-    connectionString: get('EVENT_SUBSCRIBER_CONNECTION_STRING').string(),
-  })).parse();
-
-  const serviceDiscovery = ServiceDiscovery.getInstance(envParser);
-
-  // Create connection once, outside the loop (more efficient)
-  // EventConnectionFactory automatically determines the right connection type
-  let connection: EventConnection;
-  try {
-    connection = await EventConnectionFactory.fromConnectionString(config.connectionString);
-
-    const connectionType = new URL(config.connectionString).protocol.replace(':', '');
-    logger.info({ connectionType }, 'Created shared event connection');
-  } catch (error) {
-    logger.error({ error }, 'Failed to create event connection');
-    return;
-  }
-
-  for (const subscriber of subscribers) {
-    try {
-      // Create subscriber from shared connection
-      const eventSubscriber = await Subscriber.fromConnection(connection);
-
-      // Register services
-      const services = subscriber.services.length > 0
-        ? await serviceDiscovery.register(subscriber.services)
-        : {};
-
-      // Subscribe to events
-      const subscribedEvents = subscriber.subscribedEvents || [];
-
-      if (subscribedEvents.length === 0) {
-        logger.warn({ subscriber: subscriber.constructor.name }, 'Subscriber has no subscribed events, skipping');
-        continue;
-      }
-
-      await eventSubscriber.subscribe(subscribedEvents, async (event) => {
-        try {
-          // Process single event (batch of 1)
-          await subscriber.handler({
-            events: [event],
-            services: services as any,
-            logger: subscriber.logger,
-          });
-
-          logger.debug({ eventType: event.type }, 'Successfully processed event');
-        } catch (error) {
-          logger.error({ error, event }, 'Failed to process event');
-          // Event will become visible again for retry
-        }
-      });
-
-      activeSubscribers.push(eventSubscriber);
-
-      logger.info(
-        {
-          events: subscribedEvents,
-        },
-        'Subscriber started polling'
-      );
-    } catch (error) {
-      logger.error({ error, subscriber: subscriber.constructor.name }, 'Failed to setup subscriber');
-    }
-  }
-
-  // Setup graceful shutdown
-  const shutdown = () => {
-    logger.info('Stopping all subscribers');
-    for (const eventSubscriber of activeSubscribers) {
-      connection.stop();
-    }
-  };
-
-  process.on('SIGTERM', shutdown);
-  process.on('SIGINT', shutdown);
-}
-`;
-
-		await writeFile(subscribersPath, content);
-		return subscribersPath;
-	}
-}

package/src/generators/TopicGenerator.ts

@@ -1,45 +0,0 @@
-import { Topic } from '@geekmidas/constructs/topic';
-import type { BuildContext } from '../build/types';
-import type { TopicInfo } from '../types';
-import {
-	ConstructGenerator,
-	type GeneratedConstruct,
-	type GeneratorOptions,
-} from './Generator';
-
-/**
- * Discovers `t` topics into `manifest.topics`. A topic is a *resource*, not a
- * function — it has no handler to generate. Producers reach it via its derived
- * publisher (`topic.publisher`, whose connection string is sniffed onto the
- * producing construct) and subscribers bind via `s.topic(topic)`; this generator
- * only records the topic + its event contract so infra can provision the SNS
- * topic. Identical output for every provider (locally pg-boss routes by event
- * name, so there's nothing to run).
- */
-export class TopicGenerator extends ConstructGenerator<
-	Topic<any, any>,
-	TopicInfo[]
-> {
-	isConstruct(value: any): value is Topic<any, any> {
-		return Topic.isTopic(value);
-	}
-
-	async build(
-		_context: BuildContext,
-		constructs: GeneratedConstruct<Topic<any, any>>[],
-		_outputDir: string,
-		_options?: GeneratorOptions,
-	): Promise<TopicInfo[]> {
-		const logger = console;
-		const topicInfos = constructs.map(({ construct }) => ({
-			name: construct.name,
-			events: construct.eventTypes,
-		}));
-
-		for (const topic of topicInfos) {
-			logger.log(`Discovered topic: ${topic.name}`);
-		}
-
-		return topicInfos;
-	}
-}