@geekmidas/cli 0.0.26 → 0.2.0

package/src/generators/EndpointGenerator.ts

@@ -0,0 +1,389 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { Endpoint } from '@geekmidas/constructs/endpoints';
+import type { BuildContext } from '../build/types';
+import type { LegacyProvider, RouteInfo } from '../types';
+import {
+  ConstructGenerator,
+  type GeneratedConstruct,
+  type GeneratorOptions,
+} from './Generator';
+
+export class EndpointGenerator extends ConstructGenerator<
+  Endpoint<any, any, any, any, any, any>,
+  RouteInfo[]
+> {
+  isConstruct(value: any): value is Endpoint<any, any, any, any, any, any> {
+    return Endpoint.isEndpoint(value);
+  }
+
+  async build(
+    context: BuildContext,
+    constructs: GeneratedConstruct<Endpoint<any, any, any, any, any, any>>[],
+    outputDir: string,
+    options?: GeneratorOptions,
+  ): Promise<RouteInfo[]> {
+    const provider = options?.provider || 'aws-apigatewayv2';
+    const enableOpenApi = options?.enableOpenApi || false;
+    const logger = console;
+    const routes: RouteInfo[] = [];
+
+    if (constructs.length === 0) {
+      return routes;
+    }
+
+    if (provider === 'server') {
+      // Generate endpoints.ts and app.ts
+      await this.generateEndpointsFile(outputDir, constructs, context);
+      const appFile = await this.generateAppFile(outputDir, context);
+
+      routes.push({
+        path: '*',
+        method: 'ALL',
+        handler: relative(process.cwd(), appFile),
+      });
+
+      logger.log(
+        `Generated server with ${constructs.length} endpoints${enableOpenApi ? ' (OpenAPI enabled)' : ''}`,
+      );
+    } else if (provider === 'aws-lambda') {
+      // For aws-lambda, create routes subdirectory
+      const routesDir = join(outputDir, 'routes');
+      await mkdir(routesDir, { recursive: true });
+
+      // Generate individual handlers for API Gateway routes
+      for (const { key, construct, path } of constructs) {
+        const handlerFile = await this.generateHandlerFile(
+          routesDir,
+          path.relative,
+          key,
+          'aws-apigatewayv2',
+          construct,
+          context,
+        );
+
+        const routeInfo: RouteInfo = {
+          path: construct._path,
+          method: construct.method,
+          handler: relative(process.cwd(), handlerFile).replace(
+            /\.ts$/,
+            '.handler',
+          ),
+          environment: await construct.getEnvironment(),
+        };
+
+        routes.push(routeInfo);
+        logger.log(
+          `Generated handler for ${routeInfo.method} ${routeInfo.path}`,
+        );
+      }
+    } else {
+      // Generate individual handler files for AWS API Gateway providers
+      for (const { key, construct, path } of constructs) {
+        const handlerFile = await this.generateHandlerFile(
+          outputDir,
+          path.relative,
+          key,
+          provider,
+          construct,
+          context,
+        );
+
+        const routeInfo: RouteInfo = {
+          path: construct._path,
+          method: construct.method,
+          handler: relative(process.cwd(), handlerFile).replace(
+            /\.ts$/,
+            '.handler',
+          ),
+          environment: await construct.getEnvironment(),
+        };
+
+        routes.push(routeInfo);
+        logger.log(
+          `Generated handler for ${routeInfo.method} ${routeInfo.path}`,
+        );
+      }
+    }
+
+    return routes;
+  }
+
+  private async generateHandlerFile(
+    outputDir: string,
+    sourceFile: string,
+    exportName: string,
+    provider: LegacyProvider,
+    _endpoint: Endpoint<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,
+    );
+
+    let content: string;
+
+    switch (provider) {
+      case 'aws-apigatewayv1':
+        content = this.generateAWSApiGatewayV1Handler(
+          importPath,
+          exportName,
+          relativeEnvParserPath,
+          context.envParserImportPattern,
+        );
+        break;
+      case 'aws-apigatewayv2':
+        content = this.generateAWSApiGatewayV2Handler(
+          importPath,
+          exportName,
+          relativeEnvParserPath,
+          context.envParserImportPattern,
+        );
+        break;
+      case 'server':
+        content = this.generateServerHandler(importPath, exportName);
+        break;
+      default:
+        throw new Error(`Unsupported provider: ${provider}`);
+    }
+
+    await writeFile(handlerPath, content);
+    return handlerPath;
+  }
+
+  private async generateEndpointsFile(
+    outputDir: string,
+    endpoints: GeneratedConstruct<Endpoint<any, any, any, any, any, any>>[],
+    context: BuildContext,
+  ): Promise<string> {
+    const endpointsFileName = 'endpoints.ts';
+    const endpointsPath = join(outputDir, endpointsFileName);
+
+    // Group imports by file
+    const importsByFile = new Map<string, string[]>();
+
+    for (const { path, key } of endpoints) {
+      const relativePath = relative(dirname(endpointsPath), 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 = endpoints.map(({ key }) => key);
+
+    const content = `import type { EnvironmentParser } from '@geekmidas/envkit';
+import type { Logger } from '@geekmidas/logger';
+import { HonoEndpoint } from '@geekmidas/constructs/hono';
+import { Endpoint } from '@geekmidas/constructs/endpoints';
+import { ServiceDiscovery } from '@geekmidas/services';
+import type { Hono } from 'hono';
+${imports}
+
+const endpoints: Endpoint<any, any, any, any, any, any, any, any>[] = [
+  ${allExportNames.join(',\n  ')}
+];
+
+export function setupEndpoints(
+  app: Hono,
+  envParser: EnvironmentParser<any>,
+  logger: Logger,
+  enableOpenApi: boolean = true,
+): void {
+  const serviceDiscovery = ServiceDiscovery.getInstance(
+    logger,
+    envParser
+  );
+
+  // Configure OpenAPI options based on enableOpenApi flag
+  const openApiOptions: any = enableOpenApi ? {
+    docsPath: '/docs',
+    openApiOptions: {
+      title: 'API Documentation',
+      version: '1.0.0',
+      description: 'Generated API documentation'
+    }
+  } : { docsPath: false };
+
+  HonoEndpoint.addRoutes(endpoints, serviceDiscovery, app, openApiOptions);
+}
+`;
+
+    await writeFile(endpointsPath, content);
+
+    return endpointsPath;
+  }
+
+  private async generateAppFile(
+    outputDir: string,
+    context: BuildContext,
+  ): Promise<string> {
+    const appFileName = 'app.ts';
+    const appPath = join(outputDir, appFileName);
+
+    const relativeLoggerPath = relative(dirname(appPath), context.loggerPath);
+
+    const relativeEnvParserPath = relative(
+      dirname(appPath),
+      context.envParserPath,
+    );
+
+    const content = `/**
+ * Generated server application
+ *
+ * ⚠️  WARNING: This is for LOCAL DEVELOPMENT ONLY
+ * The subscriber polling mechanism is not production-ready.
+ * For production, use AWS Lambda with SQS/SNS event sources.
+ */
+import { Hono } from 'hono';
+import type { Hono as HonoType } from 'hono';
+import { setupEndpoints } from './endpoints.js';
+import { setupSubscribers } from './subscribers.js';
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+
+export interface ServerApp {
+  app: HonoType;
+  start: (options?: {
+    port?: number;
+    serve: (app: HonoType, port: number) => void | Promise<void>;
+  }) => Promise<void>;
+}
+
+/**
+ * Create and configure the Hono application
+ *
+ * @param app - Optional Hono app instance to configure (creates new one if not provided)
+ * @param enableOpenApi - Enable OpenAPI documentation (default: true)
+ * @returns Server app with configured Hono app and start function
+ *
+ * @example
+ * // With Bun
+ * import { createApp } from './.gkm/server/app.js';
+ *
+ * const { app, start } = createApp();
+ *
+ * await start({
+ *   port: 3000,
+ *   serve: (app, port) => {
+ *     Bun.serve({ port, fetch: app.fetch });
+ *   }
+ * });
+ *
+ * @example
+ * // With Node.js (using @hono/node-server)
+ * import { serve } from '@hono/node-server';
+ * import { createApp } from './.gkm/server/app.js';
+ *
+ * const { app, start } = createApp();
+ *
+ * await start({
+ *   port: 3000,
+ *   serve: (app, port) => {
+ *     serve({ fetch: app.fetch, port });
+ *   }
+ * });
+ */
+export function createApp(app?: HonoType, enableOpenApi: boolean = true): ServerApp {
+  const honoApp = app || new Hono();
+
+  // Setup HTTP endpoints
+  setupEndpoints(honoApp, envParser, logger, enableOpenApi);
+
+  return {
+    app: honoApp,
+    async start(options) {
+      if (!options?.serve) {
+        throw new Error(
+          'serve function is required. Pass a serve function for your runtime:\\n' +
+          '  - Bun: (app, port) => Bun.serve({ port, fetch: app.fetch })\\n' +
+          '  - Node: (app, port) => serve({ fetch: app.fetch, port })'
+        );
+      }
+
+      const port = options.port ?? 3000;
+
+      // Start subscribers in background (non-blocking, local development only)
+      await setupSubscribers(envParser, logger).catch((error) => {
+        logger.error({ error }, 'Failed to start subscribers');
+      });
+
+      logger.info({ port }, 'Starting server');
+
+      // Start HTTP server using provided serve function
+      await options.serve(honoApp, port);
+
+      logger.info({ port }, 'Server started');
+    }
+  };
+}
+
+// Default export for convenience
+export default createApp;
+`;
+
+    await writeFile(appPath, content);
+
+    return appPath;
+  }
+
+  private generateAWSApiGatewayV1Handler(
+    importPath: string,
+    exportName: string,
+    envParserPath: string,
+    envParserImportPattern: string,
+  ): string {
+    return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/constructs/aws';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV1Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+  }
+
+  private generateAWSApiGatewayV2Handler(
+    importPath: string,
+    exportName: string,
+    envParserPath: string,
+    envParserImportPattern: string,
+  ): string {
+    return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/constructs/aws';
+import { ${exportName} } from '${importPath}';
+import ${envParserImportPattern} from '${envParserPath}';
+
+const adapter = new AmazonApiGatewayV2Endpoint(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+  }
+
+  private generateServerHandler(
+    importPath: string,
+    exportName: string,
+  ): string {
+    return `import { ${exportName} } from '${importPath}';
+
+// Server handler - implement based on your server framework
+export const handler = ${exportName};
+`;
+  }
+}

package/src/generators/FunctionGenerator.ts

@@ -0,0 +1,97 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { Function } from '@geekmidas/constructs/functions';
+import type { BuildContext } from '../build/types';
+import type { FunctionInfo } from '../types';
+import {
+  ConstructGenerator,
+  type GeneratedConstruct,
+  type GeneratorOptions,
+} from './Generator';
+
+export class FunctionGenerator extends ConstructGenerator<
+  Function<any, any, any, any>,
+  FunctionInfo[]
+> {
+  isConstruct(value: any): value is Function<any, any, any, any> {
+    return Function.isFunction(value);
+  }
+
+  async build(
+    context: BuildContext,
+    constructs: GeneratedConstruct<Function<any, any, any, any>>[],
+    outputDir: string,
+    options?: GeneratorOptions,
+  ): Promise<FunctionInfo[]> {
+    const provider = options?.provider || 'aws-lambda';
+    const logger = console;
+    const functionInfos: FunctionInfo[] = [];
+
+    if (constructs.length === 0 || provider !== 'aws-lambda') {
+      return functionInfos;
+    }
+
+    // Create functions subdirectory
+    const functionsDir = join(outputDir, 'functions');
+    await mkdir(functionsDir, { recursive: true });
+
+    // Generate function handlers
+    for (const { key, construct, path } of constructs) {
+      const handlerFile = await this.generateFunctionHandler(
+        functionsDir,
+        path.relative,
+        key,
+        context,
+      );
+
+      functionInfos.push({
+        name: key,
+        handler: relative(process.cwd(), handlerFile).replace(
+          /\.ts$/,
+          '.handler',
+        ),
+        timeout: construct.timeout,
+        environment: await construct.getEnvironment(),
+      });
+
+      logger.log(`Generated function handler: ${key}`);
+    }
+
+    return functionInfos;
+  }
+
+  private async generateFunctionHandler(
+    outputDir: string,
+    sourceFile: string,
+    exportName: string,
+    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 relativeLoggerPath = relative(
+      dirname(handlerPath),
+      context.loggerPath,
+    );
+
+    const content = `import { AWSLambdaFunction } from '@geekmidas/constructs/functions';
+import { ${exportName} } from '${importPath}';
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+
+const adapter = new AWSLambdaFunction(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+
+    await writeFile(handlerPath, content);
+    return handlerPath;
+  }
+}

package/src/generators/Generator.ts

@@ -0,0 +1,95 @@
+import { relative } from 'path';
+import type { Construct } from '@geekmidas/constructs';
+import fg from 'fast-glob';
+import kebabCase from 'lodash.kebabcase';
+import type { BuildContext } from '../build/types';
+import type { LegacyProvider, Routes } from '../types';
+
+export interface GeneratorOptions {
+  provider?: LegacyProvider;
+  [key: string]: any;
+}
+
+export abstract class ConstructGenerator<T extends Construct, R = void> {
+  abstract isConstruct(value: any): value is T;
+
+  static async build<T extends Construct, R = void>(
+    context: BuildContext,
+    outputDir: string,
+    generator: ConstructGenerator<T, R>,
+    patterns?: Routes,
+    options?: GeneratorOptions,
+  ): Promise<R> {
+    const constructs = await generator.load(patterns);
+    return generator.build(context, constructs, outputDir, options);
+  }
+
+  abstract build(
+    context: BuildContext,
+    constructs: GeneratedConstruct<T>[],
+    outputDir: string,
+    options?: GeneratorOptions,
+  ): Promise<R>;
+
+  async load(
+    patterns?: Routes,
+    cwd = process.cwd(),
+  ): Promise<GeneratedConstruct<T>[]> {
+    const logger = console;
+
+    // Normalize patterns to array
+    const globPatterns = Array.isArray(patterns)
+      ? patterns
+      : patterns
+        ? [patterns]
+        : [];
+
+    // Find all files
+    const files = fg.stream(globPatterns, {
+      cwd,
+      absolute: true,
+    });
+
+    // Load constructs
+    const constructs: GeneratedConstruct<T>[] = [];
+
+    for await (const f of files) {
+      try {
+        const file = f.toString();
+        const module = await import(file);
+
+        // Check all exports for constructs
+        for (const [key, construct] of Object.entries(module)) {
+          if (this.isConstruct(construct)) {
+            constructs.push({
+              key,
+              name: kebabCase(key),
+              construct,
+              path: {
+                absolute: file,
+                relative: relative(process.cwd(), file),
+              },
+            });
+          }
+        }
+      } catch (error) {
+        logger.warn(`Failed to load ${f}:`, (error as Error).message);
+        throw new Error(
+          'Failed to load constructs. Please check the logs for details.',
+        );
+      }
+    }
+
+    return constructs;
+  }
+}
+
+export interface GeneratedConstruct<T extends Construct> {
+  key: string;
+  name: string;
+  construct: T;
+  path: {
+    absolute: string;
+    relative: string;
+  };
+}