@geekmidas/cli 0.5.0 → 0.6.0

package/src/__tests__/openapi.spec.ts

@@ -1,8 +1,14 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { existsSync, realpathSync } from 'node:fs';
+import { readFile, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { openapiCommand } from '../openapi';
+import {
+  OPENAPI_OUTPUT_PATH,
+  generateOpenApi,
+  openapiCommand,
+  resolveOpenApiConfig,
+} from '../openapi';
+import type { GkmConfig } from '../types';
 import {
   cleanupDir,
   createMockEndpointFile,
@@ -10,328 +16,419 @@ import {
   createTestFile,
 } from './test-helpers';
 
-describe('OpenAPI Generation', () => {
+describe('resolveOpenApiConfig', () => {
+  const baseConfig: GkmConfig = {
+    routes: './src/endpoints/**/*.ts',
+    envParser: './src/config/env#envParser',
+    logger: './src/config/logger#logger',
+  };
+
+  it('should return disabled when openapi is false', () => {
+    const result = resolveOpenApiConfig({ ...baseConfig, openapi: false });
+    expect(result).toEqual({ enabled: false });
+  });
+
+  it('should return enabled with defaults when openapi is true', () => {
+    const result = resolveOpenApiConfig({ ...baseConfig, openapi: true });
+    expect(result).toEqual({
+      enabled: true,
+      title: 'API Documentation',
+      version: '1.0.0',
+      description: 'Auto-generated API documentation from endpoints',
+    });
+  });
+
+  it('should return disabled when openapi is undefined', () => {
+    const result = resolveOpenApiConfig({ ...baseConfig });
+    expect(result.enabled).toBe(false);
+  });
+
+  it('should use custom config values when provided', () => {
+    const result = resolveOpenApiConfig({
+      ...baseConfig,
+      openapi: {
+        enabled: true,
+        title: 'My API',
+        version: '2.0.0',
+        description: 'Custom description',
+      },
+    });
+    expect(result).toEqual({
+      enabled: true,
+      title: 'My API',
+      version: '2.0.0',
+      description: 'Custom description',
+    });
+  });
+
+  it('should use defaults for missing optional config values', () => {
+    const result = resolveOpenApiConfig({
+      ...baseConfig,
+      openapi: { enabled: true },
+    });
+    expect(result).toEqual({
+      enabled: true,
+      title: 'API Documentation',
+      version: '1.0.0',
+      description: 'Auto-generated API documentation from endpoints',
+    });
+  });
+
+  it('should be enabled by default when object provided without enabled field', () => {
+    const result = resolveOpenApiConfig({
+      ...baseConfig,
+      openapi: { title: 'Custom Title' },
+    });
+    expect(result.enabled).toBe(true);
+  });
+});
+
+describe('generateOpenApi', () => {
   let tempDir: string;
+  const originalCwd = process.cwd();
 
   beforeEach(async () => {
-    tempDir = await createTempDir('openapi-test-');
+    tempDir = realpathSync(await createTempDir('openapi-gen-'));
+    // Change to temp dir so output goes there
+    process.chdir(tempDir);
   });
 
   afterEach(async () => {
+    process.chdir(originalCwd);
     await cleanupDir(tempDir);
     vi.restoreAllMocks();
   });
 
-  describe('openapiCommand - TypeScript output (default)', () => {
-    it('should generate TypeScript module by default', async () => {
-      await createMockEndpointFile(
-        tempDir,
-        'getUser.ts',
-        'getUser',
-        '/users/:id',
-        'GET',
-      );
+  it('should return null when openapi is disabled', async () => {
+    const config: GkmConfig = {
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+      openapi: false,
+    };
 
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
+    const result = await generateOpenApi(config);
+    expect(result).toBeNull();
+  });
 
-      const outputPath = join(tempDir, 'openapi.ts');
+  it('should return null when openapi is undefined', async () => {
+    const config: GkmConfig = {
+      routes: './src/endpoints/**/*.ts',
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+    };
 
-      await openapiCommand({ output: outputPath, cwd: tempDir });
+    const result = await generateOpenApi(config);
+    expect(result).toBeNull();
+  });
 
-      expect(existsSync(outputPath)).toBe(true);
+  it('should generate to fixed .gkm/openapi.ts path', async () => {
+    await createMockEndpointFile(tempDir, 'test.ts', 'test', '/test', 'GET');
 
-      const content = await readFile(outputPath, 'utf-8');
+    const config: GkmConfig = {
+      routes: `${tempDir}/**/*.ts`,
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+      openapi: { enabled: true },
+    };
 
-      expect(content).toContain('// Auto-generated by @geekmidas/cli');
-      expect(content).toContain('export const securitySchemes');
-      expect(content).toContain('export const endpointAuth');
-      expect(content).toContain('export interface paths');
-    });
+    const result = await generateOpenApi(config, { silent: true });
 
-    it('should include endpoint auth map', async () => {
-      await createMockEndpointFile(
-        tempDir,
-        'getUser.ts',
-        'getUser',
-        '/users/:id',
-        'GET',
-      );
+    expect(result).not.toBeNull();
+    expect(result?.endpointCount).toBe(1);
+    expect(result?.outputPath).toBe(join(tempDir, OPENAPI_OUTPUT_PATH));
+    expect(existsSync(join(tempDir, OPENAPI_OUTPUT_PATH))).toBe(true);
+  });
 
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
+  it('should generate TypeScript content', async () => {
+    await createMockEndpointFile(tempDir, 'test.ts', 'test', '/test', 'GET');
 
-      const outputPath = join(tempDir, 'openapi.ts');
+    const config: GkmConfig = {
+      routes: `${tempDir}/**/*.ts`,
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+      openapi: { enabled: true },
+    };
 
-      await openapiCommand({ output: outputPath, cwd: tempDir });
+    await generateOpenApi(config, { silent: true });
 
-      const content = await readFile(outputPath, 'utf-8');
+    const content = await readFile(join(tempDir, OPENAPI_OUTPUT_PATH), 'utf-8');
+    expect(content).toContain('// Auto-generated by @geekmidas/cli');
+    expect(content).toContain('export const securitySchemes');
+    expect(content).toContain('export interface paths');
+  });
 
-      expect(content).toContain('endpointAuth');
-      expect(content).toContain("'GET /users/{id}'");
-    });
+  it('should log no endpoints message when none found', async () => {
+    const config: GkmConfig = {
+      routes: `${tempDir}/nonexistent/**/*.ts`,
+      envParser: './src/config/env#envParser',
+      logger: './src/config/logger#logger',
+      openapi: { enabled: true },
+    };
+
+    const consoleSpy = vi.spyOn(console, 'log');
+    const result = await generateOpenApi(config);
+
+    expect(result).toBeNull();
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'No valid endpoints found for OpenAPI generation',
+    );
   });
+});
 
-  describe('openapiCommand - JSON output (legacy)', () => {
-    it('should generate JSON OpenAPI spec with --json flag', async () => {
-      await createMockEndpointFile(
-        tempDir,
-        'getUser.ts',
-        'getUser',
-        '/users/:id',
-        'GET',
-      );
-
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
-
-      const outputPath = join(tempDir, 'openapi.json');
-
-      await openapiCommand({ output: outputPath, json: true, cwd: tempDir });
-
-      expect(existsSync(outputPath)).toBe(true);
-
-      const content = await readFile(outputPath, 'utf-8');
-      const spec = JSON.parse(content);
-
-      expect(spec).toHaveProperty('openapi');
-      expect(spec).toHaveProperty('info');
-      expect(spec.info.title).toBe('API Documentation');
-      expect(spec).toHaveProperty('paths');
-      expect(Object.keys(spec.paths).length).toBeGreaterThan(0);
-    });
+describe('openapiCommand', () => {
+  let tempDir: string;
+  const originalCwd = process.cwd();
 
-    it('should handle no endpoints found', async () => {
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/nonexistent/**/*.ts`],
-        }),
-      );
+  beforeEach(async () => {
+    tempDir = realpathSync(await createTempDir('openapi-cmd-'));
+  });
 
-      const consoleSpy = vi.spyOn(console, 'log');
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    // Clean up any generated .gkm folder in current directory
+    await rm(join(originalCwd, '.gkm'), { recursive: true, force: true });
+    await cleanupDir(tempDir);
+    vi.restoreAllMocks();
+  });
 
-      await openapiCommand({
-        output: join(tempDir, 'openapi.json'),
-        json: true,
-        cwd: tempDir,
-      });
+  it('should generate OpenAPI client to .gkm/openapi.ts', async () => {
+    await createMockEndpointFile(
+      tempDir,
+      'test.ts',
+      'testEndpoint',
+      '/test',
+      'GET',
+    );
+
+    await createTestFile(
+      tempDir,
+      'gkm.config.json',
+      JSON.stringify({
+        routes: [`${tempDir}/**/*.ts`],
+        openapi: { enabled: true },
+      }),
+    );
+
+    // Change to temp dir so output goes there
+    process.chdir(tempDir);
+
+    await openapiCommand({ cwd: tempDir });
+
+    const outputPath = join(tempDir, OPENAPI_OUTPUT_PATH);
+    expect(existsSync(outputPath)).toBe(true);
+
+    const content = await readFile(outputPath, 'utf-8');
+    expect(content).toContain('// Auto-generated by @geekmidas/cli');
+  });
 
-      expect(consoleSpy).toHaveBeenCalledWith('No valid endpoints found');
-    });
+  it('should enable openapi with defaults when not configured', async () => {
+    await createMockEndpointFile(
+      tempDir,
+      'test.ts',
+      'testEndpoint',
+      '/test',
+      'GET',
+    );
+
+    await createTestFile(
+      tempDir,
+      'gkm.config.json',
+      JSON.stringify({
+        routes: [`${tempDir}/**/*.ts`],
+      }),
+    );
+
+    process.chdir(tempDir);
+    const consoleSpy = vi.spyOn(console, 'log');
+
+    await openapiCommand({ cwd: tempDir });
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Found 1 endpoints'),
+    );
+    expect(existsSync(join(tempDir, OPENAPI_OUTPUT_PATH))).toBe(true);
+  });
 
-    it('should generate spec with multiple endpoints', async () => {
-      await createMockEndpointFile(
-        tempDir,
-        'getUsers.ts',
-        'getUsers',
-        '/users',
-        'GET',
-      );
-      await createMockEndpointFile(
-        tempDir,
-        'createUser.ts',
-        'createUser',
-        '/users',
-        'POST',
-      );
-      await createMockEndpointFile(
-        tempDir,
-        'deleteUser.ts',
-        'deleteUser',
-        '/users/:id',
-        'DELETE',
-      );
-
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
-
-      const outputPath = join(tempDir, 'openapi.json');
-
-      await openapiCommand({ output: outputPath, json: true, cwd: tempDir });
-
-      const content = await readFile(outputPath, 'utf-8');
-      const spec = JSON.parse(content);
-
-      expect(Object.keys(spec.paths).length).toBeGreaterThanOrEqual(1);
-    });
+  it('should include endpoint auth map', async () => {
+    await createMockEndpointFile(
+      tempDir,
+      'getUser.ts',
+      'getUser',
+      '/users/:id',
+      'GET',
+    );
+
+    await createTestFile(
+      tempDir,
+      'gkm.config.json',
+      JSON.stringify({
+        routes: [`${tempDir}/**/*.ts`],
+        openapi: { enabled: true },
+      }),
+    );
+
+    process.chdir(tempDir);
+
+    await openapiCommand({ cwd: tempDir });
+
+    const content = await readFile(join(tempDir, OPENAPI_OUTPUT_PATH), 'utf-8');
+    expect(content).toContain('endpointAuth');
+    expect(content).toContain("'GET /users/{id}'");
+  });
 
-    it('should create output directory if it does not exist', async () => {
-      await createMockEndpointFile(
-        tempDir,
-        'endpoint.ts',
-        'testEndpoint',
-        '/test',
-        'GET',
-      );
+  it('should handle no endpoints found', async () => {
+    await createTestFile(
+      tempDir,
+      'gkm.config.json',
+      JSON.stringify({
+        routes: [`${tempDir}/nonexistent/**/*.ts`],
+        openapi: { enabled: true },
+      }),
+    );
 
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
+    process.chdir(tempDir);
+    const consoleSpy = vi.spyOn(console, 'log');
 
-      const outputPath = join(tempDir, 'nested', 'dir', 'openapi.json');
+    await openapiCommand({ cwd: tempDir });
 
-      await openapiCommand({ output: outputPath, json: true, cwd: tempDir });
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'No valid endpoints found for OpenAPI generation',
+    );
+  });
 
-      expect(existsSync(outputPath)).toBe(true);
-    });
+  it('should generate with multiple endpoints', async () => {
+    await createMockEndpointFile(
+      tempDir,
+      'getUsers.ts',
+      'getUsers',
+      '/users',
+      'GET',
+    );
+    await createMockEndpointFile(
+      tempDir,
+      'createUser.ts',
+      'createUser',
+      '/users',
+      'POST',
+    );
+    await createMockEndpointFile(
+      tempDir,
+      'deleteUser.ts',
+      'deleteUser',
+      '/users/:id',
+      'DELETE',
+    );
+
+    await createTestFile(
+      tempDir,
+      'gkm.config.json',
+      JSON.stringify({
+        routes: [`${tempDir}/**/*.ts`],
+        openapi: { enabled: true },
+      }),
+    );
+
+    process.chdir(tempDir);
+    const consoleSpy = vi.spyOn(console, 'log');
+
+    await openapiCommand({ cwd: tempDir });
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Found 3 endpoints'),
+    );
+  });
 
-    it('should include API metadata in spec', async () => {
-      await createMockEndpointFile(
-        tempDir,
-        'endpoint.ts',
-        'testEndpoint',
-        '/test',
-        'GET',
-      );
-
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
-
-      const outputPath = join(tempDir, 'openapi.json');
-
-      await openapiCommand({ output: outputPath, json: true, cwd: tempDir });
-
-      const content = await readFile(outputPath, 'utf-8');
-      const spec = JSON.parse(content);
-
-      expect(spec.info).toEqual({
-        title: 'API Documentation',
-        version: '1.0.0',
-        description: 'Auto-generated API documentation from endpoints',
-      });
-    });
+  it('should create .gkm directory if it does not exist', async () => {
+    await createMockEndpointFile(
+      tempDir,
+      'endpoint.ts',
+      'testEndpoint',
+      '/test',
+      'GET',
+    );
+
+    await createTestFile(
+      tempDir,
+      'gkm.config.json',
+      JSON.stringify({
+        routes: [`${tempDir}/**/*.ts`],
+        openapi: { enabled: true },
+      }),
+    );
+
+    process.chdir(tempDir);
+
+    await openapiCommand({ cwd: tempDir });
+
+    expect(existsSync(join(tempDir, '.gkm'))).toBe(true);
+    expect(existsSync(join(tempDir, OPENAPI_OUTPUT_PATH))).toBe(true);
+  });
 
-    it('should log generation success for JSON', async () => {
-      // Create endpoint
-      await createMockEndpointFile(
-        tempDir,
-        'endpoint.ts',
-        'testEndpoint',
-        '/test',
-        'GET',
-      );
-
-      // Create config
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
-
-      const outputPath = join(tempDir, 'openapi.json');
-      const consoleSpy = vi.spyOn(console, 'log');
-
-      await openapiCommand({ output: outputPath, json: true, cwd: tempDir });
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('OpenAPI JSON spec generated'),
-      );
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Found'));
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('endpoints'),
-      );
-    });
+  it('should throw error when config loading fails', async () => {
+    process.chdir(tempDir);
 
-    it('should throw error when config loading fails', async () => {
-      // No config file created
-      await expect(
-        openapiCommand({ json: true, cwd: tempDir }),
-      ).rejects.toThrow(/OpenAPI generation failed/);
-    });
+    await expect(openapiCommand({ cwd: tempDir })).rejects.toThrow(
+      /OpenAPI generation failed/,
+    );
+  });
 
-    it('should throw error for invalid TypeScript files', async () => {
-      // Create invalid TS file
-      await createTestFile(
-        tempDir,
-        'invalid.ts',
-        'this is not valid typescript {[}]',
-      );
-
-      // Create config
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
-
-      // Should throw error for syntax errors
-      await expect(
-        openapiCommand({
-          output: join(tempDir, 'openapi.json'),
-          json: true,
-          cwd: tempDir,
-        }),
-      ).rejects.toThrow(/OpenAPI generation failed/);
-    });
+  it('should throw error for invalid TypeScript files', async () => {
+    await createTestFile(
+      tempDir,
+      'invalid.ts',
+      'this is not valid typescript {[}]',
+    );
+
+    await createTestFile(
+      tempDir,
+      'gkm.config.json',
+      JSON.stringify({
+        routes: [`${tempDir}/**/*.ts`],
+        openapi: { enabled: true },
+      }),
+    );
+
+    process.chdir(tempDir);
+
+    await expect(openapiCommand({ cwd: tempDir })).rejects.toThrow(
+      /OpenAPI generation failed/,
+    );
+  });
 
-    it('should generate valid JSON format', async () => {
-      // Create endpoint
-      await createMockEndpointFile(
-        tempDir,
-        'endpoint.ts',
-        'testEndpoint',
-        '/test',
-        'GET',
-      );
-
-      // Create config
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
-
-      const outputPath = join(tempDir, 'openapi.json');
-
-      await openapiCommand({ output: outputPath, json: true, cwd: tempDir });
-
-      const content = await readFile(outputPath, 'utf-8');
-
-      // Should be valid JSON and properly formatted
-      expect(() => JSON.parse(content)).not.toThrow();
-      expect(content).toContain('\n'); // Formatted with indentation
-    });
+  it('should log generation success', async () => {
+    await createMockEndpointFile(
+      tempDir,
+      'endpoint.ts',
+      'testEndpoint',
+      '/test',
+      'GET',
+    );
+
+    await createTestFile(
+      tempDir,
+      'gkm.config.json',
+      JSON.stringify({
+        routes: [`${tempDir}/**/*.ts`],
+        openapi: { enabled: true },
+      }),
+    );
+
+    process.chdir(tempDir);
+    const consoleSpy = vi.spyOn(console, 'log');
+
+    await openapiCommand({ cwd: tempDir });
+
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('OpenAPI client generated'),
+    );
+    expect(consoleSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Found 1 endpoints'),
+    );
+  });
 
-    it('should handle endpoints with complex schemas', async () => {
-      // Create endpoint with complex schema
-      const complexEndpointContent = `
+  it('should handle endpoints with complex schemas', async () => {
+    const complexEndpointContent = `
 import { e } from '@geekmidas/constructs/endpoints';
 import { z } from 'zod';
 
@@ -352,26 +449,22 @@ export const complexEndpoint = e
   .handle(async () => ({ id: '123', status: 'active' as const }));
 `;
 
-      await createTestFile(tempDir, 'complex.ts', complexEndpointContent);
-
-      // Create config
-      await createTestFile(
-        tempDir,
-        'gkm.config.json',
-        JSON.stringify({
-          routes: [`${tempDir}/**/*.ts`],
-        }),
-      );
+    await createTestFile(tempDir, 'complex.ts', complexEndpointContent);
 
-      const outputPath = join(tempDir, 'openapi.json');
+    await createTestFile(
+      tempDir,
+      'gkm.config.json',
+      JSON.stringify({
+        routes: [`${tempDir}/**/*.ts`],
+        openapi: { enabled: true },
+      }),
+    );
 
-      await openapiCommand({ output: outputPath, json: true, cwd: tempDir });
+    process.chdir(tempDir);
 
-      const content = await readFile(outputPath, 'utf-8');
-      const spec = JSON.parse(content);
+    await openapiCommand({ cwd: tempDir });
 
-      // Should have generated schema for complex types
-      expect(spec.paths).toBeDefined();
-    });
+    const content = await readFile(join(tempDir, OPENAPI_OUTPUT_PATH), 'utf-8');
+    expect(content).toContain('export interface paths');
   });
 });