@geekmidas/cli 0.1.0 → 0.2.0

package/src/generators/SubscriberGenerator.ts

@@ -0,0 +1,271 @@
+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 (constructs.length === 0) {
+      return subscriberInfos;
+    }
+
+    if (provider === 'server') {
+      // Generate subscribers.ts for server-based polling
+      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 (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 || [],
+        timeout: construct.timeout,
+        environment: await construct.getEnvironment(),
+      });
+
+      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> {
+    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)
+ * - 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> {
+  logger.info('Setting up subscribers in polling mode (local development)');
+
+  const config = envParser.create((get) => ({
+    connectionString: get('EVENT_SUBSCRIBER_CONNECTION_STRING').string().optional(),
+  })).parse();
+
+  if (!config.connectionString) {
+    logger.warn('EVENT_SUBSCRIBER_CONNECTION_STRING not configured, skipping subscriber setup');
+    return;
+  }
+
+  const serviceDiscovery = ServiceDiscovery.getInstance(logger, 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/__tests__/CronGenerator.spec.ts

@@ -1,6 +1,6 @@
 import { mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import type { Cron, ScheduleExpression } from '@geekmidas/api/constructs';
+import type { Cron, ScheduleExpression } from '@geekmidas/constructs/crons';
 import { itWithDir } from '@geekmidas/testkit/os';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {

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

@@ -1,9 +1,10 @@
 import { mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import type { Endpoint } from '@geekmidas/api/server';
+import type { Endpoint } from '@geekmidas/constructs/endpoints';
 import { itWithDir } from '@geekmidas/testkit/os';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import type { HttpMethod } from '../../../../api/src/constructs/types';
+
+import type { HttpMethod } from '@geekmidas/constructs';
 import {
   createMockBuildContext,
   createMockEndpointFile,
@@ -91,11 +92,26 @@ describe('EndpointGenerator', () => {
     const appPath = join(outputDir, 'app.ts');
     const appContent = await readFile(appPath, 'utf-8');
 
-    expect(appContent).toContain('import { HonoEndpoint }');
-    expect(appContent).toContain('import { testEndpoint }');
-    expect(appContent).toContain('import { anotherEndpoint }');
+    expect(appContent).toContain('import { setupEndpoints }');
+    expect(appContent).toContain('import { setupSubscribers }');
+    expect(appContent).toContain('function createApp');
+    expect(appContent).toContain('app?: HonoType');
     expect(appContent).toContain('enableOpenApi: boolean = true');
-    expect(appContent).toContain("docsPath: '/docs'");
+    expect(appContent).toContain('interface ServerApp');
+    expect(appContent).toContain('async start(options');
+    expect(appContent).toContain('serve: (app: HonoType, port: number)');
+
+    // Check that the endpoints.ts file was created with endpoint logic
+    const endpointsPath = join(outputDir, 'endpoints.ts');
+    const endpointsContent = await readFile(endpointsPath, 'utf-8');
+
+    expect(endpointsContent).toContain('import { HonoEndpoint }');
+    expect(endpointsContent).toContain('import { testEndpoint }');
+    expect(endpointsContent).toContain('import { anotherEndpoint }');
+    // Function signature always defaults to true
+    expect(endpointsContent).toContain('enableOpenApi: boolean = true');
+    // OpenAPI options are configured based on the parameter
+    expect(endpointsContent).toContain("docsPath: '/docs'");
   });
 
   itWithDir(
@@ -123,8 +139,16 @@ describe('EndpointGenerator', () => {
       const appPath = join(outputDir, 'app.ts');
       const appContent = await readFile(appPath, 'utf-8');
 
-      expect(appContent).toContain('enableOpenApi: boolean = false');
-      expect(appContent).toContain('docsPath: false');
+      expect(appContent).toContain('function createApp');
+
+      // Check that the endpoints.ts file defaults to true (but can be overridden)
+      const endpointsPath = join(outputDir, 'endpoints.ts');
+      const endpointsContent = await readFile(endpointsPath, 'utf-8');
+
+      // The function signature always defaults to true
+      expect(endpointsContent).toContain('enableOpenApi: boolean = true');
+      // But the OpenAPI options are configured dynamically based on the parameter
+      expect(endpointsContent).toContain('docsPath: false');
     },
   );
 
@@ -363,9 +387,7 @@ describe('EndpointGenerator', () => {
       provider: 'server',
     });
 
-    expect(logSpy).toHaveBeenCalledWith(
-      'Generated server app with 2 endpoints',
-    );
+    expect(logSpy).toHaveBeenCalledWith('Generated server with 2 endpoints');
 
     logSpy.mockRestore();
   });

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

@@ -1,7 +1,9 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { type Function, FunctionBuilder } from '@geekmidas/api/constructs';
+import { f } from '@geekmidas/constructs/functions';
+import type { Function } from '@geekmidas/constructs/functions';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
 import {
   cleanupDir,
   createMockBuildContext,
@@ -28,16 +30,12 @@ describe('FunctionGenerator', () => {
   });
 
   describe('isConstruct', () => {
-    it('should identify valid functions', async () => {
-      // Import the actual FunctionBuilder to create a real Function instance
-
-      const { z } = await import('zod');
-
-      const testFunction = new FunctionBuilder()
+    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 }: any) => ({
+        .handle(async ({ input }) => ({
           greeting: `Hello, ${input.name}!`,
         }));
 
@@ -55,20 +53,21 @@ describe('FunctionGenerator', () => {
     const createTestFunctionConstruct = (
       key: string,
       timeout: number = 30,
-    ): GeneratedConstruct<Function<any, any, any, any>> => ({
-      key,
-      name: key.toLowerCase(),
-      construct: {
-        __IS_FUNCTION__: true,
-        type: 'dev.geekmidas.function.function',
-        timeout,
-        handle: async () => ({ greeting: 'Hello!' }),
-      } as any,
-      path: {
-        absolute: join(tempDir, `${key}.ts`),
-        relative: `${key}.ts`,
-      },
-    });
+    ): 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 () => {