@geekmidas/cli 0.0.26 → 0.2.0

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

@@ -0,0 +1,341 @@
+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 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 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

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

package/src/index.ts

@@ -2,10 +2,10 @@
 
 import { Command } from 'commander';
 import pkg from '../package.json' assert { type: 'json' };
-import { buildCommand } from './build.ts';
+import { buildCommand } from './build/index.ts';
 import { generateReactQueryCommand } from './openapi-react-query.ts';
 import { openapiCommand } from './openapi.ts';
-import type { Provider } from './types.ts';
+import type { LegacyProvider, MainProvider } from './types.ts';
 
 const program = new Command();
 
@@ -17,34 +17,69 @@ program
 
 program
   .command('build')
-  .description('Build API handlers from endpoints')
+  .description('Build handlers from endpoints, functions, and crons')
+  .option(
+    '--provider <provider>',
+    'Target provider for generated handlers (aws, server)',
+  )
   .option(
     '--providers <providers>',
-    'Target providers for generated handlers (comma-separated)',
-    'aws-apigatewayv1',
+    '[DEPRECATED] Use --provider instead. Target providers for generated handlers (comma-separated)',
   )
   .option(
     '--enable-openapi',
     'Enable OpenAPI documentation generation for server builds',
   )
-  .action(async (options: { providers: string; enableOpenapi?: boolean }) => {
-    try {
-      const globalOptions = program.opts();
-      if (globalOptions.cwd) {
-        process.chdir(globalOptions.cwd);
+  .action(
+    async (options: {
+      provider?: string;
+      providers?: string;
+      enableOpenapi?: boolean;
+    }) => {
+      try {
+        const globalOptions = program.opts();
+        if (globalOptions.cwd) {
+          process.chdir(globalOptions.cwd);
+        }
+
+        // Handle new single provider option
+        if (options.provider) {
+          if (!['aws', 'server'].includes(options.provider)) {
+            console.error(
+              `Invalid provider: ${options.provider}. Must be 'aws' or 'server'.`,
+            );
+            process.exit(1);
+          }
+          await buildCommand({
+            provider: options.provider as MainProvider,
+            enableOpenApi: options.enableOpenapi || false,
+          });
+        }
+        // Handle legacy providers option
+        else if (options.providers) {
+          console.warn(
+            '⚠️  --providers flag is deprecated. Use --provider instead.',
+          );
+          const providerList = [
+            ...new Set(options.providers.split(',').map((p) => p.trim())),
+          ] as LegacyProvider[];
+          await buildCommand({
+            providers: providerList,
+            enableOpenApi: options.enableOpenapi || false,
+          });
+        }
+        // Default to config-driven build
+        else {
+          await buildCommand({
+            enableOpenApi: options.enableOpenapi || false,
+          });
+        }
+      } catch (error) {
+        console.error('Build failed:', (error as Error).message);
+        process.exit(1);
       }
-      const providerList = [
-        ...new Set(options.providers.split(',').map((p) => p.trim())),
-      ] as Provider[];
-      await buildCommand({
-        providers: providerList,
-        enableOpenApi: options.enableOpenapi || false,
-      });
-    } catch (error) {
-      console.error('Build failed:', (error as Error).message);
-      process.exit(1);
-    }
-  });
+    },
+  );
 
 program
   .command('cron')

package/src/openapi-react-query.ts

@@ -63,6 +63,7 @@ export async function generateReactQueryCommand(
       logger.warn('Run: npm install -D openapi-typescript');
 
       // Generate basic types file
+      await mkdir(dirname(typesPath), { recursive: true });
       await writeFile(
         typesPath,
         `// Auto-generated placeholder types
@@ -185,7 +186,7 @@ function generateReactQueryCode(
   operations: OperationInfo[],
   apiName: string,
 ): string {
-  const imports = `import { createTypedQueryClient } from '@geekmidas/api/client';
+  const imports = `import { createTypedQueryClient } from '@geekmidas/client';
 import type { paths } from './openapi-types';
 
 // Create typed query client

package/src/openapi.ts

@@ -2,9 +2,9 @@
 
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { Endpoint } from '@geekmidas/api/server';
+import { Endpoint } from '@geekmidas/constructs/endpoints';
 import { loadConfig } from './config.js';
-import { loadEndpoints } from './loadEndpoints.js';
+import { EndpointGenerator } from './generators/EndpointGenerator.js';
 
 interface OpenAPIOptions {
   output?: string;
@@ -18,9 +18,10 @@ export async function openapiCommand(
   try {
     // Load config using existing function
     const config = await loadConfig();
+    const generator = new EndpointGenerator();
 
     // Load all endpoints using the refactored function
-    const loadedEndpoints = await loadEndpoints(config.routes);
+    const loadedEndpoints = await generator.load(config.routes);
 
     if (loadedEndpoints.length === 0) {
       logger.log('No valid endpoints found');
@@ -28,7 +29,7 @@ export async function openapiCommand(
     }
 
     // Extract just the endpoint instances for OpenAPI generation
-    const endpoints = loadedEndpoints.map(({ endpoint }) => endpoint);
+    const endpoints = loadedEndpoints.map(({ construct }) => construct);
 
     // Generate OpenAPI spec using built-in method
     const spec = await Endpoint.buildOpenApiSchema(endpoints, {

package/src/types.ts

@@ -1,15 +1,58 @@
-export type Provider = 'server' | 'aws-apigatewayv1' | 'aws-apigatewayv2';
+export type MainProvider = 'aws' | 'server';
+export type LegacyProvider =
+  | 'server'
+  | 'aws-apigatewayv1'
+  | 'aws-apigatewayv2'
+  | 'aws-lambda';
 
 export type Routes = string | string[];
 
+export interface ProviderConfig {
+  enabled?: boolean;
+  outputDir?: string;
+}
+
+export interface AWSApiGatewayConfig extends ProviderConfig {
+  // Additional AWS API Gateway specific options
+}
+
+export interface AWSLambdaConfig extends ProviderConfig {
+  // Additional AWS Lambda specific options
+}
+
+export interface ServerConfig extends ProviderConfig {
+  enableOpenApi?: boolean;
+  port?: number;
+}
+
+export interface ProvidersConfig {
+  aws?: {
+    apiGateway?: {
+      v1?: boolean | AWSApiGatewayConfig;
+      v2?: boolean | AWSApiGatewayConfig;
+    };
+    lambda?: {
+      functions?: boolean | AWSLambdaConfig;
+      crons?: boolean | AWSLambdaConfig;
+    };
+  };
+  server?: boolean | ServerConfig;
+}
+
 export interface GkmConfig {
   routes: Routes;
+  functions?: Routes;
+  crons?: Routes;
+  subscribers?: Routes;
   envParser: string;
   logger: string;
+  providers?: ProvidersConfig;
 }
 
 export interface BuildOptions {
-  providers: Provider[];
+  provider?: MainProvider;
+  // Legacy support - will be deprecated
+  providers?: LegacyProvider[];
   enableOpenApi?: boolean;
 }
 
@@ -17,8 +60,54 @@ export interface RouteInfo {
   path: string;
   method: string;
   handler: string;
+  environment?: string[];
+}
+
+export interface FunctionInfo {
+  name: string;
+  handler: string;
+  timeout?: number;
+  memorySize?: number;
+  environment?: string[];
+}
+
+export interface CronInfo {
+  name: string;
+  handler: string;
+  schedule: string;
+  timeout?: number;
+  memorySize?: number;
+  environment?: string[];
+}
+
+export interface SubscriberInfo {
+  name: string;
+  handler: string;
+  subscribedEvents: string[];
+  timeout?: number;
+  memorySize?: number;
+  environment?: string[];
 }
 
 export interface RoutesManifest {
   routes: RouteInfo[];
 }
+
+export interface FunctionsManifest {
+  functions: FunctionInfo[];
+}
+
+export interface CronsManifest {
+  crons: CronInfo[];
+}
+
+export interface SubscribersManifest {
+  subscribers: SubscriberInfo[];
+}
+
+export interface BuildManifest {
+  routes: RouteInfo[];
+  functions: FunctionInfo[];
+  crons: CronInfo[];
+  subscribers: SubscriberInfo[];
+}