@geekmidas/cli 0.2.4 → 0.4.0

package/src/build/__tests__/manifests.spec.ts

@@ -0,0 +1,346 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { itWithDir } from '@geekmidas/testkit/os';
+import { describe, expect, vi } from 'vitest';
+import type {
+  CronInfo,
+  FunctionInfo,
+  RouteInfo,
+  SubscriberInfo,
+} from '../../types';
+import { generateAwsManifest, generateServerManifest } from '../manifests';
+
+describe('generateAwsManifest', () => {
+  itWithDir('should generate AWS manifest with routes', async ({ dir }) => {
+    const routes: RouteInfo[] = [
+      {
+        path: '/users',
+        method: 'GET',
+        handler: '.gkm/aws/getUsers.handler',
+        authorizer: 'jwt',
+      },
+      {
+        path: '/users',
+        method: 'POST',
+        handler: '.gkm/aws/createUser.handler',
+        authorizer: 'jwt',
+      },
+    ];
+
+    await generateAwsManifest(dir, routes, [], [], []);
+
+    const manifestPath = join(dir, 'manifest', 'aws.ts');
+    const content = await readFile(manifestPath, 'utf-8');
+
+    expect(content).toContain('export const manifest = {');
+    expect(content).toContain('} as const;');
+    expect(content).toContain('/users');
+    expect(content).toContain('GET');
+    expect(content).toContain('POST');
+    expect(content).toContain('jwt');
+  });
+
+  itWithDir(
+    'should filter out ALL method routes from AWS manifest',
+    async ({ dir }) => {
+      const routes: RouteInfo[] = [
+        {
+          path: '/users',
+          method: 'GET',
+          handler: '.gkm/aws/getUsers.handler',
+          authorizer: 'jwt',
+        },
+        {
+          path: '*',
+          method: 'ALL',
+          handler: '.gkm/server/app.ts',
+          authorizer: 'none',
+        },
+      ];
+
+      await generateAwsManifest(dir, routes, [], [], []);
+
+      const manifestPath = join(dir, 'manifest', 'aws.ts');
+      const content = await readFile(manifestPath, 'utf-8');
+
+      expect(content).toContain('/users');
+      expect(content).toContain('GET');
+      expect(content).not.toContain('"ALL"');
+    },
+  );
+
+  itWithDir('should generate AWS manifest with functions', async ({ dir }) => {
+    const functions: FunctionInfo[] = [
+      {
+        name: 'processData',
+        handler: '.gkm/aws/processData.handler',
+        timeout: 300,
+        memorySize: 512,
+        environment: ['DATABASE_URL'],
+      },
+    ];
+
+    await generateAwsManifest(dir, [], functions, [], []);
+
+    const manifestPath = join(dir, 'manifest', 'aws.ts');
+    const content = await readFile(manifestPath, 'utf-8');
+
+    expect(content).toContain('processData');
+    expect(content).toContain('300');
+    expect(content).toContain('512');
+    expect(content).toContain('DATABASE_URL');
+  });
+
+  itWithDir('should generate AWS manifest with crons', async ({ dir }) => {
+    const crons: CronInfo[] = [
+      {
+        name: 'dailyCleanup',
+        handler: '.gkm/aws/dailyCleanup.handler',
+        schedule: 'rate(1 day)',
+        timeout: 300,
+        memorySize: 256,
+        environment: [],
+      },
+    ];
+
+    await generateAwsManifest(dir, [], [], crons, []);
+
+    const manifestPath = join(dir, 'manifest', 'aws.ts');
+    const content = await readFile(manifestPath, 'utf-8');
+
+    expect(content).toContain('dailyCleanup');
+    expect(content).toContain('rate(1 day)');
+  });
+
+  itWithDir(
+    'should generate AWS manifest with subscribers',
+    async ({ dir }) => {
+      const subscribers: SubscriberInfo[] = [
+        {
+          name: 'orderHandler',
+          handler: '.gkm/aws/orderHandler.handler',
+          subscribedEvents: ['order.created', 'order.updated'],
+          timeout: 30,
+          memorySize: 256,
+          environment: [],
+        },
+      ];
+
+      await generateAwsManifest(dir, [], [], [], subscribers);
+
+      const manifestPath = join(dir, 'manifest', 'aws.ts');
+      const content = await readFile(manifestPath, 'utf-8');
+
+      expect(content).toContain('orderHandler');
+      expect(content).toContain('order.created');
+      expect(content).toContain('order.updated');
+    },
+  );
+
+  itWithDir('should export derived types', async ({ dir }) => {
+    await generateAwsManifest(dir, [], [], [], []);
+
+    const manifestPath = join(dir, 'manifest', 'aws.ts');
+    const content = await readFile(manifestPath, 'utf-8');
+
+    expect(content).toContain('export type Route =');
+    expect(content).toContain('export type Function =');
+    expect(content).toContain('export type Cron =');
+    expect(content).toContain('export type Subscriber =');
+    expect(content).toContain('export type Authorizer =');
+    expect(content).toContain('export type HttpMethod =');
+    expect(content).toContain('export type RoutePath =');
+  });
+
+  itWithDir('should log manifest generation info', async ({ dir }) => {
+    const logSpy = vi.spyOn(console, 'log');
+
+    const routes: RouteInfo[] = [
+      {
+        path: '/users',
+        method: 'GET',
+        handler: '.gkm/aws/getUsers.handler',
+        authorizer: 'jwt',
+      },
+    ];
+
+    await generateAwsManifest(dir, routes, [], [], []);
+
+    expect(logSpy).toHaveBeenCalledWith(
+      'Generated AWS manifest with 1 routes, 0 functions, 0 crons, 0 subscribers',
+    );
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Manifest:'));
+
+    logSpy.mockRestore();
+  });
+});
+
+describe('generateServerManifest', () => {
+  itWithDir(
+    'should generate server manifest with app info',
+    async ({ dir }) => {
+      const appInfo = {
+        handler: '.gkm/server/app.ts',
+        endpoints: '.gkm/server/endpoints.ts',
+      };
+
+      await generateServerManifest(dir, appInfo, [], []);
+
+      const manifestPath = join(dir, 'manifest', 'server.ts');
+      const content = await readFile(manifestPath, 'utf-8');
+
+      expect(content).toContain('export const manifest = {');
+      expect(content).toContain('} as const;');
+      expect(content).toContain('app:');
+      expect(content).toContain('.gkm/server/app.ts');
+      expect(content).toContain('.gkm/server/endpoints.ts');
+    },
+  );
+
+  itWithDir(
+    'should generate server manifest with route metadata',
+    async ({ dir }) => {
+      const appInfo = {
+        handler: '.gkm/server/app.ts',
+        endpoints: '.gkm/server/endpoints.ts',
+      };
+
+      const routes: RouteInfo[] = [
+        {
+          path: '/users',
+          method: 'GET',
+          handler: '', // Not used for server
+          authorizer: 'jwt',
+        },
+        {
+          path: '/posts',
+          method: 'POST',
+          handler: '',
+          authorizer: 'apiKey',
+        },
+      ];
+
+      await generateServerManifest(dir, appInfo, routes, []);
+
+      const manifestPath = join(dir, 'manifest', 'server.ts');
+      const content = await readFile(manifestPath, 'utf-8');
+
+      expect(content).toContain('/users');
+      expect(content).toContain('/posts');
+      expect(content).toContain('GET');
+      expect(content).toContain('POST');
+      expect(content).toContain('jwt');
+      expect(content).toContain('apiKey');
+    },
+  );
+
+  itWithDir(
+    'should filter out ALL method routes from server manifest',
+    async ({ dir }) => {
+      const appInfo = {
+        handler: '.gkm/server/app.ts',
+        endpoints: '.gkm/server/endpoints.ts',
+      };
+
+      const routes: RouteInfo[] = [
+        {
+          path: '/users',
+          method: 'GET',
+          handler: '',
+          authorizer: 'jwt',
+        },
+        {
+          path: '*',
+          method: 'ALL',
+          handler: '',
+          authorizer: 'none',
+        },
+      ];
+
+      await generateServerManifest(dir, appInfo, routes, []);
+
+      const manifestPath = join(dir, 'manifest', 'server.ts');
+      const content = await readFile(manifestPath, 'utf-8');
+
+      expect(content).toContain('/users');
+      expect(content).not.toContain('"ALL"');
+    },
+  );
+
+  itWithDir(
+    'should generate server manifest with subscribers',
+    async ({ dir }) => {
+      const appInfo = {
+        handler: '.gkm/server/app.ts',
+        endpoints: '.gkm/server/endpoints.ts',
+      };
+
+      const subscribers: SubscriberInfo[] = [
+        {
+          name: 'orderHandler',
+          handler: '.gkm/server/orderHandler.ts',
+          subscribedEvents: ['order.created'],
+          timeout: 30,
+          memorySize: 256,
+          environment: [],
+        },
+      ];
+
+      await generateServerManifest(dir, appInfo, [], subscribers);
+
+      const manifestPath = join(dir, 'manifest', 'server.ts');
+      const content = await readFile(manifestPath, 'utf-8');
+
+      // Server manifest only includes name and events for subscribers
+      expect(content).toContain('orderHandler');
+      expect(content).toContain('order.created');
+      // Should not include handler path in server manifest subscribers
+      expect(content).not.toContain('.gkm/server/orderHandler.ts');
+    },
+  );
+
+  itWithDir('should export derived types for server', async ({ dir }) => {
+    const appInfo = {
+      handler: '.gkm/server/app.ts',
+      endpoints: '.gkm/server/endpoints.ts',
+    };
+
+    await generateServerManifest(dir, appInfo, [], []);
+
+    const manifestPath = join(dir, 'manifest', 'server.ts');
+    const content = await readFile(manifestPath, 'utf-8');
+
+    expect(content).toContain('export type Route =');
+    expect(content).toContain('export type Subscriber =');
+    expect(content).toContain('export type Authorizer =');
+    expect(content).toContain('export type HttpMethod =');
+    expect(content).toContain('export type RoutePath =');
+  });
+
+  itWithDir('should log manifest generation info', async ({ dir }) => {
+    const logSpy = vi.spyOn(console, 'log');
+
+    const appInfo = {
+      handler: '.gkm/server/app.ts',
+      endpoints: '.gkm/server/endpoints.ts',
+    };
+
+    const routes: RouteInfo[] = [
+      {
+        path: '/users',
+        method: 'GET',
+        handler: '',
+        authorizer: 'jwt',
+      },
+    ];
+
+    await generateServerManifest(dir, appInfo, routes, []);
+
+    expect(logSpy).toHaveBeenCalledWith(
+      'Generated server manifest with 1 routes, 0 subscribers',
+    );
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Manifest:'));
+
+    logSpy.mockRestore();
+  });
+});

package/src/build/index.ts

@@ -1,5 +1,5 @@
 import { mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
+import { join, relative } from 'node:path';
 import type { Cron } from '@geekmidas/constructs/crons';
 import type { Endpoint } from '@geekmidas/constructs/endpoints';
 import type { Function } from '@geekmidas/constructs/functions';
@@ -12,15 +12,12 @@ import {
   type GeneratedConstruct,
   SubscriberGenerator,
 } from '../generators';
-import type {
-  BuildOptions,
-  CronInfo,
-  FunctionInfo,
-  LegacyProvider,
-  RouteInfo,
-  SubscriberInfo,
-} from '../types';
-import { generateManifests } from './manifests';
+import type { BuildOptions, LegacyProvider, RouteInfo } from '../types';
+import {
+  type ServerAppInfo,
+  generateAwsManifest,
+  generateServerManifest,
+} from './manifests';
 import { resolveProviders } from './providerResolver';
 import type { BuildContext } from './types';
 
@@ -104,55 +101,29 @@ export async function buildCommand(options: BuildOptions): Promise<void> {
   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[];
+  // Build for each provider and generate per-provider manifests
+  for (const provider of resolved.providers) {
+    await buildForProvider(
+      provider,
+      buildContext,
+      rootOutputDir,
+      endpointGenerator,
+      functionGenerator,
+      cronGenerator,
+      subscriberGenerator,
+      allEndpoints,
+      allFunctions,
+      allCrons,
+      allSubscribers,
+      resolved.enableOpenApi,
+    );
+  }
 }
 
 async function buildForProvider(
   provider: LegacyProvider,
   context: BuildContext,
+  rootOutputDir: string,
   endpointGenerator: EndpointGenerator,
   functionGenerator: FunctionGenerator,
   cronGenerator: CronGenerator,
@@ -162,7 +133,7 @@ async function buildForProvider(
   crons: GeneratedConstruct<Cron<any, any, any, any>>[],
   subscribers: GeneratedConstruct<Subscriber<any, any, any, any, any, any>>[],
   enableOpenApi: boolean,
-): Promise<BuildResult> {
+): Promise<void> {
   const outputDir = join(process.cwd(), '.gkm', provider);
 
   // Ensure output directory exists
@@ -187,11 +158,37 @@ async function buildForProvider(
     `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,
-  };
+  // Generate provider-specific manifest
+  if (provider === 'server') {
+    // For server, collect actual route metadata from endpoint constructs
+    const routeMetadata: RouteInfo[] = await Promise.all(
+      endpoints.map(async ({ construct }) => ({
+        path: construct._path,
+        method: construct.method,
+        handler: '', // Not needed for server manifest
+        authorizer: construct.authorizer?.name ?? 'none',
+      })),
+    );
+
+    const appInfo: ServerAppInfo = {
+      handler: relative(process.cwd(), join(outputDir, 'app.ts')),
+      endpoints: relative(process.cwd(), join(outputDir, 'endpoints.ts')),
+    };
+
+    await generateServerManifest(
+      rootOutputDir,
+      appInfo,
+      routeMetadata,
+      subscriberInfos,
+    );
+  } else {
+    // For AWS providers, generate AWS manifest
+    await generateAwsManifest(
+      rootOutputDir,
+      routes,
+      functionInfos,
+      cronInfos,
+      subscriberInfos,
+    );
+  }
 }

package/src/build/manifests.ts

@@ -1,7 +1,6 @@
-import { writeFile } from 'node:fs/promises';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { join, relative } from 'path';
 import type {
-  BuildManifest,
   CronInfo,
   FunctionInfo,
   RouteInfo,
@@ -10,26 +9,99 @@ import type {
 
 const logger = console;
 
-export async function generateManifests(
+export type ManifestProvider = 'aws' | 'server';
+
+export interface ServerAppInfo {
+  handler: string;
+  endpoints: string;
+}
+
+export async function generateAwsManifest(
   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 manifestDir = join(outputDir, 'manifest');
+  await mkdir(manifestDir, { recursive: true });
+
+  // Filter out 'ALL' method routes (server-specific)
+  const awsRoutes = routes.filter((r) => r.method !== 'ALL');
+
+  const content = `export const manifest = {
+  routes: ${JSON.stringify(awsRoutes, null, 2)},
+  functions: ${JSON.stringify(functions, null, 2)},
+  crons: ${JSON.stringify(crons, null, 2)},
+  subscribers: ${JSON.stringify(subscribers, null, 2)},
+} as const;
+
+// Derived types
+export type Route = (typeof manifest.routes)[number];
+export type Function = (typeof manifest.functions)[number];
+export type Cron = (typeof manifest.crons)[number];
+export type Subscriber = (typeof manifest.subscribers)[number];
+
+// Useful union types
+export type Authorizer = Route['authorizer'];
+export type HttpMethod = Route['method'];
+export type RoutePath = Route['path'];
+`;
+
+  const manifestPath = join(manifestDir, 'aws.ts');
+  await writeFile(manifestPath, content);
+
+  logger.log(
+    `Generated AWS manifest with ${awsRoutes.length} routes, ${functions.length} functions, ${crons.length} crons, ${subscribers.length} subscribers`,
+  );
+  logger.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
+}
+
+export async function generateServerManifest(
+  outputDir: string,
+  appInfo: ServerAppInfo,
+  routes: RouteInfo[],
+  subscribers: SubscriberInfo[],
+): Promise<void> {
+  const manifestDir = join(outputDir, 'manifest');
+  await mkdir(manifestDir, { recursive: true });
+
+  // For server, extract route metadata (path, method, authorizer)
+  const serverRoutes = routes
+    .filter((r) => r.method !== 'ALL')
+    .map((r) => ({
+      path: r.path,
+      method: r.method,
+      authorizer: r.authorizer,
+    }));
+
+  // Server subscribers only need name and events
+  const serverSubscribers = subscribers.map((s) => ({
+    name: s.name,
+    subscribedEvents: s.subscribedEvents,
+  }));
+
+  const content = `export const manifest = {
+  app: ${JSON.stringify(appInfo, null, 2)},
+  routes: ${JSON.stringify(serverRoutes, null, 2)},
+  subscribers: ${JSON.stringify(serverSubscribers, null, 2)},
+} as const;
+
+// Derived types
+export type Route = (typeof manifest.routes)[number];
+export type Subscriber = (typeof manifest.subscribers)[number];
+
+// Useful union types
+export type Authorizer = Route['authorizer'];
+export type HttpMethod = Route['method'];
+export type RoutePath = Route['path'];
+`;
 
-  const manifestPath = join(outputDir, 'manifest.json');
-  await writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+  const manifestPath = join(manifestDir, 'server.ts');
+  await writeFile(manifestPath, content);
 
   logger.log(
-    `\nGenerated unified manifest with ${routes.length} routes, ${functions.length} functions, ${crons.length} crons, ${subscribers.length} subscribers`,
+    `Generated server manifest with ${serverRoutes.length} routes, ${serverSubscribers.length} subscribers`,
   );
   logger.log(`Manifest: ${relative(process.cwd(), manifestPath)}`);
 }

package/src/build/types.ts

@@ -1,5 +1,6 @@
-import type { Cron, Function } from '@geekmidas/constructs';
-import type { Endpoint } from '@geekmidas/constructs';
+import type { Cron } from '@geekmidas/constructs/crons';
+import type { Endpoint } from '@geekmidas/constructs/endpoints';
+import type { Function } from '@geekmidas/constructs/functions';
 
 import type { CronInfo, FunctionInfo, RouteInfo } from '../types';
 
@@ -23,11 +24,21 @@ export interface ProcessedCron {
   schedule?: string;
 }
 
+export interface NormalizedTelescopeConfig {
+  enabled: boolean;
+  path: string;
+  ignore: string[];
+  recordBody: boolean;
+  maxEntries: number;
+  websocket: boolean;
+}
+
 export interface BuildContext {
   envParserPath: string;
   envParserImportPattern: string;
   loggerPath: string;
   loggerImportPattern: string;
+  telescope?: NormalizedTelescopeConfig;
 }
 
 export interface ProviderBuildResult {

package/src/config.ts

@@ -2,12 +2,14 @@ import { existsSync } from 'fs';
 import { join } from 'path';
 import type { GkmConfig } from './types.ts';
 
-export async function loadConfig(): Promise<GkmConfig> {
+export async function loadConfig(
+  cwd: string = process.cwd(),
+): Promise<GkmConfig> {
   const files = ['gkm.config.json', 'gkm.config.ts', 'gkm.config.js'];
   let configPath = '';
 
   for (const file of files) {
-    const path = join(process.cwd(), file);
+    const path = join(cwd, file);
     if (existsSync(path)) {
       configPath = path;
       break;