@geekmidas/cli 0.0.25 → 0.1.0

package/src/build/manifests.ts

@@ -0,0 +1,32 @@
+import { writeFile } from 'node:fs/promises';
+import { join, relative } from 'path';
+import type {
+  BuildManifest,
+  CronInfo,
+  FunctionInfo,
+  RouteInfo,
+} from '../types';
+
+const logger = console;
+
+export async function generateManifests(
+  outputDir: string,
+  routes: RouteInfo[],
+  functions: FunctionInfo[],
+  crons: CronInfo[],
+): Promise<void> {
+  // Generate unified manifest for all providers
+  const manifest: BuildManifest = {
+    routes,
+    functions,
+    crons,
+  };
+
+  const manifestPath = join(outputDir, 'manifest.json');
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+
+  logger.log(
+    `Generated ${routes.length} routes, ${functions.length} functions, ${crons.length} crons in ${relative(process.cwd(), outputDir)}`,
+  );
+  logger.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
+}

package/src/build/providerResolver.ts

@@ -0,0 +1,184 @@
+import type {
+  AWSApiGatewayConfig,
+  AWSLambdaConfig,
+  BuildOptions,
+  GkmConfig,
+  LegacyProvider,
+  MainProvider,
+  ProvidersConfig,
+  ServerConfig,
+} from '../types';
+
+export interface ResolvedProviders {
+  providers: LegacyProvider[];
+  enableOpenApi: boolean;
+}
+
+/**
+ * Resolves provider configuration from the new simplified system
+ * to the internal legacy format for backward compatibility
+ */
+export function resolveProviders(
+  config: GkmConfig,
+  options: BuildOptions,
+): ResolvedProviders {
+  const providers: LegacyProvider[] = [];
+  let enableOpenApi = options.enableOpenApi || false;
+
+  // Handle legacy providers option (deprecated)
+  if (options.providers) {
+    return {
+      providers: options.providers,
+      enableOpenApi,
+    };
+  }
+
+  // Handle new provider option
+  if (options.provider) {
+    const resolvedProviders = resolveMainProvider(
+      options.provider,
+      config.providers,
+    );
+    providers.push(...resolvedProviders.providers);
+    enableOpenApi = resolvedProviders.enableOpenApi || enableOpenApi;
+  }
+  // Default: build all configured providers
+  else if (config.providers) {
+    const resolvedProviders = resolveAllConfiguredProviders(config.providers);
+    providers.push(...resolvedProviders.providers);
+    enableOpenApi = resolvedProviders.enableOpenApi || enableOpenApi;
+  }
+  // Fallback: use default AWS configuration
+  else {
+    providers.push('aws-apigatewayv2', 'aws-lambda');
+  }
+
+  return {
+    providers: [...new Set(providers)], // Remove duplicates
+    enableOpenApi,
+  };
+}
+
+function resolveMainProvider(
+  mainProvider: MainProvider,
+  providersConfig?: ProvidersConfig,
+): ResolvedProviders {
+  const providers: LegacyProvider[] = [];
+  let enableOpenApi = false;
+
+  if (mainProvider === 'aws') {
+    const awsConfig = providersConfig?.aws;
+
+    // Resolve API Gateway providers
+    if (awsConfig?.apiGateway) {
+      if (isEnabled(awsConfig.apiGateway.v1)) {
+        providers.push('aws-apigatewayv1');
+      }
+      if (isEnabled(awsConfig.apiGateway.v2)) {
+        providers.push('aws-apigatewayv2');
+      }
+    } else {
+      // Default: enable v2 if no specific config
+      providers.push('aws-apigatewayv2');
+    }
+
+    // Resolve Lambda providers
+    if (awsConfig?.lambda) {
+      if (
+        isEnabled(awsConfig.lambda.functions) ||
+        isEnabled(awsConfig.lambda.crons)
+      ) {
+        providers.push('aws-lambda');
+      }
+    } else {
+      // Default: enable lambda if no specific config
+      providers.push('aws-lambda');
+    }
+  } else if (mainProvider === 'server') {
+    providers.push('server');
+    const serverConfig = providersConfig?.server;
+
+    if (typeof serverConfig === 'object' && serverConfig?.enableOpenApi) {
+      enableOpenApi = true;
+    }
+  }
+
+  return { providers, enableOpenApi };
+}
+
+function resolveAllConfiguredProviders(
+  providersConfig: ProvidersConfig,
+): ResolvedProviders {
+  const providers: LegacyProvider[] = [];
+  let enableOpenApi = false;
+
+  // AWS providers
+  if (providersConfig.aws) {
+    const awsProviders = resolveMainProvider('aws', providersConfig);
+    providers.push(...awsProviders.providers);
+  }
+
+  // Server provider
+  if (providersConfig.server && isEnabled(providersConfig.server)) {
+    providers.push('server');
+    if (
+      typeof providersConfig.server === 'object' &&
+      providersConfig.server.enableOpenApi
+    ) {
+      enableOpenApi = true;
+    }
+  }
+
+  return { providers, enableOpenApi };
+}
+
+function isEnabled(
+  config:
+    | boolean
+    | AWSApiGatewayConfig
+    | AWSLambdaConfig
+    | ServerConfig
+    | undefined,
+): boolean {
+  if (config === undefined) return false;
+  if (typeof config === 'boolean') return config;
+  return config.enabled !== false; // Default to true if enabled is not explicitly false
+}
+
+/**
+ * Gets configuration for a specific AWS service
+ */
+export function getAWSServiceConfig<
+  T extends AWSApiGatewayConfig | AWSLambdaConfig,
+>(
+  config: GkmConfig,
+  service: 'apiGateway' | 'lambda',
+  subService?: 'v1' | 'v2' | 'functions' | 'crons',
+): T | undefined {
+  const awsConfig = config.providers?.aws;
+  if (!awsConfig) return undefined;
+
+  if (service === 'apiGateway' && awsConfig.apiGateway) {
+    const apiConfig = subService
+      ? awsConfig.apiGateway[subService as 'v1' | 'v2']
+      : undefined;
+    return typeof apiConfig === 'object' ? (apiConfig as T) : undefined;
+  }
+
+  if (service === 'lambda' && awsConfig.lambda) {
+    const lambdaConfig = subService
+      ? awsConfig.lambda[subService as 'functions' | 'crons']
+      : undefined;
+    return typeof lambdaConfig === 'object' ? (lambdaConfig as T) : undefined;
+  }
+
+  return undefined;
+}
+
+/**
+ * Gets server configuration
+ */
+export function getServerConfig(config: GkmConfig): ServerConfig | undefined {
+  const serverConfig = config.providers?.server;
+  return typeof serverConfig === 'object' ? serverConfig : undefined;
+}

package/src/build/types.ts

@@ -0,0 +1,37 @@
+import type { Cron, Function } from '@geekmidas/api/constructs';
+import type { Endpoint } from '@geekmidas/api/server';
+
+import type { CronInfo, FunctionInfo, RouteInfo } from '../types';
+
+export interface ProcessedEndpoint {
+  file: string;
+  exportName: string;
+  endpoint: Endpoint<any, any, any, any, any, any>;
+  routeInfo: RouteInfo;
+}
+
+export interface ProcessedFunction {
+  file: string;
+  exportName: string;
+  fn: Function<any, any, any, any, any>;
+}
+
+export interface ProcessedCron {
+  file: string;
+  exportName: string;
+  cron: Cron<any, any, any, any>;
+  schedule?: string;
+}
+
+export interface BuildContext {
+  envParserPath: string;
+  envParserImportPattern: string;
+  loggerPath: string;
+  loggerImportPattern: string;
+}
+
+export interface ProviderBuildResult {
+  routes: RouteInfo[];
+  functions: FunctionInfo[];
+  crons: CronInfo[];
+}

package/src/config.ts

@@ -1,20 +1,28 @@
 import { existsSync } from 'fs';
 import { join } from 'path';
-import { readFile } from 'fs/promises';
 import type { GkmConfig } from './types.ts';
 
 export async function loadConfig(): Promise<GkmConfig> {
-  const configPath = join(process.cwd(), 'gkm.config.json');
+  const files = ['gkm.config.json', 'gkm.config.ts', 'gkm.config.js'];
+  let configPath = '';
 
-  if (!existsSync(configPath)) {
+  for (const file of files) {
+    const path = join(process.cwd(), file);
+    if (existsSync(path)) {
+      configPath = path;
+      break;
+    }
+  }
+
+  if (!configPath) {
     throw new Error(
-      'gkm.config.json not found. Please create a configuration file.',
+      'Configuration file not found. Please create gkm.config.json, gkm.config.ts, or gkm.config.js in the project root.',
     );
   }
 
   try {
-    const config = await readFile(configPath, 'utf-8');
-    return JSON.parse(config);
+    const config = await import(configPath);
+    return config.default;
   } catch (error) {
     throw new Error(
       `Failed to load gkm.config.json: ${(error as Error).message}`,

package/src/generators/CronGenerator.ts

@@ -0,0 +1,97 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { Cron } from '@geekmidas/api/constructs';
+import type { BuildContext } from '../build/types';
+import type { CronInfo } from '../types';
+import {
+  ConstructGenerator,
+  type GeneratedConstruct,
+  type GeneratorOptions,
+} from './Generator';
+
+export class CronGenerator extends ConstructGenerator<
+  Cron<any, any, any, any>,
+  CronInfo[]
+> {
+  async build(
+    context: BuildContext,
+    constructs: GeneratedConstruct<Cron<any, any, any, any>>[],
+    outputDir: string,
+    options?: GeneratorOptions,
+  ): Promise<CronInfo[]> {
+    const provider = options?.provider || 'aws-lambda';
+    const logger = console;
+    const cronInfos: CronInfo[] = [];
+
+    if (constructs.length === 0 || provider !== 'aws-lambda') {
+      return cronInfos;
+    }
+
+    // Create crons subdirectory
+    const cronsDir = join(outputDir, 'crons');
+    await mkdir(cronsDir, { recursive: true });
+
+    // Generate cron handlers
+    for (const { key, construct, path } of constructs) {
+      const handlerFile = await this.generateCronHandler(
+        cronsDir,
+        path.relative,
+        key,
+        context,
+      );
+
+      cronInfos.push({
+        name: key,
+        handler: relative(process.cwd(), handlerFile).replace(
+          /\.ts$/,
+          '.handler',
+        ),
+        schedule: construct.schedule || 'rate(1 hour)',
+        timeout: construct.timeout,
+      });
+
+      logger.log(`Generated cron handler: ${key}`);
+    }
+
+    return cronInfos;
+  }
+
+  isConstruct(value: any): value is Cron<any, any, any, any> {
+    return Cron.isCron(value);
+  }
+
+  private async generateCronHandler(
+    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 { AWSScheduledFunction } from '@geekmidas/api/aws-lambda';
+import { ${exportName} } from '${importPath}';
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+
+const adapter = new AWSScheduledFunction(envParser, ${exportName});
+
+export const handler = adapter.handler;
+`;
+
+    await writeFile(handlerPath, content);
+    return handlerPath;
+  }
+}

package/src/generators/EndpointGenerator.ts

@@ -0,0 +1,290 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { Endpoint } from '@geekmidas/api/server';
+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 single server file with all endpoints
+      const serverFile = await this.generateServerFile(
+        outputDir,
+        constructs,
+        context,
+        enableOpenApi,
+      );
+
+      routes.push({
+        path: '*',
+        method: 'ALL',
+        handler: relative(process.cwd(), serverFile),
+      });
+
+      logger.log(
+        `Generated server app 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',
+          ),
+        };
+
+        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',
+          ),
+        };
+
+        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 generateServerFile(
+    outputDir: string,
+    endpoints: GeneratedConstruct<Endpoint<any, any, any, any, any, any>>[],
+    context: BuildContext,
+    enableOpenApi: boolean,
+  ): Promise<string> {
+    const serverFileName = 'app.ts';
+    const serverPath = join(outputDir, serverFileName);
+
+    // Group imports by file
+    const importsByFile = new Map<string, string[]>();
+
+    for (const { path, key } of endpoints) {
+      const relativePath = relative(dirname(serverPath), path.relative);
+      const importPath = relativePath.replace(/\.ts$/, '.js');
+
+      if (!importsByFile.has(importPath)) {
+        importsByFile.set(importPath, []);
+      }
+      importsByFile.get(importPath)!.push(key);
+    }
+
+    const relativeEnvParserPath = relative(
+      dirname(serverPath),
+      context.envParserPath,
+    );
+    const relativeLoggerPath = relative(
+      dirname(serverPath),
+      context.loggerPath,
+    );
+
+    // 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 { HonoEndpoint } from '@geekmidas/api/hono';
+import { Endpoint } from '@geekmidas/api/server';
+import { ServiceDiscovery } from '@geekmidas/api/services';
+import { Hono } from 'hono';
+import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
+import ${context.loggerImportPattern} from '${relativeLoggerPath}';
+${imports}
+
+export function createApp(app?: Hono, enableOpenApi: boolean = ${enableOpenApi}): Hono {
+  const honoApp = app || new Hono();
+  
+  const endpoints: Endpoint<any, any, any, any, any, any, any>[] = [
+    ${allExportNames.join(',\n    ')}
+  ];
+
+  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, honoApp, openApiOptions);
+
+  return honoApp;
+}
+
+// Default export for convenience
+export default createApp;
+`;
+
+    await writeFile(serverPath, content);
+
+    return serverPath;
+  }
+
+  private generateAWSApiGatewayV1Handler(
+    importPath: string,
+    exportName: string,
+    envParserPath: string,
+    envParserImportPattern: string,
+  ): string {
+    return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/api/aws-apigateway';
+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/api/aws-apigateway';
+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};
+`;
+  }
+}