@geekmidas/cli 0.5.1 → 0.6.0

package/src/dev/index.ts

@@ -15,6 +15,7 @@ import {
   FunctionGenerator,
   SubscriberGenerator,
 } from '../generators';
+import { generateOpenApi, resolveOpenApiConfig } from '../openapi';
 import type {
   GkmConfig,
   LegacyProvider,
@@ -206,6 +207,12 @@ export async function devCommand(options: DevOptions): Promise<void> {
     logger.log(`🔭 Telescope enabled at ${telescope.path}`);
   }
 
+  // Resolve OpenAPI configuration
+  const openApiConfig = resolveOpenApiConfig(config);
+  if (openApiConfig.enabled) {
+    logger.log(`📄 OpenAPI output: ${openApiConfig.output}`);
+  }
+
   const buildContext: BuildContext = {
     envParserPath,
     envParserImportPattern,
@@ -222,6 +229,11 @@ export async function devCommand(options: DevOptions): Promise<void> {
     resolved.enableOpenApi,
   );
 
+  // Generate OpenAPI spec on startup
+  if (openApiConfig.enabled) {
+    await generateOpenApi(config);
+  }
+
   // Determine runtime (default to node)
   const runtime: Runtime = config.runtime ?? 'node';
 
@@ -307,6 +319,12 @@ export async function devCommand(options: DevOptions): Promise<void> {
           resolved.providers[0] as LegacyProvider,
           resolved.enableOpenApi,
         );
+
+        // Regenerate OpenAPI if enabled
+        if (openApiConfig.enabled) {
+          await generateOpenApi(config, { silent: true });
+        }
+
         logger.log('✅ Rebuild complete, restarting server...');
         await devServer.restart();
       } catch (error) {

package/src/init/generators/config.ts

@@ -11,17 +11,29 @@ export function generateConfigFiles(
   options: TemplateOptions,
   template: TemplateConfig,
 ): GeneratedFile[] {
-  const { telescope } = options;
+  const { telescope, routesStructure } = options;
   const isServerless = template.name === 'serverless';
   const hasWorker = template.name === 'worker';
 
+  // Get routes glob pattern based on structure
+  const getRoutesGlob = () => {
+    switch (routesStructure) {
+      case 'centralized-endpoints':
+        return './src/endpoints/**/*.ts';
+      case 'centralized-routes':
+        return './src/routes/**/*.ts';
+      case 'domain-based':
+        return './src/**/routes/*.ts';
+    }
+  };
+
   // Build gkm.config.ts
-  let gkmConfig = `import { defineConfig } from '@geekmidas/cli';
+  let gkmConfig = `import { defineConfig } from '@geekmidas/cli/config';
 
 export default defineConfig({
-  routes: './src/endpoints/**/*.ts',
-  envParser: './src/config/env',
-  logger: './src/config/logger',`;
+  routes: '${getRoutesGlob()}',
+  envParser: './src/config/env#envParser',
+  logger: './src/config/logger#logger',`;
 
   if (isServerless || hasWorker) {
     gkmConfig += `
@@ -42,6 +54,12 @@ export default defineConfig({
   },`;
   }
 
+  // Always add openapi config (output path is fixed to .gkm/openapi.ts)
+  gkmConfig += `
+  openapi: {
+    enabled: true,
+  },`;
+
   gkmConfig += `
 });
 `;

package/src/init/generators/package.ts

@@ -1,7 +1,8 @@
-import type {
-  GeneratedFile,
-  TemplateConfig,
-  TemplateOptions,
+import {
+  type GeneratedFile,
+  OPENAPI_OUTPUT_PATH,
+  type TemplateConfig,
+  type TemplateOptions,
 } from '../templates/index.js';
 
 /**
@@ -67,6 +68,12 @@ export function generatePackageJson(
     version: '0.0.1',
     private: true,
     type: 'module',
+    exports: {
+      './client': {
+        types: OPENAPI_OUTPUT_PATH,
+        import: OPENAPI_OUTPUT_PATH,
+      },
+    },
     scripts,
     dependencies: sortObject(dependencies),
     devDependencies: sortObject(devDependencies),

package/src/init/index.ts

@@ -13,7 +13,8 @@ import {
   type TemplateName,
   type TemplateOptions,
   getTemplate,
-  routeStyleChoices,
+  loggerTypeChoices,
+  routesStructureChoices,
   templateChoices,
 } from './templates/index.js';
 import {
@@ -85,9 +86,16 @@ export async function initCommand(
       },
       {
         type: options.yes ? null : 'select',
-        name: 'routeStyle',
-        message: 'Route organization:',
-        choices: routeStyleChoices,
+        name: 'loggerType',
+        message: 'Logger:',
+        choices: loggerTypeChoices,
+        initial: 0,
+      },
+      {
+        type: options.yes ? null : 'select',
+        name: 'routesStructure',
+        message: 'Routes structure:',
+        choices: routesStructureChoices,
         initial: 0,
       },
       {
@@ -137,9 +145,10 @@ export async function initCommand(
     template: options.template || answers.template || 'minimal',
     telescope: options.yes ? true : (answers.telescope ?? true),
     database: options.yes ? true : (answers.database ?? true),
-    routeStyle: options.yes
-      ? 'file-based'
-      : (answers.routeStyle ?? 'file-based'),
+    loggerType: options.yes ? 'pino' : (answers.loggerType ?? 'pino'),
+    routesStructure: options.yes
+      ? 'centralized-endpoints'
+      : (answers.routesStructure ?? 'centralized-endpoints'),
     monorepo,
     apiPath: monorepo ? (options.apiPath ?? answers.apiPath ?? 'apps/api') : '',
   };
@@ -199,6 +208,16 @@ export async function initCommand(
     } catch {
       console.error('\n  Warning: Failed to install dependencies.');
     }
+
+    // Format generated files with biome
+    try {
+      execSync('npx @biomejs/biome format --write --unsafe .', {
+        cwd: targetDir,
+        stdio: 'inherit',
+      });
+    } catch {
+      // Silently ignore format errors
+    }
   }
 
   // Print next steps

package/src/init/templates/api.ts

@@ -41,6 +41,30 @@ export const apiTemplate: TemplateConfig = {
   },
 
   files: (options: TemplateOptions): GeneratedFile[] => {
+    const { loggerType, routesStructure } = options;
+
+    const loggerContent = `import { createLogger } from '@geekmidas/logger/${loggerType}';
+
+export const logger = createLogger();
+`;
+
+    // Get route path based on structure
+    const getRoutePath = (file: string) => {
+      switch (routesStructure) {
+        case 'centralized-endpoints':
+          return `src/endpoints/${file}`;
+        case 'centralized-routes':
+          return `src/routes/${file}`;
+        case 'domain-based': {
+          const parts = file.split('/');
+          if (parts.length === 1) {
+            return `src/${file.replace('.ts', '')}/routes/index.ts`;
+          }
+          return `src/${parts[0]}/routes/${parts.slice(1).join('/')}`;
+        }
+      }
+    };
+
     const files: GeneratedFile[] = [
       // src/config/env.ts
       {
@@ -66,21 +90,15 @@ export const config = envParser
 `,
       },
 
-      // src/config/logger.ts - using pino
+      // src/config/logger.ts
       {
         path: 'src/config/logger.ts',
-        content: `import { PinoLogger } from '@geekmidas/logger/pino';
-
-export const logger = new PinoLogger({
-  app: '${options.name}',
-  level: process.env.LOG_LEVEL || 'info',
-});
-`,
+        content: loggerContent,
       },
 
-      // src/endpoints/health.ts
+      // health endpoint
       {
-        path: 'src/endpoints/health.ts',
+        path: getRoutePath('health.ts'),
         content: `import { e } from '@geekmidas/constructs/endpoints';
 
 export default e
@@ -91,46 +109,11 @@ export default e
   }));
 `,
       },
-    ];
-
-    // Add user endpoints based on route style
-    if (options.routeStyle === 'flat') {
-      files.push(
-        {
-          path: 'src/endpoints/users-list.ts',
-          content: `import { e } from '@geekmidas/constructs/endpoints';
-
-export default e
-  .get('/users')
-  .handle(async () => ({
-    users: [
-      { id: '1', name: 'Alice' },
-      { id: '2', name: 'Bob' },
-    ],
-  }));
-`,
-        },
-        {
-          path: 'src/endpoints/users-get.ts',
-          content: `import { e } from '@geekmidas/constructs/endpoints';
-import { z } from 'zod';
 
-export default e
-  .get('/users/:id')
-  .params(z.object({ id: z.string() }))
-  .handle(async ({ params }) => ({
-    id: params.id,
-    name: 'Alice',
-    email: 'alice@example.com',
-  }));
-`,
-        },
-      );
-    } else {
-      files.push(
-        {
-          path: 'src/endpoints/users/list.ts',
-          content: `import { e } from '@geekmidas/constructs/endpoints';
+      // users endpoints
+      {
+        path: getRoutePath('users/list.ts'),
+        content: `import { e } from '@geekmidas/constructs/endpoints';
 
 export default e
   .get('/users')
@@ -141,10 +124,10 @@ export default e
     ],
   }));
 `,
-        },
-        {
-          path: 'src/endpoints/users/get.ts',
-          content: `import { e } from '@geekmidas/constructs/endpoints';
+      },
+      {
+        path: getRoutePath('users/get.ts'),
+        content: `import { e } from '@geekmidas/constructs/endpoints';
 import { z } from 'zod';
 
 export default e
@@ -156,9 +139,8 @@ export default e
     email: 'alice@example.com',
   }));
 `,
-        },
-      );
-    }
+      },
+    ];
 
     // Add database service if enabled
     if (options.database) {

package/src/init/templates/index.ts

@@ -4,9 +4,22 @@ import { serverlessTemplate } from './serverless.js';
 import { workerTemplate } from './worker.js';
 
 /**
- * Route organization style
+ * OpenAPI output path (fixed, not configurable)
  */
-export type RouteStyle = 'file-based' | 'flat';
+export const OPENAPI_OUTPUT_PATH = './.gkm/openapi.ts';
+
+/**
+ * Logger implementation type
+ */
+export type LoggerType = 'pino' | 'console';
+
+/**
+ * Routes structure pattern
+ */
+export type RoutesStructure =
+  | 'centralized-endpoints'
+  | 'centralized-routes'
+  | 'domain-based';
 
 /**
  * Options collected from user prompts
@@ -16,7 +29,8 @@ export interface TemplateOptions {
   template: TemplateName;
   telescope: boolean;
   database: boolean;
-  routeStyle: RouteStyle;
+  loggerType: LoggerType;
+  routesStructure: RoutesStructure;
   monorepo: boolean;
   /** Path for the API app in monorepo (e.g., 'apps/api') */
   apiPath: string;
@@ -81,18 +95,39 @@ export const templateChoices = [
 ];
 
 /**
- * Route style choices for prompts
+ * Logger type choices for prompts
+ */
+export const loggerTypeChoices = [
+  {
+    title: 'Pino',
+    value: 'pino' as LoggerType,
+    description: 'Fast JSON logger for production (recommended)',
+  },
+  {
+    title: 'Console',
+    value: 'console' as LoggerType,
+    description: 'Simple console logger for development',
+  },
+];
+
+/**
+ * Routes structure choices for prompts
  */
-export const routeStyleChoices = [
+export const routesStructureChoices = [
+  {
+    title: 'Centralized (endpoints)',
+    value: 'centralized-endpoints' as RoutesStructure,
+    description: 'src/endpoints/**/*.ts',
+  },
   {
-    title: 'File-based',
-    value: 'file-based' as RouteStyle,
-    description: 'Folder structure matches URL paths (users/list.ts → /users)',
+    title: 'Centralized (routes)',
+    value: 'centralized-routes' as RoutesStructure,
+    description: 'src/routes/**/*.ts',
   },
   {
-    title: 'Flat',
-    value: 'flat' as RouteStyle,
-    description: 'All endpoints in one folder (users-list.ts → /users)',
+    title: 'Domain-based',
+    value: 'domain-based' as RoutesStructure,
+    description: 'src/**/routes/*.ts (e.g., src/users/routes/list.ts)',
   },
 ];
 

package/src/init/templates/minimal.ts

@@ -38,6 +38,25 @@ export const minimalTemplate: TemplateConfig = {
   },
 
   files: (options: TemplateOptions): GeneratedFile[] => {
+    const { loggerType, routesStructure } = options;
+
+    const loggerContent = `import { createLogger } from '@geekmidas/logger/${loggerType}';
+
+export const logger = createLogger();
+`;
+
+    // Get route path based on structure
+    const getRoutePath = (file: string) => {
+      switch (routesStructure) {
+        case 'centralized-endpoints':
+          return `src/endpoints/${file}`;
+        case 'centralized-routes':
+          return `src/routes/${file}`;
+        case 'domain-based':
+          return `src/${file.replace('.ts', '')}/routes/index.ts`;
+      }
+    };
+
     const files: GeneratedFile[] = [
       // src/config/env.ts
       {
@@ -55,21 +74,15 @@ export const config = envParser
 `,
       },
 
-      // src/config/logger.ts - using pino
+      // src/config/logger.ts
       {
         path: 'src/config/logger.ts',
-        content: `import { PinoLogger } from '@geekmidas/logger/pino';
-
-export const logger = new PinoLogger({
-  app: '${options.name}',
-  level: process.env.LOG_LEVEL || 'info',
-});
-`,
+        content: loggerContent,
       },
 
-      // src/endpoints/health.ts
+      // health endpoint
       {
-        path: 'src/endpoints/health.ts',
+        path: getRoutePath('health.ts'),
         content: `import { e } from '@geekmidas/constructs/endpoints';
 
 export default e

package/src/init/templates/serverless.ts

@@ -40,6 +40,25 @@ export const serverlessTemplate: TemplateConfig = {
   },
 
   files: (options: TemplateOptions): GeneratedFile[] => {
+    const { loggerType, routesStructure } = options;
+
+    const loggerContent = `import { createLogger } from '@geekmidas/logger/${loggerType}';
+
+export const logger = createLogger();
+`;
+
+    // Get route path based on structure
+    const getRoutePath = (file: string) => {
+      switch (routesStructure) {
+        case 'centralized-endpoints':
+          return `src/endpoints/${file}`;
+        case 'centralized-routes':
+          return `src/routes/${file}`;
+        case 'domain-based':
+          return `src/${file.replace('.ts', '')}/routes/index.ts`;
+      }
+    };
+
     const files: GeneratedFile[] = [
       // src/config/env.ts
       {
@@ -64,22 +83,15 @@ export const config = envParser
 `,
       },
 
-      // src/config/logger.ts - using pino
+      // src/config/logger.ts
       {
         path: 'src/config/logger.ts',
-        content: `import { PinoLogger } from '@geekmidas/logger/pino';
-
-export const logger = new PinoLogger({
-  app: '${options.name}',
-  stage: process.env.STAGE || 'dev',
-  level: process.env.LOG_LEVEL || 'info',
-});
-`,
+        content: loggerContent,
       },
 
-      // src/endpoints/health.ts
+      // health endpoint
       {
-        path: 'src/endpoints/health.ts',
+        path: getRoutePath('health.ts'),
         content: `import { e } from '@geekmidas/constructs/endpoints';
 
 export default e

package/src/init/templates/worker.ts

@@ -39,6 +39,25 @@ export const workerTemplate: TemplateConfig = {
   },
 
   files: (options: TemplateOptions): GeneratedFile[] => {
+    const { loggerType, routesStructure } = options;
+
+    const loggerContent = `import { createLogger } from '@geekmidas/logger/${loggerType}';
+
+export const logger = createLogger();
+`;
+
+    // Get route path based on structure
+    const getRoutePath = (file: string) => {
+      switch (routesStructure) {
+        case 'centralized-endpoints':
+          return `src/endpoints/${file}`;
+        case 'centralized-routes':
+          return `src/routes/${file}`;
+        case 'domain-based':
+          return `src/${file.replace('.ts', '')}/routes/index.ts`;
+      }
+    };
+
     const files: GeneratedFile[] = [
       // src/config/env.ts
       {
@@ -66,21 +85,15 @@ export const config = envParser
 `,
       },
 
-      // src/config/logger.ts - using pino
+      // src/config/logger.ts
       {
         path: 'src/config/logger.ts',
-        content: `import { PinoLogger } from '@geekmidas/logger/pino';
-
-export const logger = new PinoLogger({
-  app: '${options.name}',
-  level: process.env.LOG_LEVEL || 'info',
-});
-`,
+        content: loggerContent,
       },
 
-      // src/endpoints/health.ts
+      // health endpoint
       {
-        path: 'src/endpoints/health.ts',
+        path: getRoutePath('health.ts'),
         content: `import { e } from '@geekmidas/constructs/endpoints';
 
 export default e