@geekmidas/cli 0.1.0 → 0.2.0

package/src/build/index.ts

@@ -1,15 +1,25 @@
 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 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, LegacyProvider } from '../types';
+import type {
+  BuildOptions,
+  CronInfo,
+  FunctionInfo,
+  LegacyProvider,
+  RouteInfo,
+  SubscriberInfo,
+} from '../types';
 import { generateManifests } from './manifests';
 import { resolveProviders } from './providerResolver';
 import type { BuildContext } from './types';
@@ -30,6 +40,9 @@ export async function buildCommand(options: BuildOptions): Promise<void> {
   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
@@ -59,29 +72,40 @@ export async function buildCommand(options: BuildOptions): Promise<void> {
   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] = await Promise.all([
-    endpointGenerator.load(config.routes),
-    config.functions ? functionGenerator.load(config.functions) : [],
-    config.crons ? cronGenerator.load(config.crons) : [],
-  ]);
+  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
+    allCrons.length === 0 &&
+    allSubscribers.length === 0
   ) {
-    logger.log('No endpoints, functions, or crons found to process');
+    logger.log(
+      'No endpoints, functions, crons, or subscribers found to process',
+    );
     return;
   }
 
-  // Build for each provider in parallel
-  await Promise.all(
+  // 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,
@@ -89,13 +113,41 @@ export async function buildCommand(options: BuildOptions): Promise<void> {
         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(
@@ -104,11 +156,13 @@ async function buildForProvider(
   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<void> {
+): Promise<BuildResult> {
   const outputDir = join(process.cwd(), '.gkm', provider);
 
   // Ensure output directory exists
@@ -117,20 +171,27 @@ async function buildForProvider(
   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,
+  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

@@ -5,6 +5,7 @@ import type {
   CronInfo,
   FunctionInfo,
   RouteInfo,
+  SubscriberInfo,
 } from '../types';
 
 const logger = console;
@@ -14,19 +15,21 @@ export async function generateManifests(
   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(
-    `Generated ${routes.length} routes, ${functions.length} functions, ${crons.length} crons in ${relative(process.cwd(), outputDir)}`,
+    `\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/types.ts

@@ -1,5 +1,5 @@
-import type { Cron, Function } from '@geekmidas/api/constructs';
-import type { Endpoint } from '@geekmidas/api/server';
+import type { Cron, Function } from '@geekmidas/constructs';
+import type { Endpoint } from '@geekmidas/constructs';
 
 import type { CronInfo, FunctionInfo, RouteInfo } from '../types';
 

package/src/generators/CronGenerator.ts

@@ -1,6 +1,6 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, relative } from 'node:path';
-import { Cron } from '@geekmidas/api/constructs';
+import { Cron } from '@geekmidas/constructs/crons';
 import type { BuildContext } from '../build/types';
 import type { CronInfo } from '../types';
 import {
@@ -48,6 +48,7 @@ export class CronGenerator extends ConstructGenerator<
         ),
         schedule: construct.schedule || 'rate(1 hour)',
         timeout: construct.timeout,
+        environment: await construct.getEnvironment(),
       });
 
       logger.log(`Generated cron handler: ${key}`);
@@ -81,7 +82,7 @@ export class CronGenerator extends ConstructGenerator<
       context.loggerPath,
     );
 
-    const content = `import { AWSScheduledFunction } from '@geekmidas/api/aws-lambda';
+    const content = `import { AWSScheduledFunction } from '@geekmidas/constructs/crons';
 import { ${exportName} } from '${importPath}';
 import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
 import ${context.loggerImportPattern} from '${relativeLoggerPath}';

package/src/generators/EndpointGenerator.ts

@@ -1,6 +1,6 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, relative } from 'node:path';
-import { Endpoint } from '@geekmidas/api/server';
+import { Endpoint } from '@geekmidas/constructs/endpoints';
 import type { BuildContext } from '../build/types';
 import type { LegacyProvider, RouteInfo } from '../types';
 import {
@@ -33,22 +33,18 @@ export class EndpointGenerator extends ConstructGenerator<
     }
 
     if (provider === 'server') {
-      // Generate single server file with all endpoints
-      const serverFile = await this.generateServerFile(
-        outputDir,
-        constructs,
-        context,
-        enableOpenApi,
-      );
+      // 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(), serverFile),
+        handler: relative(process.cwd(), appFile),
       });
 
       logger.log(
-        `Generated server app with ${constructs.length} endpoints${enableOpenApi ? ' (OpenAPI enabled)' : ''}`,
+        `Generated server with ${constructs.length} endpoints${enableOpenApi ? ' (OpenAPI enabled)' : ''}`,
       );
     } else if (provider === 'aws-lambda') {
       // For aws-lambda, create routes subdirectory
@@ -73,6 +69,7 @@ export class EndpointGenerator extends ConstructGenerator<
             /\.ts$/,
             '.handler',
           ),
+          environment: await construct.getEnvironment(),
         };
 
         routes.push(routeInfo);
@@ -99,6 +96,7 @@ export class EndpointGenerator extends ConstructGenerator<
             /\.ts$/,
             '.handler',
           ),
+          environment: await construct.getEnvironment(),
         };
 
         routes.push(routeInfo);
@@ -160,20 +158,19 @@ export class EndpointGenerator extends ConstructGenerator<
     return handlerPath;
   }
 
-  private async generateServerFile(
+  private async generateEndpointsFile(
     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);
+    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(serverPath), path.relative);
+      const relativePath = relative(dirname(endpointsPath), path.relative);
       const importPath = relativePath.replace(/\.ts$/, '.js');
 
       if (!importsByFile.has(importPath)) {
@@ -182,15 +179,6 @@ export class EndpointGenerator extends ConstructGenerator<
       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(
@@ -201,21 +189,24 @@ export class EndpointGenerator extends ConstructGenerator<
 
     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}';
+    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}
 
-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 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
@@ -231,18 +222,126 @@ export function createApp(app?: Hono, enableOpenApi: boolean = ${enableOpenApi})
     }
   } : { docsPath: false };
 
-  HonoEndpoint.addRoutes(endpoints, serviceDiscovery, honoApp, openApiOptions);
+  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);
 
-  return honoApp;
+    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(serverPath, content);
+    await writeFile(appPath, content);
 
-    return serverPath;
+    return appPath;
   }
 
   private generateAWSApiGatewayV1Handler(
@@ -251,7 +350,7 @@ export default createApp;
     envParserPath: string,
     envParserImportPattern: string,
   ): string {
-    return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/api/aws-apigateway';
+    return `import { AmazonApiGatewayV1Endpoint } from '@geekmidas/constructs/aws';
 import { ${exportName} } from '${importPath}';
 import ${envParserImportPattern} from '${envParserPath}';
 
@@ -267,7 +366,7 @@ export const handler = adapter.handler;
     envParserPath: string,
     envParserImportPattern: string,
   ): string {
-    return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/api/aws-apigateway';
+    return `import { AmazonApiGatewayV2Endpoint } from '@geekmidas/constructs/aws';
 import { ${exportName} } from '${importPath}';
 import ${envParserImportPattern} from '${envParserPath}';
 

package/src/generators/FunctionGenerator.ts

@@ -1,6 +1,6 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, relative } from 'node:path';
-import { Function } from '@geekmidas/api/constructs';
+import { Function } from '@geekmidas/constructs/functions';
 import type { BuildContext } from '../build/types';
 import type { FunctionInfo } from '../types';
 import {
@@ -51,6 +51,7 @@ export class FunctionGenerator extends ConstructGenerator<
           '.handler',
         ),
         timeout: construct.timeout,
+        environment: await construct.getEnvironment(),
       });
 
       logger.log(`Generated function handler: ${key}`);
@@ -80,7 +81,7 @@ export class FunctionGenerator extends ConstructGenerator<
       context.loggerPath,
     );
 
-    const content = `import { AWSLambdaFunction } from '@geekmidas/api/aws-lambda';
+    const content = `import { AWSLambdaFunction } from '@geekmidas/constructs/functions';
 import { ${exportName} } from '${importPath}';
 import ${context.envParserImportPattern} from '${relativeEnvParserPath}';
 import ${context.loggerImportPattern} from '${relativeLoggerPath}';

package/src/generators/Generator.ts

@@ -1,5 +1,5 @@
 import { relative } from 'path';
-import type { Construct } from '@geekmidas/api/constructs';
+import type { Construct } from '@geekmidas/constructs';
 import fg from 'fast-glob';
 import kebabCase from 'lodash.kebabcase';
 import type { BuildContext } from '../build/types';