@geekmidas/cli 0.4.0 → 0.5.1

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

@@ -0,0 +1,341 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { initCommand } from '../index.js';
+
+describe('initCommand', () => {
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `cli-init-test-${Date.now()}`);
+    await mkdir(tempDir, { recursive: true });
+    originalCwd = process.cwd();
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('non-monorepo', () => {
+    it('should create project with minimal template', async () => {
+      await initCommand('my-api', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+      });
+
+      const projectDir = join(tempDir, 'my-api');
+      expect(existsSync(projectDir)).toBe(true);
+      expect(existsSync(join(projectDir, 'package.json'))).toBe(true);
+      expect(existsSync(join(projectDir, 'gkm.config.ts'))).toBe(true);
+      expect(existsSync(join(projectDir, 'tsconfig.json'))).toBe(true);
+      expect(existsSync(join(projectDir, 'biome.json'))).toBe(true);
+      expect(existsSync(join(projectDir, 'turbo.json'))).toBe(true);
+      expect(existsSync(join(projectDir, 'docker-compose.yml'))).toBe(true);
+      expect(existsSync(join(projectDir, '.env'))).toBe(true);
+      expect(existsSync(join(projectDir, '.env.development'))).toBe(true);
+      expect(existsSync(join(projectDir, '.env.test'))).toBe(true);
+      expect(existsSync(join(projectDir, '.gitignore'))).toBe(true);
+      expect(existsSync(join(projectDir, 'src/config/env.ts'))).toBe(true);
+      expect(existsSync(join(projectDir, 'src/config/logger.ts'))).toBe(true);
+      expect(existsSync(join(projectDir, 'src/endpoints/health.ts'))).toBe(
+        true,
+      );
+    });
+
+    it('should create package.json with correct content', async () => {
+      await initCommand('my-api', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+      });
+
+      const pkgPath = join(tempDir, 'my-api', 'package.json');
+      const content = await readFile(pkgPath, 'utf-8');
+      const pkg = JSON.parse(content);
+
+      expect(pkg.name).toBe('my-api');
+      expect(pkg.type).toBe('module');
+      expect(pkg.dependencies['@geekmidas/constructs']).toBe('workspace:*');
+      expect(pkg.dependencies['@geekmidas/telescope']).toBe('workspace:*');
+      expect(pkg.dependencies['zod']).toMatch(/^~/);
+      expect(pkg.devDependencies['@biomejs/biome']).toBeDefined();
+      expect(pkg.devDependencies['turbo']).toBeDefined();
+      expect(pkg.scripts.dev).toBe('gkm dev');
+      expect(pkg.scripts.lint).toBe('biome lint .');
+    });
+
+    it('should create gkm.config.ts with telescope when enabled', async () => {
+      await initCommand('my-api', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+      });
+
+      const configPath = join(tempDir, 'my-api', 'gkm.config.ts');
+      const content = await readFile(configPath, 'utf-8');
+
+      expect(content).toContain("routes: './src/endpoints/**/*.ts'");
+      expect(content).toContain('telescope');
+      expect(content).toContain('/__telescope');
+    });
+
+    it('should create api template with user endpoints', async () => {
+      await initCommand('my-api', {
+        template: 'api',
+        yes: true,
+        skipInstall: true,
+      });
+
+      const projectDir = join(tempDir, 'my-api');
+      expect(existsSync(join(projectDir, 'src/endpoints/users/list.ts'))).toBe(
+        true,
+      );
+      expect(existsSync(join(projectDir, 'src/endpoints/users/get.ts'))).toBe(
+        true,
+      );
+      expect(existsSync(join(projectDir, 'src/services/database.ts'))).toBe(
+        true,
+      );
+    });
+
+    it('should create serverless template with functions', async () => {
+      await initCommand('my-api', {
+        template: 'serverless',
+        yes: true,
+        skipInstall: true,
+      });
+
+      const projectDir = join(tempDir, 'my-api');
+      expect(existsSync(join(projectDir, 'src/functions/hello.ts'))).toBe(true);
+
+      const configPath = join(projectDir, 'gkm.config.ts');
+      const content = await readFile(configPath, 'utf-8');
+      expect(content).toContain('functions');
+    });
+
+    it('should create worker template with crons and subscribers', async () => {
+      await initCommand('my-api', {
+        template: 'worker',
+        yes: true,
+        skipInstall: true,
+      });
+
+      const projectDir = join(tempDir, 'my-api');
+      expect(existsSync(join(projectDir, 'src/crons/cleanup.ts'))).toBe(true);
+      expect(
+        existsSync(join(projectDir, 'src/subscribers/user-events.ts')),
+      ).toBe(true);
+      expect(existsSync(join(projectDir, 'src/events/types.ts'))).toBe(true);
+
+      const configPath = join(projectDir, 'gkm.config.ts');
+      const content = await readFile(configPath, 'utf-8');
+      expect(content).toContain('crons');
+      expect(content).toContain('subscribers');
+    });
+  });
+
+  describe('monorepo', () => {
+    it('should create monorepo structure', async () => {
+      await initCommand('my-monorepo', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+        monorepo: true,
+        apiPath: 'apps/api',
+      });
+
+      const projectDir = join(tempDir, 'my-monorepo');
+
+      // Root files
+      expect(existsSync(join(projectDir, 'package.json'))).toBe(true);
+      expect(existsSync(join(projectDir, 'pnpm-workspace.yaml'))).toBe(true);
+      expect(existsSync(join(projectDir, 'tsconfig.json'))).toBe(true);
+      expect(existsSync(join(projectDir, 'biome.json'))).toBe(true);
+      expect(existsSync(join(projectDir, 'turbo.json'))).toBe(true);
+      expect(existsSync(join(projectDir, '.gitignore'))).toBe(true);
+
+      // API app files
+      expect(existsSync(join(projectDir, 'apps/api/package.json'))).toBe(true);
+      expect(existsSync(join(projectDir, 'apps/api/gkm.config.ts'))).toBe(true);
+      expect(existsSync(join(projectDir, 'apps/api/tsconfig.json'))).toBe(true);
+      expect(
+        existsSync(join(projectDir, 'apps/api/src/endpoints/health.ts')),
+      ).toBe(true);
+
+      // Models package
+      expect(existsSync(join(projectDir, 'packages/models/package.json'))).toBe(
+        true,
+      );
+      expect(
+        existsSync(join(projectDir, 'packages/models/tsconfig.json')),
+      ).toBe(true);
+      expect(existsSync(join(projectDir, 'packages/models/src/index.ts'))).toBe(
+        true,
+      );
+    });
+
+    it('should create root package.json with turbo scripts', async () => {
+      await initCommand('my-monorepo', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+        monorepo: true,
+        apiPath: 'apps/api',
+      });
+
+      const pkgPath = join(tempDir, 'my-monorepo', 'package.json');
+      const content = await readFile(pkgPath, 'utf-8');
+      const pkg = JSON.parse(content);
+
+      expect(pkg.name).toBe('my-monorepo');
+      expect(pkg.scripts.dev).toBe('turbo dev');
+      expect(pkg.scripts.build).toBe('turbo build');
+      expect(pkg.scripts.lint).toBe('biome lint .');
+      expect(pkg.devDependencies['@biomejs/biome']).toBeDefined();
+      expect(pkg.devDependencies['turbo']).toBeDefined();
+    });
+
+    it('should create API package.json with models dependency', async () => {
+      await initCommand('my-monorepo', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+        monorepo: true,
+        apiPath: 'apps/api',
+      });
+
+      const pkgPath = join(tempDir, 'my-monorepo', 'apps/api/package.json');
+      const content = await readFile(pkgPath, 'utf-8');
+      const pkg = JSON.parse(content);
+
+      expect(pkg.name).toBe('@my-monorepo/api');
+      expect(pkg.dependencies['@my-monorepo/models']).toBe('workspace:*');
+      expect(pkg.dependencies['zod']).toBeUndefined(); // zod is in models
+      expect(pkg.devDependencies['@biomejs/biome']).toBeUndefined(); // at root
+      expect(pkg.devDependencies['turbo']).toBeUndefined(); // at root
+    });
+
+    it('should create API tsconfig with paths', async () => {
+      await initCommand('my-monorepo', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+        monorepo: true,
+        apiPath: 'apps/api',
+      });
+
+      const tsConfigPath = join(
+        tempDir,
+        'my-monorepo',
+        'apps/api/tsconfig.json',
+      );
+      const content = await readFile(tsConfigPath, 'utf-8');
+      const config = JSON.parse(content);
+
+      expect(config.extends).toBe('../../tsconfig.json');
+      expect(config.compilerOptions.paths['@my-monorepo/*']).toEqual([
+        '../../packages/*/src',
+      ]);
+    });
+
+    it('should create models package with zod schemas', async () => {
+      await initCommand('my-monorepo', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+        monorepo: true,
+        apiPath: 'apps/api',
+      });
+
+      const pkgPath = join(
+        tempDir,
+        'my-monorepo',
+        'packages/models/package.json',
+      );
+      const content = await readFile(pkgPath, 'utf-8');
+      const pkg = JSON.parse(content);
+
+      expect(pkg.name).toBe('@my-monorepo/models');
+      expect(pkg.dependencies.zod).toBeDefined();
+
+      const indexPath = join(
+        tempDir,
+        'my-monorepo',
+        'packages/models/src/index.ts',
+      );
+      const indexContent = await readFile(indexPath, 'utf-8');
+      expect(indexContent).toContain('userSchema');
+      expect(indexContent).toContain('paginationSchema');
+    });
+
+    it('should support custom API path', async () => {
+      await initCommand('my-monorepo', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+        monorepo: true,
+        apiPath: 'services/backend',
+      });
+
+      const projectDir = join(tempDir, 'my-monorepo');
+      expect(
+        existsSync(join(projectDir, 'services/backend/package.json')),
+      ).toBe(true);
+      expect(
+        existsSync(join(projectDir, 'services/backend/gkm.config.ts')),
+      ).toBe(true);
+
+      const pkgPath = join(projectDir, 'services/backend/package.json');
+      const content = await readFile(pkgPath, 'utf-8');
+      const pkg = JSON.parse(content);
+      expect(pkg.name).toBe('@my-monorepo/backend');
+    });
+  });
+
+  describe('docker-compose', () => {
+    it('should include postgres for database-enabled projects', async () => {
+      await initCommand('my-api', {
+        template: 'minimal',
+        yes: true,
+        skipInstall: true,
+      });
+
+      const dockerPath = join(tempDir, 'my-api', 'docker-compose.yml');
+      const content = await readFile(dockerPath, 'utf-8');
+      expect(content).toContain('postgres:16-alpine');
+      expect(content).toContain('5432:5432');
+    });
+
+    it('should include serverless-redis-http for serverless template', async () => {
+      await initCommand('my-api', {
+        template: 'serverless',
+        yes: true,
+        skipInstall: true,
+      });
+
+      const dockerPath = join(tempDir, 'my-api', 'docker-compose.yml');
+      const content = await readFile(dockerPath, 'utf-8');
+      expect(content).toContain('hiett/serverless-redis-http');
+    });
+
+    it('should include rabbitmq for worker template', async () => {
+      await initCommand('my-api', {
+        template: 'worker',
+        yes: true,
+        skipInstall: true,
+      });
+
+      const dockerPath = join(tempDir, 'my-api', 'docker-compose.yml');
+      const content = await readFile(dockerPath, 'utf-8');
+      expect(content).toContain('rabbitmq:3-management-alpine');
+      expect(content).toContain('5672:5672');
+      expect(content).toContain('15672:15672');
+    });
+  });
+});

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

@@ -0,0 +1,104 @@
+import { mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  checkDirectoryExists,
+  detectPackageManager,
+  validateProjectName,
+} from '../utils.js';
+
+describe('validateProjectName', () => {
+  it('should accept valid project names', () => {
+    expect(validateProjectName('my-project')).toBe(true);
+    expect(validateProjectName('my_project')).toBe(true);
+    expect(validateProjectName('myProject')).toBe(true);
+    expect(validateProjectName('my-project-123')).toBe(true);
+    expect(validateProjectName('project')).toBe(true);
+  });
+
+  it('should reject empty names', () => {
+    expect(validateProjectName('')).toBe('Project name is required');
+  });
+
+  it('should reject names with invalid characters', () => {
+    const result = validateProjectName('my project');
+    expect(result).toContain('can only contain');
+  });
+
+  it('should accept scoped package names', () => {
+    // @ / . are valid for scoped npm packages
+    expect(validateProjectName('@my/project')).toBe(true);
+    expect(validateProjectName('my.project')).toBe(true);
+  });
+
+  it('should reject names with other special characters', () => {
+    expect(validateProjectName('my$project')).toContain('can only contain');
+    expect(validateProjectName('my#project')).toContain('can only contain');
+    expect(validateProjectName('my!project')).toContain('can only contain');
+  });
+});
+
+describe('checkDirectoryExists', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `cli-test-${Date.now()}`);
+    await mkdir(tempDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('should return true for non-existent directory', () => {
+    expect(checkDirectoryExists('non-existent-dir', tempDir)).toBe(true);
+  });
+
+  it('should return error for existing directory', async () => {
+    const existingDir = 'existing-dir';
+    await mkdir(join(tempDir, existingDir));
+    const result = checkDirectoryExists(existingDir, tempDir);
+    expect(result).toContain('already exists');
+  });
+});
+
+describe('detectPackageManager', () => {
+  let tempDir: string;
+  let originalEnv: string | undefined;
+
+  beforeEach(async () => {
+    tempDir = join(tmpdir(), `cli-test-${Date.now()}`);
+    await mkdir(tempDir, { recursive: true });
+    originalEnv = process.env.npm_config_user_agent;
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+    if (originalEnv !== undefined) {
+      process.env.npm_config_user_agent = originalEnv;
+    } else {
+      delete process.env.npm_config_user_agent;
+    }
+  });
+
+  it('should detect pnpm from user agent', () => {
+    process.env.npm_config_user_agent = 'pnpm/8.0.0';
+    expect(detectPackageManager(tempDir)).toBe('pnpm');
+  });
+
+  it('should detect yarn from user agent', () => {
+    process.env.npm_config_user_agent = 'yarn/4.0.0';
+    expect(detectPackageManager(tempDir)).toBe('yarn');
+  });
+
+  it('should detect bun from user agent', () => {
+    process.env.npm_config_user_agent = 'bun/1.0.0';
+    expect(detectPackageManager(tempDir)).toBe('bun');
+  });
+
+  it('should default to npm when no lockfile or user agent', () => {
+    delete process.env.npm_config_user_agent;
+    expect(detectPackageManager(tempDir)).toBe('npm');
+  });
+});

package/src/init/generators/config.ts

@@ -0,0 +1,192 @@
+import type {
+  GeneratedFile,
+  TemplateConfig,
+  TemplateOptions,
+} from '../templates/index.js';
+
+/**
+ * Generate configuration files (gkm.config.ts, tsconfig.json, biome.json, turbo.json)
+ */
+export function generateConfigFiles(
+  options: TemplateOptions,
+  template: TemplateConfig,
+): GeneratedFile[] {
+  const { telescope } = options;
+  const isServerless = template.name === 'serverless';
+  const hasWorker = template.name === 'worker';
+
+  // Build gkm.config.ts
+  let gkmConfig = `import { defineConfig } from '@geekmidas/cli';
+
+export default defineConfig({
+  routes: './src/endpoints/**/*.ts',
+  envParser: './src/config/env',
+  logger: './src/config/logger',`;
+
+  if (isServerless || hasWorker) {
+    gkmConfig += `
+  functions: './src/functions/**/*.ts',`;
+  }
+
+  if (hasWorker) {
+    gkmConfig += `
+  crons: './src/crons/**/*.ts',
+  subscribers: './src/subscribers/**/*.ts',`;
+  }
+
+  if (telescope) {
+    gkmConfig += `
+  telescope: {
+    enabled: true,
+    path: '/__telescope',
+  },`;
+  }
+
+  gkmConfig += `
+});
+`;
+
+  // Build tsconfig.json - extends root for monorepo, standalone for non-monorepo
+  const tsConfig = options.monorepo
+    ? {
+        extends: '../../tsconfig.json',
+        compilerOptions: {
+          outDir: './dist',
+          rootDir: './src',
+          baseUrl: '.',
+          paths: {
+            [`@${options.name}/*`]: ['../../packages/*/src'],
+          },
+        },
+        include: ['src/**/*.ts'],
+        exclude: ['node_modules', 'dist'],
+      }
+    : {
+        compilerOptions: {
+          target: 'ES2022',
+          module: 'NodeNext',
+          moduleResolution: 'NodeNext',
+          lib: ['ES2022'],
+          strict: true,
+          esModuleInterop: true,
+          skipLibCheck: true,
+          forceConsistentCasingInFileNames: true,
+          resolveJsonModule: true,
+          declaration: true,
+          declarationMap: true,
+          outDir: './dist',
+          rootDir: './src',
+        },
+        include: ['src/**/*.ts'],
+        exclude: ['node_modules', 'dist'],
+      };
+
+  // Skip biome.json and turbo.json for monorepo (they're at root)
+  if (options.monorepo) {
+    return [
+      {
+        path: 'gkm.config.ts',
+        content: gkmConfig,
+      },
+      {
+        path: 'tsconfig.json',
+        content: JSON.stringify(tsConfig, null, 2) + '\n',
+      },
+    ];
+  }
+
+  // Build biome.json
+  const biomeConfig = {
+    $schema: 'https://biomejs.dev/schemas/1.9.4/schema.json',
+    vcs: {
+      enabled: true,
+      clientKind: 'git',
+      useIgnoreFile: true,
+    },
+    organizeImports: {
+      enabled: true,
+    },
+    formatter: {
+      enabled: true,
+      indentStyle: 'space',
+      indentWidth: 2,
+      lineWidth: 80,
+    },
+    javascript: {
+      formatter: {
+        quoteStyle: 'single',
+        trailingCommas: 'all',
+        semicolons: 'always',
+        arrowParentheses: 'always',
+      },
+    },
+    linter: {
+      enabled: true,
+      rules: {
+        recommended: true,
+        correctness: {
+          noUnusedImports: 'error',
+          noUnusedVariables: 'error',
+        },
+        style: {
+          noNonNullAssertion: 'off',
+        },
+      },
+    },
+    files: {
+      ignore: ['node_modules', 'dist', '.gkm', 'coverage'],
+    },
+  };
+
+  // Build turbo.json
+  const turboConfig = {
+    $schema: 'https://turbo.build/schema.json',
+    tasks: {
+      build: {
+        dependsOn: ['^build'],
+        outputs: ['dist/**'],
+      },
+      dev: {
+        cache: false,
+        persistent: true,
+      },
+      test: {
+        dependsOn: ['^build'],
+        cache: false,
+      },
+      'test:once': {
+        dependsOn: ['^build'],
+        outputs: ['coverage/**'],
+      },
+      typecheck: {
+        dependsOn: ['^build'],
+        outputs: [],
+      },
+      lint: {
+        outputs: [],
+      },
+      fmt: {
+        outputs: [],
+      },
+    },
+  };
+
+  return [
+    {
+      path: 'gkm.config.ts',
+      content: gkmConfig,
+    },
+    {
+      path: 'tsconfig.json',
+      content: JSON.stringify(tsConfig, null, 2) + '\n',
+    },
+    {
+      path: 'biome.json',
+      content: JSON.stringify(biomeConfig, null, 2) + '\n',
+    },
+    {
+      path: 'turbo.json',
+      content: JSON.stringify(turboConfig, null, 2) + '\n',
+    },
+  ];
+}