@geekmidas/cli 0.0.26 → 0.2.0

package/src/build/index.ts

@@ -0,0 +1,197 @@
+import { mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { Cron } from '@geekmidas/constructs/crons';
+import type { Endpoint } from '@geekmidas/constructs/endpoints';
+import type { Function } from '@geekmidas/constructs/functions';
+import type { Subscriber } from '@geekmidas/constructs/subscribers';
+import { loadConfig } from '../config';
+import {
+  CronGenerator,
+  EndpointGenerator,
+  FunctionGenerator,
+  type GeneratedConstruct,
+  SubscriberGenerator,
+} from '../generators';
+import type {
+  BuildOptions,
+  CronInfo,
+  FunctionInfo,
+  LegacyProvider,
+  RouteInfo,
+  SubscriberInfo,
+} 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}`);
+  }
+  if (config.subscribers) {
+    logger.log(`Loading subscribers from: ${config.subscribers}`);
+  }
+  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();
+  const subscriberGenerator = new SubscriberGenerator();
+
+  // Load all constructs in parallel
+  const [allEndpoints, allFunctions, allCrons, allSubscribers] =
+    await Promise.all([
+      endpointGenerator.load(config.routes),
+      config.functions ? functionGenerator.load(config.functions) : [],
+      config.crons ? cronGenerator.load(config.crons) : [],
+      config.subscribers ? subscriberGenerator.load(config.subscribers) : [],
+    ]);
+
+  logger.log(`Found ${allEndpoints.length} endpoints`);
+  logger.log(`Found ${allFunctions.length} functions`);
+  logger.log(`Found ${allCrons.length} crons`);
+  logger.log(`Found ${allSubscribers.length} subscribers`);
+
+  if (
+    allEndpoints.length === 0 &&
+    allFunctions.length === 0 &&
+    allCrons.length === 0 &&
+    allSubscribers.length === 0
+  ) {
+    logger.log(
+      'No endpoints, functions, crons, or subscribers found to process',
+    );
+    return;
+  }
+
+  // Ensure .gkm directory exists
+  const rootOutputDir = join(process.cwd(), '.gkm');
+  await mkdir(rootOutputDir, { recursive: true });
+
+  // Collect all build results from each provider
+  const allBuildResults = await Promise.all(
+    resolved.providers.map((provider) =>
+      buildForProvider(
+        provider,
+        buildContext,
+        endpointGenerator,
+        functionGenerator,
+        cronGenerator,
+        subscriberGenerator,
+        allEndpoints,
+        allFunctions,
+        allCrons,
+        allSubscribers,
+        resolved.enableOpenApi,
+      ),
+    ),
+  );
+
+  // Aggregate all routes, functions, crons, and subscribers from all providers
+  const aggregatedRoutes = allBuildResults.flatMap((result) => result.routes);
+  const aggregatedFunctions = allBuildResults.flatMap(
+    (result) => result.functions,
+  );
+  const aggregatedCrons = allBuildResults.flatMap((result) => result.crons);
+  const aggregatedSubscribers = allBuildResults.flatMap(
+    (result) => result.subscribers,
+  );
+
+  // Generate single manifest at root .gkm directory
+  await generateManifests(
+    rootOutputDir,
+    aggregatedRoutes,
+    aggregatedFunctions,
+    aggregatedCrons,
+    aggregatedSubscribers,
+  );
+}
+
+interface BuildResult {
+  routes: RouteInfo[];
+  functions: FunctionInfo[];
+  crons: CronInfo[];
+  subscribers: SubscriberInfo[];
+}
+
+async function buildForProvider(
+  provider: LegacyProvider,
+  context: BuildContext,
+  endpointGenerator: EndpointGenerator,
+  functionGenerator: FunctionGenerator,
+  cronGenerator: CronGenerator,
+  subscriberGenerator: SubscriberGenerator,
+  endpoints: GeneratedConstruct<Endpoint<any, any, any, any, any, any>>[],
+  functions: GeneratedConstruct<Function<any, any, any, any>>[],
+  crons: GeneratedConstruct<Cron<any, any, any, any>>[],
+  subscribers: GeneratedConstruct<Subscriber<any, any, any, any, any, any>>[],
+  enableOpenApi: boolean,
+): Promise<BuildResult> {
+  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, subscriberInfos] = await Promise.all(
+    [
+      endpointGenerator.build(context, endpoints, outputDir, {
+        provider,
+        enableOpenApi,
+      }),
+      functionGenerator.build(context, functions, outputDir, { provider }),
+      cronGenerator.build(context, crons, outputDir, { provider }),
+      subscriberGenerator.build(context, subscribers, outputDir, { provider }),
+    ],
+  );
+
+  logger.log(
+    `Generated ${routes.length} routes, ${functionInfos.length} functions, ${cronInfos.length} crons, ${subscriberInfos.length} subscribers for ${provider}`,
+  );
+
+  // Return build results instead of generating manifest here
+  return {
+    routes,
+    functions: functionInfos,
+    crons: cronInfos,
+    subscribers: subscriberInfos,
+  };
+}

package/src/build/manifests.ts

@@ -0,0 +1,35 @@
+import { writeFile } from 'node:fs/promises';
+import { join, relative } from 'path';
+import type {
+  BuildManifest,
+  CronInfo,
+  FunctionInfo,
+  RouteInfo,
+  SubscriberInfo,
+} from '../types';
+
+const logger = console;
+
+export async function generateManifests(
+  outputDir: string,
+  routes: RouteInfo[],
+  functions: FunctionInfo[],
+  crons: CronInfo[],
+  subscribers: SubscriberInfo[],
+): Promise<void> {
+  // Generate unified manifest for all providers
+  const manifest: BuildManifest = {
+    routes,
+    functions,
+    crons,
+    subscribers,
+  };
+
+  const manifestPath = join(outputDir, 'manifest.json');
+  await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+
+  logger.log(
+    `\nGenerated unified manifest with ${routes.length} routes, ${functions.length} functions, ${crons.length} crons, ${subscribers.length} subscribers`,
+  );
+  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/constructs';
+import type { Endpoint } from '@geekmidas/constructs';
+
+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,98 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join, relative } from 'node:path';
+import { Cron } from '@geekmidas/constructs/crons';
+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,
+        environment: await construct.getEnvironment(),
+      });
+
+      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/constructs/crons';
+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;
+  }
+}