@geekmidas/cli 0.0.26 → 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

@@ -0,0 +1,445 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { Cron, ScheduleExpression } from '@geekmidas/constructs/crons';
+import { itWithDir } from '@geekmidas/testkit/os';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  cleanupDir,
+  createMockBuildContext,
+  createMockCronFile,
+  createTempDir,
+  createTestCron,
+} from '../../__tests__/test-helpers';
+import { CronGenerator } from '../CronGenerator';
+import type { GeneratedConstruct } from '../Generator';
+
+describe('CronGenerator', () => {
+  let tempDir: string;
+  let outputDir: string;
+  let generator: CronGenerator;
+  let context: ReturnType<typeof createMockBuildContext>;
+
+  beforeEach(async () => {
+    tempDir = await createTempDir();
+    outputDir = join(tempDir, 'output');
+    generator = new CronGenerator();
+    context = createMockBuildContext();
+  });
+
+  afterEach(async () => {
+    await cleanupDir(tempDir);
+  });
+
+  describe('isConstruct', () => {
+    it('should identify valid crons', () => {
+      const testCron = createTestCron('rate(1 hour)', 30);
+      expect(generator.isConstruct(testCron)).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 createMockCronConstruct = (
+      key: string,
+      schedule: ScheduleExpression = 'rate(1 hour)',
+      timeout: number = 30,
+    ): GeneratedConstruct<Cron<any, any, any, any>> => ({
+      key,
+      name: key.toLowerCase(),
+      construct: createTestCron(schedule, timeout),
+      path: {
+        absolute: join(tempDir, `${key}.ts`),
+        relative: `${key}.ts`,
+      },
+    });
+
+    describe('aws-lambda provider', () => {
+      itWithDir('should generate cron handlers', async ({ dir }) => {
+        const outputDir = join(dir, 'output');
+        const cronsDir = join(dir, 'crons');
+        await mkdir(outputDir, { recursive: true });
+
+        await Promise.all([
+          createMockCronFile(
+            cronsDir,
+            'dailyReport.ts',
+            'dailyReport',
+            'rate(1 day)',
+          ),
+          createMockCronFile(
+            cronsDir,
+            'hourlyCleanup.ts',
+            'hourlyCleanup',
+            'rate(1 hour)',
+          ),
+          createMockCronFile(
+            cronsDir,
+            'weeklyBackup.ts',
+            'weeklyBackup',
+            'cron(0 0 ? * SUN *)',
+          ),
+        ]);
+
+        const constructs = await generator.load('**/crons/*.ts', dir);
+
+        const cronInfos = await generator.build(
+          context,
+          constructs,
+          outputDir,
+          { provider: 'aws-lambda' },
+        );
+
+        expect(cronInfos).toHaveLength(3);
+
+        // Find crons by name since order may vary
+        const dailyReport = cronInfos.find((c) => c.name === 'dailyReport');
+        const hourlyCleanup = cronInfos.find((c) => c.name === 'hourlyCleanup');
+        const weeklyBackup = cronInfos.find((c) => c.name === 'weeklyBackup');
+
+        expect(dailyReport).toMatchObject({
+          name: 'dailyReport',
+          handler: expect.stringContaining('crons/dailyReport.handler'),
+          schedule: 'rate(1 day)',
+        });
+        expect(hourlyCleanup).toMatchObject({
+          name: 'hourlyCleanup',
+          handler: expect.stringContaining('crons/hourlyCleanup.handler'),
+          schedule: 'rate(1 hour)',
+        });
+        expect(weeklyBackup).toMatchObject({
+          name: 'weeklyBackup',
+          handler: expect.stringContaining('crons/weeklyBackup.handler'),
+          schedule: 'cron(0 0 ? * SUN *)',
+        });
+
+        // Check that handler files were created
+        const dailyReportHandlerPath = join(
+          outputDir,
+          'crons',
+          'dailyReport.ts',
+        );
+        const dailyReportContent = await readFile(
+          dailyReportHandlerPath,
+          'utf-8',
+        );
+        expect(dailyReportContent).toContain('AWSScheduledFunction');
+        expect(dailyReportContent).toContain('import { dailyReport }');
+        expect(dailyReportContent).toContain('import envParser');
+        expect(dailyReportContent).toContain('import logger');
+
+        const hourlyCleanupHandlerPath = join(
+          outputDir,
+          'crons',
+          'hourlyCleanup.ts',
+        );
+        const hourlyCleanupContent = await readFile(
+          hourlyCleanupHandlerPath,
+          'utf-8',
+        );
+        expect(hourlyCleanupContent).toContain('AWSScheduledFunction');
+        expect(hourlyCleanupContent).toContain('import { hourlyCleanup }');
+      });
+
+      it('should use default schedule when none provided', async () => {
+        // Create a cron with empty schedule that will use default
+        const cronWithDefaultSchedule = createTestCron(undefined, 30);
+
+        const construct: GeneratedConstruct<Cron<any, any, any, any>> = {
+          key: 'defaultScheduleCron',
+          name: 'default-schedule-cron',
+          construct: cronWithDefaultSchedule,
+          path: {
+            absolute: join(tempDir, 'defaultScheduleCron.ts'),
+            relative: 'defaultScheduleCron.ts',
+          },
+        };
+
+        const cronInfos = await generator.build(
+          context,
+          [construct],
+          outputDir,
+          { provider: 'aws-lambda' },
+        );
+
+        // Since the construct has a schedule, it should use that or default logic
+        expect(cronInfos[0].schedule).toBeDefined();
+      });
+
+      itWithDir(
+        'should generate correct relative import paths',
+        async ({ dir }) => {
+          const outputDir = join(dir, 'output');
+          const nestedDir = join(dir, 'src', 'crons', 'deep');
+          await mkdir(outputDir, { recursive: true });
+
+          await createMockCronFile(
+            nestedDir,
+            'deepCron.ts',
+            'deepCron',
+            'rate(1 day)',
+          );
+
+          const constructs = await generator.load(
+            '**/src/crons/deep/*.ts',
+            dir,
+          );
+
+          await generator.build(context, constructs, outputDir, {
+            provider: 'aws-lambda',
+          });
+
+          const handlerPath = join(outputDir, 'crons', 'deepCron.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\/crons\/deep\/deepCron\.js['"]+/,
+          );
+          expect(handlerContent).toMatch(/from ['"]+.*\/env['"]+/);
+          expect(handlerContent).toMatch(/from ['"]+.*\/logger['"]+/);
+        },
+      );
+
+      itWithDir('should log generation progress', async ({ dir }) => {
+        const logSpy = vi.spyOn(console, 'log');
+        const outputDir = join(dir, 'output');
+        const cronsDir = join(dir, 'crons');
+        await mkdir(outputDir, { recursive: true });
+
+        await createMockCronFile(
+          cronsDir,
+          'testCron.ts',
+          'testCron',
+          'rate(1 hour)',
+        );
+
+        const constructs = await generator.load('**/crons/*.ts', dir);
+
+        await generator.build(context, constructs, outputDir, {
+          provider: 'aws-lambda',
+        });
+
+        expect(logSpy).toHaveBeenCalledWith('Generated cron handler: testCron');
+
+        logSpy.mockRestore();
+      });
+    });
+
+    describe('non aws-lambda provider', () => {
+      itWithDir(
+        'should return empty array for server provider',
+        async ({ dir }) => {
+          const outputDir = join(dir, 'output');
+          const cronsDir = join(dir, 'crons');
+          await mkdir(outputDir, { recursive: true });
+
+          await createMockCronFile(
+            cronsDir,
+            'testCron.ts',
+            'testCron',
+            'rate(1 hour)',
+          );
+
+          const constructs = await generator.load('**/crons/*.ts', dir);
+
+          const cronInfos = await generator.build(
+            context,
+            constructs,
+            outputDir,
+            { provider: 'server' },
+          );
+
+          expect(cronInfos).toEqual([]);
+        },
+      );
+
+      itWithDir(
+        'should return empty array for aws-apigatewayv1 provider',
+        async ({ dir }) => {
+          const outputDir = join(dir, 'output');
+          const cronsDir = join(dir, 'crons');
+          await mkdir(outputDir, { recursive: true });
+
+          await createMockCronFile(
+            cronsDir,
+            'testCron.ts',
+            'testCron',
+            'rate(1 hour)',
+          );
+
+          const constructs = await generator.load('**/crons/*.ts', dir);
+
+          const cronInfos = await generator.build(
+            context,
+            constructs,
+            outputDir,
+            { provider: 'aws-apigatewayv1' },
+          );
+
+          expect(cronInfos).toEqual([]);
+        },
+      );
+    });
+
+    it('should return empty array for empty constructs', async () => {
+      const cronInfos = await generator.build(context, [], outputDir, {
+        provider: 'aws-lambda',
+      });
+      expect(cronInfos).toEqual([]);
+    });
+
+    itWithDir(
+      'should use default provider when none specified',
+      async ({ dir }) => {
+        const outputDir = join(dir, 'output');
+        const cronsDir = join(dir, 'crons');
+        await mkdir(outputDir, { recursive: true });
+
+        await createMockCronFile(
+          cronsDir,
+          'defaultCron.ts',
+          'defaultCron',
+          'rate(1 hour)',
+        );
+
+        const constructs = await generator.load('**/crons/*.ts', dir);
+
+        const cronInfos = await generator.build(context, constructs, outputDir);
+
+        expect(cronInfos).toHaveLength(1);
+        expect(cronInfos[0].name).toBe('defaultCron');
+
+        // Check that handler was created (default is aws-lambda)
+        const handlerPath = join(outputDir, 'crons', 'defaultCron.ts');
+        const handlerContent = await readFile(handlerPath, 'utf-8');
+        expect(handlerContent).toContain('AWSScheduledFunction');
+      },
+    );
+
+    itWithDir('should handle various schedule expressions', async ({ dir }) => {
+      const outputDir = join(dir, 'output');
+      const cronsDir = join(dir, 'crons');
+      await mkdir(outputDir, { recursive: true });
+
+      await Promise.all([
+        createMockCronFile(
+          cronsDir,
+          'rateCron.ts',
+          'rateCron',
+          'rate(5 minutes)',
+        ),
+        createMockCronFile(
+          cronsDir,
+          'cronExpression.ts',
+          'cronExpression',
+          'cron(0 12 * * ? *)',
+        ),
+        createMockCronFile(
+          cronsDir,
+          'dailyRate.ts',
+          'dailyRate',
+          'rate(1 day)',
+        ),
+      ]);
+
+      const constructs = await generator.load('**/crons/*.ts', dir);
+
+      const cronInfos = await generator.build(context, constructs, outputDir, {
+        provider: 'aws-lambda',
+      });
+
+      // Find crons by name since order may vary
+      const rateCron = cronInfos.find((c) => c.name === 'rateCron');
+      const cronExpression = cronInfos.find((c) => c.name === 'cronExpression');
+      const dailyRate = cronInfos.find((c) => c.name === 'dailyRate');
+
+      expect(rateCron?.schedule).toBe('rate(5 minutes)');
+      expect(cronExpression?.schedule).toBe('cron(0 12 * * ? *)');
+      expect(dailyRate?.schedule).toBe('rate(1 day)');
+    });
+
+    itWithDir(
+      'should handle crons with different timeout values',
+      async ({ dir }) => {
+        const outputDir = join(dir, 'output');
+        const cronsDir = join(dir, 'crons');
+        await mkdir(outputDir, { recursive: true });
+
+        await Promise.all([
+          createMockCronFile(
+            cronsDir,
+            'quickCron.ts',
+            'quickCron',
+            'rate(1 minute)',
+          ),
+          createMockCronFile(
+            cronsDir,
+            'slowCron.ts',
+            'slowCron',
+            'rate(1 hour)',
+          ),
+        ]);
+
+        const constructs = await generator.load('**/crons/*.ts', dir);
+
+        const cronInfos = await generator.build(
+          context,
+          constructs,
+          outputDir,
+          {
+            provider: 'aws-lambda',
+          },
+        );
+
+        // Find crons by name since order may vary
+        const quickCron = cronInfos.find((c) => c.name === 'quickCron');
+        const slowCron = cronInfos.find((c) => c.name === 'slowCron');
+
+        // Note: timeout comes from the cron construct, not the file creation
+        expect(quickCron).toBeDefined();
+        expect(slowCron).toBeDefined();
+      },
+    );
+
+    itWithDir(
+      'should handle crons with custom environment parser patterns',
+      async ({ dir }) => {
+        const outputDir = join(dir, 'output');
+        const cronsDir = join(dir, 'crons');
+        await mkdir(outputDir, { recursive: true });
+
+        const customContext = {
+          ...context,
+          envParserImportPattern: '{ customParser as envParser }',
+          loggerImportPattern: '{ customLogger as logger }',
+        };
+
+        await createMockCronFile(
+          cronsDir,
+          'customCron.ts',
+          'customCron',
+          'rate(1 hour)',
+        );
+
+        const constructs = await generator.load('**/crons/*.ts', dir);
+
+        await generator.build(customContext, constructs, outputDir, {
+          provider: 'aws-lambda',
+        });
+
+        const handlerPath = join(outputDir, 'crons', 'customCron.ts');
+        const handlerContent = await readFile(handlerPath, 'utf-8');
+
+        expect(handlerContent).toContain(
+          'import { customParser as envParser }',
+        );
+        expect(handlerContent).toContain('import { customLogger as logger }');
+      },
+    );
+  });
+});