@geekmidas/cli 0.0.26 → 0.1.0

package/src/build/__tests__/index-new.spec.ts

@@ -0,0 +1,578 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { itWithDir } from '@geekmidas/testkit/os';
+import { describe, expect, vi } from 'vitest';
+import {
+  createMockCronFile,
+  createMockEndpointFile,
+  createMockFunctionFile,
+  createTestFile,
+} from '../../__tests__/test-helpers';
+import { buildCommand } from '../index';
+
+describe('buildCommand', () => {
+  itWithDir(
+    'should build endpoints, functions, and crons for multiple providers',
+    async ({ dir }) => {
+      // Create test files that will be discovered
+      await createMockEndpointFile(
+        dir,
+        'src/endpoints/users.ts',
+        'getUsersEndpoint',
+        '/users',
+        'GET',
+      );
+      await createMockEndpointFile(
+        dir,
+        'src/endpoints/posts.ts',
+        'getPostsEndpoint',
+        '/posts',
+        'GET',
+      );
+      await createMockFunctionFile(
+        dir,
+        'src/functions/process.ts',
+        'processDataFunction',
+        60,
+      );
+      await createMockCronFile(
+        dir,
+        'src/crons/cleanup.ts',
+        'cleanupCron',
+        'rate(1 day)',
+      );
+
+      // Create a basic config file
+      await createTestFile(
+        dir,
+        'gkm.config.ts',
+        `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  functions: './src/functions/**/*.ts',
+  crons: './src/crons/**/*.ts',
+  envParser: './config/env',
+  logger: './config/logger',
+};
+`,
+      );
+
+      // Create env and logger files
+      await createTestFile(dir, 'config/env.ts', 'export default {}');
+      await createTestFile(dir, 'config/logger.ts', 'export default {}');
+
+      const originalCwd = process.cwd();
+      process.chdir(dir);
+
+      try {
+        await buildCommand({ provider: 'server' });
+
+        // Check that output directories were created
+        const serverDir = join(dir, '.gkm', 'server');
+        expect(await readFile(join(serverDir, 'app.ts'), 'utf-8')).toContain(
+          'HonoEndpoint',
+        );
+      } finally {
+        process.chdir(originalCwd);
+      }
+    },
+  );
+
+  itWithDir(
+    'should perform complete build with all construct types for AWS Lambda',
+    async ({ dir }) => {
+      // Create comprehensive test setup with all construct types
+      await createMockEndpointFile(
+        dir,
+        'src/endpoints/users.ts',
+        'getUsersEndpoint',
+        '/users',
+        'GET',
+      );
+      await createMockEndpointFile(
+        dir,
+        'src/endpoints/posts.ts',
+        'getPostsEndpoint',
+        '/posts',
+        'POST',
+      );
+      await createMockFunctionFile(
+        dir,
+        'src/functions/processData.ts',
+        'processDataFunction',
+        300,
+      );
+      await createMockFunctionFile(
+        dir,
+        'src/functions/sendEmail.ts',
+        'sendEmailFunction',
+        30,
+      );
+      await createMockCronFile(
+        dir,
+        'src/crons/dailyCleanup.ts',
+        'dailyCleanupCron',
+        'rate(1 day)',
+      );
+      await createMockCronFile(
+        dir,
+        'src/crons/hourlyReport.ts',
+        'hourlyReportCron',
+        'cron(0 * * * ? *)',
+      );
+
+      // Create config
+      await createTestFile(
+        dir,
+        'gkm.config.ts',
+        `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  functions: './src/functions/**/*.ts',
+  crons: './src/crons/**/*.ts',
+  envParser: './config/env',
+  logger: './config/logger',
+};
+`,
+      );
+
+      // Create env and logger files
+      await createTestFile(dir, 'config/env.ts', 'export default {}');
+      await createTestFile(dir, 'config/logger.ts', 'export default {}');
+
+      const originalCwd = process.cwd();
+      process.chdir(dir);
+
+      try {
+        // Build for AWS Lambda
+        await buildCommand({ provider: 'aws' });
+
+        const awsLambdaDir = join(dir, '.gkm', 'aws-lambda');
+        const awsApiGatewayV2Dir = join(dir, '.gkm', 'aws-apigatewayv2');
+
+        // Verify Lambda handlers were created
+        expect(
+          await readFile(
+            join(awsLambdaDir, 'functions', 'processDataFunction.ts'),
+            'utf-8',
+          ),
+        ).toContain('AWSLambdaFunction');
+        expect(
+          await readFile(
+            join(awsLambdaDir, 'functions', 'sendEmailFunction.ts'),
+            'utf-8',
+          ),
+        ).toContain('AWSLambdaFunction');
+
+        // Verify Cron handlers were created
+        expect(
+          await readFile(
+            join(awsLambdaDir, 'crons', 'dailyCleanupCron.ts'),
+            'utf-8',
+          ),
+        ).toContain('AWSScheduledFunction');
+        expect(
+          await readFile(
+            join(awsLambdaDir, 'crons', 'hourlyReportCron.ts'),
+            'utf-8',
+          ),
+        ).toContain('AWSScheduledFunction');
+
+        // Verify API Gateway handlers were created
+        expect(
+          await readFile(
+            join(awsApiGatewayV2Dir, 'getUsersEndpoint.ts'),
+            'utf-8',
+          ),
+        ).toContain('AmazonApiGatewayV2Endpoint');
+        expect(
+          await readFile(
+            join(awsApiGatewayV2Dir, 'getPostsEndpoint.ts'),
+            'utf-8',
+          ),
+        ).toContain('AmazonApiGatewayV2Endpoint');
+
+        // Verify unified manifests were created with all construct types
+        const lambdaManifestPath = join(awsLambdaDir, 'manifest.json');
+        const apiGatewayManifestPath = join(awsApiGatewayV2Dir, 'manifest.json');
+
+        const lambdaManifest = JSON.parse(
+          await readFile(lambdaManifestPath, 'utf-8'),
+        );
+        const apiGatewayManifest = JSON.parse(
+          await readFile(apiGatewayManifestPath, 'utf-8'),
+        );
+
+        // Verify Lambda manifest structure
+        expect(lambdaManifest).toMatchObject({
+          routes: expect.arrayContaining([
+            expect.objectContaining({
+              path: '/users',
+              method: 'GET',
+              handler: expect.stringContaining('routes/getUsersEndpoint.handler'),
+            }),
+            expect.objectContaining({
+              path: '/posts',
+              method: 'POST',
+              handler: expect.stringContaining('routes/getPostsEndpoint.handler'),
+            }),
+          ]),
+          functions: expect.arrayContaining([
+            expect.objectContaining({
+              name: 'processDataFunction',
+              handler: expect.stringContaining(
+                'functions/processDataFunction.handler',
+              ),
+              timeout: 300,
+            }),
+            expect.objectContaining({
+              name: 'sendEmailFunction',
+              handler: expect.stringContaining(
+                'functions/sendEmailFunction.handler',
+              ),
+              timeout: 30,
+            }),
+          ]),
+          crons: expect.arrayContaining([
+            expect.objectContaining({
+              name: 'dailyCleanupCron',
+              handler: expect.stringContaining(
+                'crons/dailyCleanupCron.handler',
+              ),
+              schedule: 'rate(1 day)',
+            }),
+            expect.objectContaining({
+              name: 'hourlyReportCron',
+              handler: expect.stringContaining(
+                'crons/hourlyReportCron.handler',
+              ),
+              schedule: 'cron(0 * * * ? *)',
+            }),
+          ]),
+        });
+
+        // Verify API Gateway manifest structure
+        expect(apiGatewayManifest).toMatchObject({
+          routes: expect.arrayContaining([
+            expect.objectContaining({
+              path: '/users',
+              method: 'GET',
+              handler: expect.stringContaining('getUsersEndpoint.handler'),
+            }),
+            expect.objectContaining({
+              path: '/posts',
+              method: 'POST',
+              handler: expect.stringContaining('getPostsEndpoint.handler'),
+            }),
+          ]),
+          functions: [],
+          crons: [],
+        });
+
+        // Verify counts
+        expect(lambdaManifest.routes).toHaveLength(2);
+        expect(lambdaManifest.functions).toHaveLength(2);
+        expect(lambdaManifest.crons).toHaveLength(2);
+        expect(apiGatewayManifest.routes).toHaveLength(2);
+        expect(apiGatewayManifest.functions).toHaveLength(0);
+        expect(apiGatewayManifest.crons).toHaveLength(0);
+      } finally {
+        process.chdir(originalCwd);
+      }
+    },
+  );
+
+  itWithDir('should handle case with no constructs found', async ({ dir }) => {
+    // Create a basic config file with no actual construct files
+    await createTestFile(
+      dir,
+      'gkm.config.ts',
+      `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  functions: './src/functions/**/*.ts',
+  crons: './src/crons/**/*.ts',
+  envParser: './config/env',
+  logger: './config/logger',
+};
+`,
+    );
+
+    // Create env and logger files
+    await createTestFile(dir, 'config/env.ts', 'export default {}');
+    await createTestFile(dir, 'config/logger.ts', 'export default {}');
+
+    const originalCwd = process.cwd();
+    process.chdir(dir);
+
+    const logSpy = vi.spyOn(console, 'log');
+
+    try {
+      await buildCommand({ provider: 'server' });
+
+      expect(logSpy).toHaveBeenCalledWith('Found 0 endpoints');
+      expect(logSpy).toHaveBeenCalledWith('Found 0 functions');
+      expect(logSpy).toHaveBeenCalledWith('Found 0 crons');
+      expect(logSpy).toHaveBeenCalledWith(
+        'No endpoints, functions, or crons found to process',
+      );
+    } finally {
+      process.chdir(originalCwd);
+      logSpy.mockRestore();
+    }
+  });
+
+  itWithDir(
+    'should handle optional functions and crons config',
+    async ({ dir }) => {
+      // Create config with undefined functions and crons
+      await createTestFile(
+        dir,
+        'gkm.config.ts',
+        `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  functions: undefined,
+  crons: undefined,
+  envParser: './config/env',
+  logger: './config/logger',
+};
+`,
+      );
+
+      await createMockEndpointFile(
+        dir,
+        'src/endpoints/test.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      // Create env and logger files
+      await createTestFile(dir, 'config/env.ts', 'export default {}');
+      await createTestFile(dir, 'config/logger.ts', 'export default {}');
+
+      const originalCwd = process.cwd();
+      process.chdir(dir);
+
+      const logSpy = vi.spyOn(console, 'log');
+
+      try {
+        await buildCommand({ provider: 'server' });
+
+        expect(logSpy).toHaveBeenCalledWith('Found 1 endpoints');
+        expect(logSpy).toHaveBeenCalledWith('Found 0 functions');
+        expect(logSpy).toHaveBeenCalledWith('Found 0 crons');
+
+        // Should not log functions or crons loading messages
+        expect(logSpy).not.toHaveBeenCalledWith(
+          expect.stringContaining('Loading functions'),
+        );
+        expect(logSpy).not.toHaveBeenCalledWith(
+          expect.stringContaining('Loading crons'),
+        );
+      } finally {
+        process.chdir(originalCwd);
+        logSpy.mockRestore();
+      }
+    },
+  );
+
+  itWithDir(
+    'should parse envParser configuration correctly',
+    async ({ dir }) => {
+      // Create config with custom named exports
+      await createTestFile(
+        dir,
+        'gkm.config.ts',
+        `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  functions: undefined,
+  crons: undefined,
+  envParser: './config/env#customEnvParser',
+  logger: './config/logger#customLogger',
+};
+`,
+      );
+
+      await createMockEndpointFile(
+        dir,
+        'src/endpoints/test.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      // Create env and logger files with named exports
+      await createTestFile(
+        dir,
+        'config/env.ts',
+        'export const customEnvParser = {}',
+      );
+      await createTestFile(
+        dir,
+        'config/logger.ts',
+        'export const customLogger = {}',
+      );
+
+      const originalCwd = process.cwd();
+      process.chdir(dir);
+
+      try {
+        await buildCommand({ provider: 'aws' });
+
+        // Verify that a handler file was generated with correct imports
+        const handlerFile = join(dir, '.gkm/aws-apigatewayv2/testEndpoint.ts');
+        const handlerContent = await readFile(handlerFile, 'utf-8');
+        expect(handlerContent).toContain('{ customEnvParser as envParser }');
+      } finally {
+        process.chdir(originalCwd);
+      }
+    },
+  );
+
+  itWithDir(
+    'should create output directories for each provider',
+    async ({ dir }) => {
+      // Create config with multiple providers
+      await createTestFile(
+        dir,
+        'gkm.config.ts',
+        `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  functions: undefined,
+  crons: undefined,
+  envParser: './config/env',
+  logger: './config/logger',
+};
+`,
+      );
+
+      await createMockEndpointFile(
+        dir,
+        'src/endpoints/test.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      // Create env and logger files
+      await createTestFile(dir, 'config/env.ts', 'export default {}');
+      await createTestFile(dir, 'config/logger.ts', 'export default {}');
+
+      const originalCwd = process.cwd();
+      process.chdir(dir);
+
+      try {
+        await buildCommand({ provider: 'aws' });
+
+        const v2HandlerFile = join(
+          dir,
+          '.gkm/aws-apigatewayv2/testEndpoint.ts',
+        );
+
+        const v2Content = await readFile(v2HandlerFile, 'utf-8');
+
+        expect(v2Content).toContain('AmazonApiGatewayV2Endpoint');
+      } finally {
+        process.chdir(originalCwd);
+      }
+    },
+  );
+
+  itWithDir(
+    'should handle default import patterns for envParser and logger',
+    async ({ dir }) => {
+      // Create config with default import patterns
+      await createTestFile(
+        dir,
+        'gkm.config.ts',
+        `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  functions: undefined,
+  crons: undefined,
+  envParser: './config/env',
+  logger: './config/logger',
+};
+`,
+      );
+
+      await createMockEndpointFile(
+        dir,
+        'src/endpoints/test.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      // Create env and logger files with default exports
+      await createTestFile(dir, 'config/env.ts', 'export default {}');
+      await createTestFile(dir, 'config/logger.ts', 'export default {}');
+
+      const originalCwd = process.cwd();
+      process.chdir(dir);
+
+      try {
+        await buildCommand({ provider: 'aws' });
+
+        // Verify that a handler file was generated with default imports
+        const handlerFile = join(dir, '.gkm/aws-apigatewayv2/testEndpoint.ts');
+        const handlerContent = await readFile(handlerFile, 'utf-8');
+        expect(handlerContent).toContain('import envParser');
+        expect(handlerContent).not.toContain('{ envParser }');
+      } finally {
+        process.chdir(originalCwd);
+      }
+    },
+  );
+
+  itWithDir(
+    'should handle envParser pattern with same name as expected',
+    async ({ dir }) => {
+      // Create config with named exports that match expected names
+      await createTestFile(
+        dir,
+        'gkm.config.ts',
+        `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  functions: undefined,
+  crons: undefined,
+  envParser: './config/env#envParser',
+  logger: './config/logger#logger',
+};
+`,
+      );
+
+      await createMockEndpointFile(
+        dir,
+        'src/endpoints/test.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      // Create env and logger files with named exports
+      await createTestFile(dir, 'config/env.ts', 'export const envParser = {}');
+      await createTestFile(dir, 'config/logger.ts', 'export const logger = {}');
+
+      const originalCwd = process.cwd();
+      process.chdir(dir);
+
+      try {
+        await buildCommand({ provider: 'aws' });
+
+        // Verify that a handler file was generated with named imports
+        const handlerFile = join(dir, '.gkm/aws-apigatewayv2/testEndpoint.ts');
+        const handlerContent = await readFile(handlerFile, 'utf-8');
+
+        expect(handlerContent).toContain('{ envParser }');
+      } finally {
+        process.chdir(originalCwd);
+      }
+    },
+  );
+});

package/src/build/index.ts

@@ -0,0 +1,136 @@
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { Cron, Function } from '@geekmidas/api/constructs';
+import type { Endpoint } from '@geekmidas/api/server';
+import { loadConfig } from '../config';
+import {
+  CronGenerator,
+  EndpointGenerator,
+  FunctionGenerator,
+  type GeneratedConstruct,
+} from '../generators';
+import type { BuildOptions, LegacyProvider } from '../types';
+import { generateManifests } from './manifests';
+import { resolveProviders } from './providerResolver';
+import type { BuildContext } from './types';
+
+const logger = console;
+
+export async function buildCommand(options: BuildOptions): Promise<void> {
+  const config = await loadConfig();
+
+  // Resolve providers from new config format
+  const resolved = resolveProviders(config, options);
+
+  logger.log(`Building with providers: ${resolved.providers.join(', ')}`);
+  logger.log(`Loading routes from: ${config.routes}`);
+  if (config.functions) {
+    logger.log(`Loading functions from: ${config.functions}`);
+  }
+  if (config.crons) {
+    logger.log(`Loading crons from: ${config.crons}`);
+  }
+  logger.log(`Using envParser: ${config.envParser}`);
+
+  // Parse envParser configuration
+  const [envParserPath, envParserName] = config.envParser.split('#');
+  const envParserImportPattern = !envParserName
+    ? 'envParser'
+    : envParserName === 'envParser'
+      ? '{ envParser }'
+      : `{ ${envParserName} as envParser }`;
+
+  // Parse logger configuration
+  const [loggerPath, loggerName] = config.logger.split('#');
+  const loggerImportPattern = !loggerName
+    ? 'logger'
+    : loggerName === 'logger'
+      ? '{ logger }'
+      : `{ ${loggerName} as logger }`;
+
+  const buildContext: BuildContext = {
+    envParserPath,
+    envParserImportPattern,
+    loggerPath,
+    loggerImportPattern,
+  };
+
+  // Initialize generators
+  const endpointGenerator = new EndpointGenerator();
+  const functionGenerator = new FunctionGenerator();
+  const cronGenerator = new CronGenerator();
+
+  // Load all constructs in parallel
+  const [allEndpoints, allFunctions, allCrons] = await Promise.all([
+    endpointGenerator.load(config.routes),
+    config.functions ? functionGenerator.load(config.functions) : [],
+    config.crons ? cronGenerator.load(config.crons) : [],
+  ]);
+
+  logger.log(`Found ${allEndpoints.length} endpoints`);
+  logger.log(`Found ${allFunctions.length} functions`);
+  logger.log(`Found ${allCrons.length} crons`);
+
+  if (
+    allEndpoints.length === 0 &&
+    allFunctions.length === 0 &&
+    allCrons.length === 0
+  ) {
+    logger.log('No endpoints, functions, or crons found to process');
+    return;
+  }
+
+  // Build for each provider in parallel
+  await Promise.all(
+    resolved.providers.map((provider) =>
+      buildForProvider(
+        provider,
+        buildContext,
+        endpointGenerator,
+        functionGenerator,
+        cronGenerator,
+        allEndpoints,
+        allFunctions,
+        allCrons,
+        resolved.enableOpenApi,
+      ),
+    ),
+  );
+}
+
+async function buildForProvider(
+  provider: LegacyProvider,
+  context: BuildContext,
+  endpointGenerator: EndpointGenerator,
+  functionGenerator: FunctionGenerator,
+  cronGenerator: CronGenerator,
+  endpoints: GeneratedConstruct<Endpoint<any, any, any, any, any, any>>[],
+  functions: GeneratedConstruct<Function<any, any, any, any>>[],
+  crons: GeneratedConstruct<Cron<any, any, any, any>>[],
+  enableOpenApi: boolean,
+): Promise<void> {
+  const outputDir = join(process.cwd(), '.gkm', provider);
+
+  // Ensure output directory exists
+  await mkdir(outputDir, { recursive: true });
+
+  logger.log(`\nGenerating handlers for provider: ${provider}`);
+
+  // Build all constructs in parallel
+  const [routes, functionInfos, cronInfos] = await Promise.all([
+    endpointGenerator.build(context, endpoints, outputDir, {
+      provider,
+      enableOpenApi,
+    }),
+    functionGenerator.build(context, functions, outputDir, { provider }),
+    cronGenerator.build(context, crons, outputDir, { provider }),
+  ]);
+
+  // Generate manifests
+  await generateManifests(
+    outputDir,
+    routes,
+    functionInfos,
+    cronInfos,
+  );
+}