@geekmidas/cli 0.6.2 → 0.8.0

package/dist/{types-Bi7VzDUZ.d.mts → types-b-vwGpqc.d.cts}

@@ -1,6 +1,5 @@
 //#region src/types.d.ts
-type MainProvider = 'aws' | 'server';
-type LegacyProvider = 'server' | 'aws-apigatewayv1' | 'aws-apigatewayv2' | 'aws-lambda';
+
 type Routes = string | string[];
 interface ProviderConfig {
   enabled?: boolean;
@@ -29,6 +28,14 @@ interface TelescopeConfig {
   /** Enable WebSocket for real-time updates (default: true, requires @hono/node-ws for Node.js) */
   websocket?: boolean;
 }
+interface StudioConfig {
+  /** Enable/disable studio (default: true in development) */
+  enabled?: boolean;
+  /** Path prefix for studio UI (default: /__studio) */
+  path?: string;
+  /** Schema to introspect (default: 'public') */
+  schema?: string;
+}
 interface OpenApiConfig {
   /** Enable OpenAPI generation (default: true) */
   enabled?: boolean;
@@ -39,6 +46,33 @@ interface OpenApiConfig {
   /** API description */
   description?: string;
 }
+interface HooksConfig {
+  /**
+   * Path to a module exporting server lifecycle hooks.
+   * The module should export `beforeSetup` and/or `afterSetup` functions.
+   *
+   * @example
+   * ```typescript
+   * // src/config/hooks.ts
+   * import type { Hono } from 'hono';
+   * import type { Logger } from '@geekmidas/logger';
+   * import type { EnvironmentParser } from '@geekmidas/envkit';
+   *
+   * // Called BEFORE gkm endpoints are registered
+   * export function beforeSetup(app: Hono, ctx: { envParser: EnvironmentParser; logger: Logger }) {
+   *   app.use('*', cors());
+   *   app.get('/custom/health', (c) => c.json({ status: 'ok' }));
+   * }
+   *
+   * // Called AFTER gkm endpoints are registered
+   * export function afterSetup(app: Hono, ctx: { envParser: EnvironmentParser; logger: Logger }) {
+   *   app.notFound((c) => c.json({ error: 'Not found' }, 404));
+   *   app.onError((err, c) => c.json({ error: err.message }, 500));
+   * }
+   * ```
+   */
+  server?: string;
+}
 interface ProvidersConfig {
   aws?: {
     apiGateway?: {
@@ -60,6 +94,16 @@ interface GkmConfig {
   envParser: string;
   logger: string;
   providers?: ProvidersConfig;
+  /**
+   * Server lifecycle hooks for customizing the Hono app.
+   * Allows adding custom routes, middleware, error handlers, etc.
+   *
+   * @example
+   * hooks: {
+   *   server: './src/config/hooks'
+   * }
+   */
+  hooks?: HooksConfig;
   /**
    * Telescope configuration for debugging/monitoring.
    * Can be:
@@ -68,6 +112,16 @@ interface GkmConfig {
    * - A TelescopeConfig object for inline configuration
    */
   telescope?: string | boolean | TelescopeConfig;
+  /**
+   * Studio configuration for database browsing.
+   * Can be:
+   * - A string path to a module that exports a Studio instance (recommended)
+   * - A boolean to enable/disable with defaults
+   * - A StudioConfig object for inline configuration
+   *
+   * Requires a database connection configured via services.
+   */
+  studio?: string | boolean | StudioConfig;
   /**
    * OpenAPI generation configuration.
    * Can be:
@@ -104,55 +158,6 @@ interface GkmConfig {
    */
   env?: string | string[];
 }
-interface BuildOptions {
-  provider?: MainProvider;
-  providers?: LegacyProvider[];
-  enableOpenApi?: boolean;
-}
-interface RouteInfo {
-  path: string;
-  method: string;
-  handler: string;
-  timeout?: number;
-  memorySize?: number;
-  environment?: string[];
-  authorizer: string;
-}
-interface FunctionInfo {
-  name: string;
-  handler: string;
-  timeout?: number;
-  memorySize?: number;
-  environment?: string[];
-}
-interface CronInfo {
-  name: string;
-  handler: string;
-  schedule: string;
-  timeout?: number;
-  memorySize?: number;
-  environment?: string[];
-}
-interface SubscriberInfo {
-  name: string;
-  handler: string;
-  subscribedEvents: string[];
-  timeout?: number;
-  memorySize?: number;
-  environment?: string[];
-}
-interface RoutesManifest {
-  routes: RouteInfo[];
-}
-interface FunctionsManifest {
-  functions: FunctionInfo[];
-}
-interface CronsManifest {
-  crons: CronInfo[];
-}
-interface SubscribersManifest {
-  subscribers: SubscriberInfo[];
-}
 //#endregion
-export { AWSApiGatewayConfig, AWSLambdaConfig, BuildOptions, CronInfo, CronsManifest, FunctionInfo, FunctionsManifest, GkmConfig, LegacyProvider, MainProvider, OpenApiConfig, ProviderConfig, ProvidersConfig, RouteInfo, Routes, RoutesManifest, Runtime, ServerConfig, SubscriberInfo, SubscribersManifest, TelescopeConfig };
-//# sourceMappingURL=types-Bi7VzDUZ.d.mts.map
+export { GkmConfig, OpenApiConfig };
+//# sourceMappingURL=types-b-vwGpqc.d.cts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geekmidas/cli",
-  "version": "0.6.2",
+  "version": "0.8.0",
   "description": "CLI tools for building Lambda handlers, server applications, and generating OpenAPI specs",
   "private": false,
   "type": "module",
@@ -50,14 +50,14 @@
     "typescript": "^5.8.2",
     "vitest": "^3.2.4",
     "zod": "~4.1.13",
-    "@geekmidas/testkit": "0.1.0"
+    "@geekmidas/testkit": "0.3.1"
   },
   "peerDependencies": {
-    "@geekmidas/constructs": "~0.2.4",
-    "@geekmidas/schema": "~0.0.3",
-    "@geekmidas/logger": "~0.1.0",
     "@geekmidas/envkit": "~0.1.0",
-    "@geekmidas/telescope": "~0.0.1"
+    "@geekmidas/logger": "~0.1.0",
+    "@geekmidas/constructs": "~0.2.4",
+    "@geekmidas/telescope": "~0.1.0",
+    "@geekmidas/schema": "~0.0.3"
   },
   "peerDependenciesMeta": {
     "@geekmidas/telescope": {

package/src/__tests__/EndpointGenerator.hooks.spec.ts

@@ -0,0 +1,204 @@
+import { mkdir, readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { e } from '@geekmidas/constructs/endpoints';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type { BuildContext } from '../build/types';
+import { EndpointGenerator } from '../generators/EndpointGenerator';
+import type { GeneratedConstruct } from '../generators/Generator';
+
+// Create a minimal mock endpoint for testing
+const mockEndpoint = e.get('/test').handle(async () => ({ ok: true }));
+
+describe('EndpointGenerator hooks generation', () => {
+  const testOutputDir = join(process.cwd(), '.test-output');
+  let generator: EndpointGenerator;
+
+  // Mock endpoint construct for testing
+  const mockConstruct: GeneratedConstruct<typeof mockEndpoint> = {
+    key: 'testEndpoint',
+    construct: mockEndpoint,
+    path: {
+      relative: '/project/src/endpoints/test.ts',
+      absolute: '/project/src/endpoints/test.ts',
+    },
+  };
+
+  beforeEach(async () => {
+    generator = new EndpointGenerator();
+    await mkdir(testOutputDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(testOutputDir, { recursive: true, force: true });
+  });
+
+  const baseContext: BuildContext = {
+    envParserPath: '/project/src/config/env.ts',
+    envParserImportPattern: '{ envParser }',
+    loggerPath: '/project/src/config/logger.ts',
+    loggerImportPattern: 'logger',
+  };
+
+  describe('generateAppFile', () => {
+    it('should not include hooks when hooks config is undefined', async () => {
+      await generator.build(baseContext, [mockConstruct], testOutputDir, {
+        provider: 'server',
+      });
+
+      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+      expect(appContent).not.toContain('serverHooks');
+      expect(appContent).not.toContain('beforeSetup');
+      expect(appContent).not.toContain('afterSetup');
+    });
+
+    it('should include hooks imports when hooks config is provided', async () => {
+      const contextWithHooks: BuildContext = {
+        ...baseContext,
+        hooks: {
+          serverHooksPath: '/project/src/config/hooks.ts',
+        },
+      };
+
+      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+        provider: 'server',
+      });
+
+      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+      expect(appContent).toContain('import * as serverHooks from');
+      expect(appContent).toContain('hooks.ts');
+    });
+
+    it('should include beforeSetup hook call', async () => {
+      const contextWithHooks: BuildContext = {
+        ...baseContext,
+        hooks: {
+          serverHooksPath: '/project/src/config/hooks.ts',
+        },
+      };
+
+      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+        provider: 'server',
+      });
+
+      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+      expect(appContent).toContain(
+        "if (typeof serverHooks.beforeSetup === 'function')",
+      );
+      expect(appContent).toContain(
+        'await serverHooks.beforeSetup(honoApp, { envParser, logger })',
+      );
+    });
+
+    it('should include afterSetup hook call', async () => {
+      const contextWithHooks: BuildContext = {
+        ...baseContext,
+        hooks: {
+          serverHooksPath: '/project/src/config/hooks.ts',
+        },
+      };
+
+      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+        provider: 'server',
+      });
+
+      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+      expect(appContent).toContain(
+        "if (typeof serverHooks.afterSetup === 'function')",
+      );
+      expect(appContent).toContain(
+        'await serverHooks.afterSetup(honoApp, { envParser, logger })',
+      );
+    });
+
+    it('should place telescope before beforeSetup, and beforeSetup before endpoints', async () => {
+      const contextWithHooks: BuildContext = {
+        ...baseContext,
+        hooks: {
+          serverHooksPath: '/project/src/config/hooks.ts',
+        },
+        telescope: {
+          enabled: true,
+          path: '/__telescope',
+          maxEntries: 100,
+          recordBody: true,
+          ignore: [],
+          websocket: false,
+        },
+      };
+
+      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+        provider: 'server',
+      });
+
+      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+      // Use specific patterns to find the actual calls (not imports/comments)
+      const telescopeIndex = appContent.indexOf('createMiddleware(telescope)');
+      const beforeSetupCallIndex = appContent.indexOf(
+        'serverHooks.beforeSetup(honoApp',
+      );
+      const setupEndpointsIndex = appContent.indexOf(
+        'await setupEndpoints(honoApp',
+      );
+
+      expect(telescopeIndex).toBeGreaterThan(0);
+      expect(beforeSetupCallIndex).toBeGreaterThan(0);
+      expect(setupEndpointsIndex).toBeGreaterThan(0);
+      // Telescope middleware first (to capture all requests)
+      expect(telescopeIndex).toBeLessThan(beforeSetupCallIndex);
+      // Then beforeSetup hook
+      expect(beforeSetupCallIndex).toBeLessThan(setupEndpointsIndex);
+    });
+
+    it('should place afterSetup after setupEndpoints', async () => {
+      const contextWithHooks: BuildContext = {
+        ...baseContext,
+        hooks: {
+          serverHooksPath: '/project/src/config/hooks.ts',
+        },
+      };
+
+      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+        provider: 'server',
+      });
+
+      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+      // Use specific patterns to find the actual calls (not imports/comments)
+      const setupEndpointsIndex = appContent.indexOf(
+        'await setupEndpoints(honoApp',
+      );
+      const afterSetupCallIndex = appContent.indexOf(
+        'serverHooks.afterSetup(honoApp',
+      );
+
+      expect(setupEndpointsIndex).toBeGreaterThan(0);
+      expect(afterSetupCallIndex).toBeGreaterThan(0);
+      expect(afterSetupCallIndex).toBeGreaterThan(setupEndpointsIndex);
+    });
+
+    it('should generate correct relative import path for hooks', async () => {
+      const contextWithHooks: BuildContext = {
+        ...baseContext,
+        hooks: {
+          serverHooksPath: join(testOutputDir, '../../src/config/hooks.ts'),
+        },
+      };
+
+      await generator.build(contextWithHooks, [mockConstruct], testOutputDir, {
+        provider: 'server',
+      });
+
+      const appContent = await readFile(join(testOutputDir, 'app.ts'), 'utf-8');
+
+      // Should have a relative import path
+      expect(appContent).toMatch(
+        /import \* as serverHooks from '\.\.\/.*hooks\.ts'/,
+      );
+    });
+  });
+});

package/src/__tests__/normalizeHooksConfig.spec.ts

@@ -0,0 +1,63 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { normalizeHooksConfig } from '../dev';
+
+describe('normalizeHooksConfig', () => {
+  const originalCwd = process.cwd();
+
+  beforeEach(() => {
+    vi.spyOn(process, 'cwd').mockReturnValue('/test/project');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should return undefined when hooks config is undefined', () => {
+    const result = normalizeHooksConfig(undefined);
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined when hooks config is empty object', () => {
+    const result = normalizeHooksConfig({});
+    expect(result).toBeUndefined();
+  });
+
+  it('should return undefined when server hooks path is not provided', () => {
+    const result = normalizeHooksConfig({ server: undefined });
+    expect(result).toBeUndefined();
+  });
+
+  it('should normalize path with .ts extension', () => {
+    const result = normalizeHooksConfig({ server: './src/hooks.ts' });
+
+    expect(result).toBeDefined();
+    expect(result!.serverHooksPath).toBe('/test/project/src/hooks.ts');
+  });
+
+  it('should add .ts extension when missing', () => {
+    const result = normalizeHooksConfig({ server: './src/hooks' });
+
+    expect(result).toBeDefined();
+    expect(result!.serverHooksPath).toBe('/test/project/src/hooks.ts');
+  });
+
+  it('should resolve relative paths from cwd', () => {
+    const result = normalizeHooksConfig({ server: 'config/server-hooks' });
+
+    expect(result).toBeDefined();
+    expect(result!.serverHooksPath).toBe(
+      '/test/project/config/server-hooks.ts',
+    );
+  });
+
+  it('should handle nested directory paths', () => {
+    const result = normalizeHooksConfig({
+      server: './src/config/hooks/server',
+    });
+
+    expect(result).toBeDefined();
+    expect(result!.serverHooksPath).toBe(
+      '/test/project/src/config/hooks/server.ts',
+    );
+  });
+});

package/src/build/index.ts

@@ -5,7 +5,7 @@ import type { Endpoint } from '@geekmidas/constructs/endpoints';
 import type { Function } from '@geekmidas/constructs/functions';
 import type { Subscriber } from '@geekmidas/constructs/subscribers';
 import { loadConfig, parseModuleConfig } from '../config';
-import { normalizeTelescopeConfig } from '../dev';
+import { normalizeHooksConfig, normalizeTelescopeConfig } from '../dev';
 import {
   CronGenerator,
   EndpointGenerator,
@@ -55,12 +55,19 @@ export async function buildCommand(options: BuildOptions): Promise<void> {
     logger.log(`🔭 Telescope enabled at ${telescope.path}`);
   }
 
+  // Normalize hooks configuration
+  const hooks = normalizeHooksConfig(config.hooks);
+  if (hooks) {
+    logger.log(`🪝 Server hooks enabled`);
+  }
+
   const buildContext: BuildContext = {
     envParserPath,
     envParserImportPattern,
     loggerPath,
     loggerImportPattern,
     telescope,
+    hooks,
   };
 
   // Initialize generators

package/src/build/types.ts

@@ -38,12 +38,31 @@ export interface NormalizedTelescopeConfig {
   websocket: boolean;
 }
 
+export interface NormalizedStudioConfig {
+  enabled: boolean;
+  /** Path to user's studio module (if provided) */
+  studioPath?: string;
+  /** Import pattern for studio (e.g., '{ studio }' or 'studio') */
+  studioImportPattern?: string;
+  /** UI path for studio dashboard */
+  path: string;
+  /** Database schema to introspect */
+  schema: string;
+}
+
+export interface NormalizedHooksConfig {
+  /** Path to server hooks module */
+  serverHooksPath: string;
+}
+
 export interface BuildContext {
   envParserPath: string;
   envParserImportPattern: string;
   loggerPath: string;
   loggerImportPattern: string;
   telescope?: NormalizedTelescopeConfig;
+  studio?: NormalizedStudioConfig;
+  hooks?: NormalizedHooksConfig;
 }
 
 export interface ProviderBuildResult {