@geekmidas/cli 0.4.0 → 0.5.0

package/src/dev/index.ts

@@ -1,12 +1,14 @@
 import { type ChildProcess, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { mkdir } from 'node:fs/promises';
 import { createServer } from 'node:net';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
 import chokidar from 'chokidar';
+import { config as dotenvConfig } from 'dotenv';
 import fg from 'fast-glob';
 import { resolveProviders } from '../build/providerResolver';
 import type { BuildContext, NormalizedTelescopeConfig } from '../build/types';
-import { loadConfig } from '../config';
+import { loadConfig, parseModuleConfig } from '../config';
 import {
   CronGenerator,
   EndpointGenerator,
@@ -22,6 +24,39 @@ import type {
 
 const logger = console;
 
+/**
+ * Load environment files
+ * @internal Exported for testing
+ */
+export function loadEnvFiles(
+  envConfig: string | string[] | undefined,
+  cwd: string = process.cwd(),
+): { loaded: string[]; missing: string[] } {
+  const loaded: string[] = [];
+  const missing: string[] = [];
+
+  // Normalize to array
+  const envFiles = envConfig
+    ? Array.isArray(envConfig)
+      ? envConfig
+      : [envConfig]
+    : ['.env'];
+
+  // Load each env file in order (later files override earlier)
+  for (const envFile of envFiles) {
+    const envPath = resolve(cwd, envFile);
+    if (existsSync(envPath)) {
+      dotenvConfig({ path: envPath, override: true, quiet: true });
+      loaded.push(envFile);
+    } else if (envConfig) {
+      // Only report as missing if explicitly configured
+      missing.push(envFile);
+    }
+  }
+
+  return { loaded, missing };
+}
+
 /**
  * Check if a port is available
  * @internal Exported for testing
@@ -79,6 +114,23 @@ export function normalizeTelescopeConfig(
     return undefined;
   }
 
+  // Handle string path (e.g., './src/config/telescope')
+  if (typeof config === 'string') {
+    const { path: telescopePath, importPattern: telescopeImportPattern } =
+      parseModuleConfig(config, 'telescope');
+
+    return {
+      enabled: true,
+      telescopePath,
+      telescopeImportPattern,
+      path: '/__telescope',
+      ignore: [],
+      recordBody: true,
+      maxEntries: 1000,
+      websocket: true,
+    };
+  }
+
   // Default to enabled in development mode
   const isEnabled =
     config === true || config === undefined || config.enabled !== false;
@@ -106,8 +158,26 @@ export interface DevOptions {
 }
 
 export async function devCommand(options: DevOptions): Promise<void> {
+  // Load default .env file BEFORE loading config
+  // This ensures env vars are available when config and its dependencies are loaded
+  const defaultEnv = loadEnvFiles('.env');
+  if (defaultEnv.loaded.length > 0) {
+    logger.log(`📦 Loaded env: ${defaultEnv.loaded.join(', ')}`);
+  }
+
   const config = await loadConfig();
 
+  // Load any additional env files specified in config
+  if (config.env) {
+    const { loaded, missing } = loadEnvFiles(config.env);
+    if (loaded.length > 0) {
+      logger.log(`📦 Loaded env: ${loaded.join(', ')}`);
+    }
+    if (missing.length > 0) {
+      logger.warn(`⚠️  Missing env files: ${missing.join(', ')}`);
+    }
+  }
+
   // Force server provider for dev mode
   const resolved = resolveProviders(config, { provider: 'server' });
 
@@ -124,21 +194,11 @@ export async function devCommand(options: DevOptions): Promise<void> {
   }
   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 }`;
+  // Parse envParser and logger configuration
+  const { path: envParserPath, importPattern: envParserImportPattern } =
+    parseModuleConfig(config.envParser, 'envParser');
+  const { path: loggerPath, importPattern: loggerImportPattern } =
+    parseModuleConfig(config.logger, 'logger');
 
   // Normalize telescope configuration
   const telescope = normalizeTelescopeConfig(config.telescope);

package/src/generators/EndpointGenerator.ts

@@ -336,10 +336,23 @@ export function setupEndpoints(
     // Generate telescope imports and setup if enabled
     const telescopeEnabled = context.telescope?.enabled;
     const telescopeWebSocketEnabled = context.telescope?.websocket;
-    const telescopeImports = telescopeEnabled
-      ? `import { Telescope, InMemoryStorage } from '@geekmidas/telescope';
-import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`
-      : '';
+    const usesExternalTelescope = !!context.telescope?.telescopePath;
+
+    // Generate imports based on whether telescope is external or inline
+    let telescopeImports = '';
+    if (telescopeEnabled) {
+      if (usesExternalTelescope) {
+        const relativeTelescopePath = relative(
+          dirname(appPath),
+          context.telescope!.telescopePath!,
+        );
+        telescopeImports = `import ${context.telescope!.telescopeImportPattern} from '${relativeTelescopePath}';
+import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`;
+      } else {
+        telescopeImports = `import { Telescope, InMemoryStorage } from '@geekmidas/telescope';
+import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`;
+      }
+    }
 
     const telescopeWebSocketSetupCode = telescopeWebSocketEnabled
       ? `
@@ -375,8 +388,23 @@ import { createMiddleware, createUI } from '@geekmidas/telescope/hono';`
 `
       : '';
 
-    const telescopeSetup = telescopeEnabled
-      ? `
+    // Generate telescope setup - either use external instance or create inline
+    let telescopeSetup = '';
+    if (telescopeEnabled) {
+      if (usesExternalTelescope) {
+        // Use external telescope instance - no need to create one
+        telescopeSetup = `
+${telescopeWebSocketSetupCode}
+  // Add telescope middleware (before endpoints to capture all requests)
+  honoApp.use('*', createMiddleware(telescope));
+
+  // Mount telescope UI
+  const telescopeUI = createUI(telescope);
+  honoApp.route('${context.telescope!.path}', telescopeUI);
+`;
+      } else {
+        // Create inline telescope instance
+        telescopeSetup = `
   // Setup Telescope for debugging/monitoring
   const telescopeStorage = new InMemoryStorage({ maxEntries: ${context.telescope!.maxEntries} });
   const telescope = new Telescope({
@@ -393,8 +421,9 @@ ${telescopeWebSocketSetupCode}
   // Mount telescope UI
   const telescopeUI = createUI(telescope);
   honoApp.route('${context.telescope!.path}', telescopeUI);
-`
-      : '';
+`;
+      }
+    }
 
     const content = `/**
  * Generated server application

package/src/index.ts

@@ -4,6 +4,7 @@ import { Command } from 'commander';
 import pkg from '../package.json' assert { type: 'json' };
 import { buildCommand } from './build/index.ts';
 import { devCommand } from './dev/index.ts';
+import { type InitOptions, initCommand } from './init/index.ts';
 import { generateReactQueryCommand } from './openapi-react-query.ts';
 import { openapiCommand } from './openapi.ts';
 import type { LegacyProvider, MainProvider } from './types.ts';
@@ -16,6 +17,31 @@ program
   .version(pkg.version)
   .option('--cwd <path>', 'Change working directory');
 
+program
+  .command('init')
+  .description('Scaffold a new project')
+  .argument('[name]', 'Project name')
+  .option(
+    '--template <template>',
+    'Project template (minimal, api, serverless, worker)',
+  )
+  .option('--skip-install', 'Skip dependency installation', false)
+  .option('-y, --yes', 'Skip prompts, use defaults', false)
+  .option('--monorepo', 'Setup as monorepo with packages/models', false)
+  .option('--api-path <path>', 'API app path in monorepo (default: apps/api)')
+  .action(async (name: string | undefined, options: InitOptions) => {
+    try {
+      const globalOptions = program.opts();
+      if (globalOptions.cwd) {
+        process.chdir(globalOptions.cwd);
+      }
+      await initCommand(name, options);
+    } catch (error) {
+      console.error('Init failed:', (error as Error).message);
+      process.exit(1);
+    }
+  });
+
 program
   .command('build')
   .description('Build handlers from endpoints, functions, and crons')

package/src/init/__tests__/generators.spec.ts

@@ -0,0 +1,366 @@
+import { describe, expect, it } from 'vitest';
+import { generateConfigFiles } from '../generators/config.js';
+import { generateDockerFiles } from '../generators/docker.js';
+import { generateEnvFiles } from '../generators/env.js';
+import { generateModelsPackage } from '../generators/models.js';
+import { generateMonorepoFiles } from '../generators/monorepo.js';
+import { generatePackageJson } from '../generators/package.js';
+import type { TemplateOptions } from '../templates/index.js';
+import { minimalTemplate } from '../templates/minimal.js';
+import { serverlessTemplate } from '../templates/serverless.js';
+import { workerTemplate } from '../templates/worker.js';
+
+const baseOptions: TemplateOptions = {
+  name: 'test-project',
+  template: 'minimal',
+  telescope: true,
+  database: true,
+  routeStyle: 'file-based',
+  monorepo: false,
+  apiPath: '',
+};
+
+describe('generatePackageJson', () => {
+  it('should generate package.json with correct name', () => {
+    const files = generatePackageJson(baseOptions, minimalTemplate);
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe('package.json');
+
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.name).toBe('test-project');
+    expect(pkg.type).toBe('module');
+    expect(pkg.private).toBe(true);
+  });
+
+  it('should include telescope when enabled', () => {
+    const files = generatePackageJson(baseOptions, minimalTemplate);
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.dependencies['@geekmidas/telescope']).toBe('workspace:*');
+  });
+
+  it('should include database dependencies when enabled', () => {
+    const files = generatePackageJson(baseOptions, minimalTemplate);
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.dependencies['@geekmidas/db']).toBe('workspace:*');
+    expect(pkg.dependencies['kysely']).toBeDefined();
+    expect(pkg.dependencies['pg']).toBeDefined();
+  });
+
+  it('should exclude telescope when disabled', () => {
+    const options = { ...baseOptions, telescope: false };
+    const files = generatePackageJson(options, minimalTemplate);
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.dependencies['@geekmidas/telescope']).toBeUndefined();
+  });
+
+  it('should use workspace:* for @geekmidas packages', () => {
+    const files = generatePackageJson(baseOptions, minimalTemplate);
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.dependencies['@geekmidas/constructs']).toBe('workspace:*');
+    expect(pkg.dependencies['@geekmidas/envkit']).toBe('workspace:*');
+    expect(pkg.dependencies['@geekmidas/logger']).toBe('workspace:*');
+  });
+
+  it('should use tilde versions for external packages', () => {
+    const files = generatePackageJson(baseOptions, minimalTemplate);
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.dependencies['hono']).toMatch(/^~/);
+    expect(pkg.dependencies['pino']).toMatch(/^~/);
+    expect(pkg.devDependencies['typescript']).toMatch(/^~/);
+  });
+
+  it('should include biome and turbo for non-monorepo', () => {
+    const files = generatePackageJson(baseOptions, minimalTemplate);
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.devDependencies['@biomejs/biome']).toBeDefined();
+    expect(pkg.devDependencies['turbo']).toBeDefined();
+    expect(pkg.scripts['lint']).toBeDefined();
+    expect(pkg.scripts['fmt']).toBeDefined();
+  });
+
+  it('should exclude biome and turbo for monorepo apps', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generatePackageJson(options, minimalTemplate);
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.devDependencies['@biomejs/biome']).toBeUndefined();
+    expect(pkg.devDependencies['turbo']).toBeUndefined();
+    expect(pkg.scripts['lint']).toBeUndefined();
+    expect(pkg.scripts['fmt']).toBeUndefined();
+  });
+
+  it('should include models package for monorepo apps', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generatePackageJson(options, minimalTemplate);
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.dependencies['@test-project/models']).toBe('workspace:*');
+    expect(pkg.dependencies['zod']).toBeUndefined(); // zod is in models
+  });
+
+  it('should use scoped package name for monorepo apps', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generatePackageJson(options, minimalTemplate);
+    const pkg = JSON.parse(files[0].content);
+    expect(pkg.name).toBe('@test-project/api');
+  });
+});
+
+describe('generateConfigFiles', () => {
+  it('should generate gkm.config.ts and tsconfig.json for non-monorepo', () => {
+    const files = generateConfigFiles(baseOptions, minimalTemplate);
+    const paths = files.map((f) => f.path);
+    expect(paths).toContain('gkm.config.ts');
+    expect(paths).toContain('tsconfig.json');
+    expect(paths).toContain('biome.json');
+    expect(paths).toContain('turbo.json');
+  });
+
+  it('should only generate gkm.config.ts and tsconfig.json for monorepo', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateConfigFiles(options, minimalTemplate);
+    const paths = files.map((f) => f.path);
+    expect(paths).toContain('gkm.config.ts');
+    expect(paths).toContain('tsconfig.json');
+    expect(paths).not.toContain('biome.json');
+    expect(paths).not.toContain('turbo.json');
+  });
+
+  it('should include telescope config when enabled', () => {
+    const files = generateConfigFiles(baseOptions, minimalTemplate);
+    const gkmConfig = files.find((f) => f.path === 'gkm.config.ts');
+    expect(gkmConfig?.content).toContain('telescope');
+  });
+
+  it('should include functions config for serverless template', () => {
+    const options = { ...baseOptions, template: 'serverless' as const };
+    const files = generateConfigFiles(options, serverlessTemplate);
+    const gkmConfig = files.find((f) => f.path === 'gkm.config.ts');
+    expect(gkmConfig?.content).toContain('functions');
+  });
+
+  it('should include paths config for monorepo apps', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateConfigFiles(options, minimalTemplate);
+    const tsConfig = files.find((f) => f.path === 'tsconfig.json');
+    const config = JSON.parse(tsConfig!.content);
+    expect(config.extends).toBe('../../tsconfig.json');
+    expect(config.compilerOptions.paths).toBeDefined();
+    expect(config.compilerOptions.paths['@test-project/*']).toBeDefined();
+  });
+});
+
+describe('generateEnvFiles', () => {
+  it('should generate all env files for non-monorepo', () => {
+    const files = generateEnvFiles(baseOptions, minimalTemplate);
+    const paths = files.map((f) => f.path);
+    expect(paths).toContain('.env');
+    expect(paths).toContain('.env.example');
+    expect(paths).toContain('.env.development');
+    expect(paths).toContain('.env.test');
+    expect(paths).toContain('.gitignore');
+  });
+
+  it('should not generate .gitignore for monorepo', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateEnvFiles(options, minimalTemplate);
+    const paths = files.map((f) => f.path);
+    expect(paths).not.toContain('.gitignore');
+  });
+
+  it('should include DATABASE_URL when database is enabled', () => {
+    const files = generateEnvFiles(baseOptions, minimalTemplate);
+    const envFile = files.find((f) => f.path === '.env');
+    expect(envFile?.content).toContain('DATABASE_URL');
+  });
+
+  it('should include RABBITMQ_URL for worker template', () => {
+    const options = { ...baseOptions, template: 'worker' as const };
+    const files = generateEnvFiles(options, workerTemplate);
+    const envFile = files.find((f) => f.path === '.env');
+    expect(envFile?.content).toContain('RABBITMQ_URL');
+  });
+});
+
+describe('generateDockerFiles', () => {
+  it('should generate docker-compose.yml', () => {
+    const files = generateDockerFiles(baseOptions, minimalTemplate);
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe('docker-compose.yml');
+  });
+
+  it('should include postgres when database is enabled', () => {
+    const files = generateDockerFiles(baseOptions, minimalTemplate);
+    expect(files[0].content).toContain('postgres');
+    expect(files[0].content).toContain('5432');
+  });
+
+  it('should include redis', () => {
+    const files = generateDockerFiles(baseOptions, minimalTemplate);
+    expect(files[0].content).toContain('redis');
+    expect(files[0].content).toContain('6379');
+  });
+
+  it('should include serverless-redis-http for serverless template', () => {
+    const options = { ...baseOptions, template: 'serverless' as const };
+    const files = generateDockerFiles(options, serverlessTemplate);
+    expect(files[0].content).toContain('hiett/serverless-redis-http');
+    expect(files[0].content).toContain('8079');
+  });
+
+  it('should include rabbitmq for worker template', () => {
+    const options = { ...baseOptions, template: 'worker' as const };
+    const files = generateDockerFiles(options, workerTemplate);
+    expect(files[0].content).toContain('rabbitmq');
+    expect(files[0].content).toContain('5672');
+    expect(files[0].content).toContain('15672');
+  });
+});
+
+describe('generateMonorepoFiles', () => {
+  it('should return empty array for non-monorepo', () => {
+    const files = generateMonorepoFiles(baseOptions, minimalTemplate);
+    expect(files).toHaveLength(0);
+  });
+
+  it('should generate root files for monorepo', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateMonorepoFiles(options, minimalTemplate);
+    const paths = files.map((f) => f.path);
+    expect(paths).toContain('package.json');
+    expect(paths).toContain('pnpm-workspace.yaml');
+    expect(paths).toContain('tsconfig.json');
+    expect(paths).toContain('biome.json');
+    expect(paths).toContain('turbo.json');
+    expect(paths).toContain('.gitignore');
+  });
+
+  it('should include correct workspace paths', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateMonorepoFiles(options, minimalTemplate);
+    const workspace = files.find((f) => f.path === 'pnpm-workspace.yaml');
+    expect(workspace?.content).toContain("'apps/*'");
+    expect(workspace?.content).toContain("'packages/*'");
+  });
+
+  it('should include root scripts', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateMonorepoFiles(options, minimalTemplate);
+    const pkgJson = files.find((f) => f.path === 'package.json');
+    const pkg = JSON.parse(pkgJson!.content);
+    expect(pkg.scripts.dev).toBe('turbo dev');
+    expect(pkg.scripts.build).toBe('turbo build');
+    expect(pkg.scripts.lint).toBe('biome lint .');
+  });
+});
+
+describe('generateModelsPackage', () => {
+  it('should return empty array for non-monorepo', () => {
+    const files = generateModelsPackage(baseOptions);
+    expect(files).toHaveLength(0);
+  });
+
+  it('should generate models package for monorepo', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateModelsPackage(options);
+    const paths = files.map((f) => f.path);
+    expect(paths).toContain('packages/models/package.json');
+    expect(paths).toContain('packages/models/tsconfig.json');
+    expect(paths).toContain('packages/models/src/index.ts');
+  });
+
+  it('should use correct package name', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateModelsPackage(options);
+    const pkgJson = files.find(
+      (f) => f.path === 'packages/models/package.json',
+    );
+    const pkg = JSON.parse(pkgJson!.content);
+    expect(pkg.name).toBe('@test-project/models');
+  });
+
+  it('should include zod as dependency', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateModelsPackage(options);
+    const pkgJson = files.find(
+      (f) => f.path === 'packages/models/package.json',
+    );
+    const pkg = JSON.parse(pkgJson!.content);
+    expect(pkg.dependencies.zod).toBeDefined();
+  });
+
+  it('should include example schemas', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateModelsPackage(options);
+    const indexTs = files.find(
+      (f) => f.path === 'packages/models/src/index.ts',
+    );
+    expect(indexTs?.content).toContain('userSchema');
+    expect(indexTs?.content).toContain('paginationSchema');
+    expect(indexTs?.content).toContain("import { z } from 'zod'");
+  });
+
+  it('should extend root tsconfig', () => {
+    const options: TemplateOptions = {
+      ...baseOptions,
+      monorepo: true,
+      apiPath: 'apps/api',
+    };
+    const files = generateModelsPackage(options);
+    const tsConfig = files.find(
+      (f) => f.path === 'packages/models/tsconfig.json',
+    );
+    const config = JSON.parse(tsConfig!.content);
+    expect(config.extends).toBe('../../tsconfig.json');
+  });
+});