@geekmidas/cli 0.0.26 → 0.2.0

package/src/__tests__/openapi.spec.ts

@@ -0,0 +1,362 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { openapiCommand } from '../openapi';
+import {
+  cleanupDir,
+  createMockEndpointFile,
+  createTempDir,
+  createTestFile,
+} from './test-helpers';
+
+describe('OpenAPI Generation', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await createTempDir('openapi-test-');
+  });
+
+  afterEach(async () => {
+    await cleanupDir(tempDir);
+    vi.restoreAllMocks();
+  });
+
+  describe('openapiCommand', () => {
+    it('should generate OpenAPI spec for endpoints', async () => {
+      // Create endpoint file
+      await createMockEndpointFile(
+        tempDir,
+        'getUser.ts',
+        'getUser',
+        '/users/:id',
+        'GET',
+      );
+
+      // Create config file
+      await createTestFile(
+        tempDir,
+        'gkm.config.json',
+        JSON.stringify({
+          routes: [`${tempDir}/**/*.ts`],
+        }),
+      );
+
+      const outputPath = join(tempDir, 'openapi.json');
+
+      // Mock process.cwd
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+
+      await openapiCommand({ output: outputPath });
+
+      // Verify file was created
+      expect(existsSync(outputPath)).toBe(true);
+
+      // Verify content
+      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);
+    });
+
+    it('should handle no endpoints found', async () => {
+      // Create config with no matching files
+      await createTestFile(
+        tempDir,
+        'gkm.config.json',
+        JSON.stringify({
+          routes: [`${tempDir}/nonexistent/**/*.ts`],
+        }),
+      );
+
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+      const consoleSpy = vi.spyOn(console, 'log');
+
+      await openapiCommand({ output: join(tempDir, 'openapi.json') });
+
+      expect(consoleSpy).toHaveBeenCalledWith('No valid endpoints found');
+    });
+
+    it('should use default output path when not specified', async () => {
+      // Create endpoint file
+      await createMockEndpointFile(
+        tempDir,
+        'endpoint.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      // Create config
+      await createTestFile(
+        tempDir,
+        'gkm.config.json',
+        JSON.stringify({
+          routes: [`${tempDir}/**/*.ts`],
+        }),
+      );
+
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+
+      await openapiCommand();
+
+      // Should create openapi.json in current directory
+      expect(existsSync(join(tempDir, 'openapi.json'))).toBe(true);
+    });
+
+    it('should generate spec with multiple endpoints', async () => {
+      // Create multiple endpoint files
+      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',
+      );
+
+      // Create config
+      await createTestFile(
+        tempDir,
+        'gkm.config.json',
+        JSON.stringify({
+          routes: [`${tempDir}/**/*.ts`],
+        }),
+      );
+
+      const outputPath = join(tempDir, 'openapi.json');
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+
+      await openapiCommand({ output: outputPath });
+
+      const content = await readFile(outputPath, 'utf-8');
+      const spec = JSON.parse(content);
+
+      // Should have multiple paths
+      expect(Object.keys(spec.paths).length).toBeGreaterThanOrEqual(1);
+    });
+
+    it('should create output directory if it does not exist', async () => {
+      // Create endpoint file
+      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, 'nested', 'dir', 'openapi.json');
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+
+      await openapiCommand({ output: outputPath });
+
+      expect(existsSync(outputPath)).toBe(true);
+    });
+
+    it('should include API metadata in spec', 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');
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+
+      await openapiCommand({ output: outputPath });
+
+      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 log generation success', 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');
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+      const consoleSpy = vi.spyOn(console, 'log');
+
+      await openapiCommand({ output: outputPath });
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('OpenAPI spec generated'),
+      );
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Found'));
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('endpoints'),
+      );
+    });
+
+    it('should throw error when config loading fails', async () => {
+      // No config file created
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+
+      await expect(openapiCommand()).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`],
+        }),
+      );
+
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+
+      // Should throw error for syntax errors
+      await expect(
+        openapiCommand({ output: join(tempDir, 'openapi.json') }),
+      ).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');
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+
+      await openapiCommand({ output: outputPath });
+
+      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 handle endpoints with complex schemas', async () => {
+      // Create endpoint with complex schema
+      const complexEndpointContent = `
+import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+
+export const complexEndpoint = e
+  .post('/complex')
+  .body(z.object({
+    user: z.object({
+      name: z.string(),
+      email: z.string().email(),
+      age: z.number().optional(),
+    }),
+    tags: z.array(z.string()),
+  }))
+  .output(z.object({
+    id: z.string(),
+    status: z.enum(['active', 'inactive']),
+  }))
+  .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`],
+        }),
+      );
+
+      const outputPath = join(tempDir, 'openapi.json');
+      vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+
+      await openapiCommand({ output: outputPath });
+
+      const content = await readFile(outputPath, 'utf-8');
+      const spec = JSON.parse(content);
+
+      // Should have generated schema for complex types
+      expect(spec.paths).toBeDefined();
+    });
+  });
+});

package/src/__tests__/test-helpers.ts

@@ -0,0 +1,180 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  CronBuilder,
+  type ScheduleExpression,
+} from '@geekmidas/constructs/crons';
+import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+
+/**
+ * Creates a temporary directory for testing
+ */
+export async function createTempDir(prefix = 'cli-test-'): Promise<string> {
+  const tempPath = join(
+    tmpdir(),
+    `${prefix}${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  await mkdir(tempPath, { recursive: true });
+  return tempPath;
+}
+
+/**
+ * Cleans up a directory
+ */
+export async function cleanupDir(path: string): Promise<void> {
+  try {
+    await rm(path, { recursive: true, force: true });
+  } catch (error) {
+    // Ignore errors during cleanup
+  }
+}
+
+/**
+ * Creates a test file with content
+ */
+export async function createTestFile(
+  dir: string,
+  filename: string,
+  content: string,
+): Promise<string> {
+  const filePath = join(dir, filename);
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+  return filePath;
+}
+
+/**
+ * Creates a mock endpoint file with real endpoint construct
+ */
+export async function createMockEndpointFile(
+  dir: string,
+  filename: string,
+  exportName: string,
+  path: string = '/test',
+  method: string = 'GET',
+): Promise<string> {
+  const content = `
+import { e } from '@geekmidas/constructs/endpoints';
+import { z } from 'zod';
+
+export const ${exportName} = e
+  .${method.toLowerCase()}('${path}')
+  .output(z.object({ message: z.string() }))
+  .handle(async () => ({ message: 'Hello from ${exportName}' }));
+`;
+  return createTestFile(dir, filename, content);
+}
+
+/**
+ * Creates a mock function file with real function construct
+ */
+export async function createMockFunctionFile(
+  dir: string,
+  filename: string,
+  exportName: string,
+  timeout = 30,
+): Promise<string> {
+  const content = `
+import { f } from '@geekmidas/constructs/functions';
+import { z } from 'zod';
+
+export const ${exportName} = f
+  .input(z.object({ name: z.string() }))
+  .output(z.object({ greeting: z.string() }))
+  .timeout(${timeout})
+  .handle(async ({ input }) => ({ greeting: \`Hello, \${input.name}!\` }));
+`;
+  return createTestFile(dir, filename, content);
+}
+
+/**
+ * Creates a mock cron file with real cron construct
+ */
+export async function createMockCronFile(
+  dir: string,
+  filename: string,
+  exportName: string,
+  schedule = 'rate(1 hour)',
+): Promise<string> {
+  const content = `
+import { CronBuilder } from '@geekmidas/constructs/crons';
+import { z } from 'zod';
+
+export const ${exportName} = new CronBuilder()
+  .schedule('${schedule}')
+  .output(z.object({ processed: z.number() }))
+  .handle(async () => {
+    console.log('Running cron job: ${exportName}');
+    return { processed: 10 };
+  });
+`;
+  return createTestFile(dir, filename, content);
+}
+
+/**
+ * Helper functions to create real constructs for testing
+ */
+export function createTestEndpoint(path: string, method: HttpMethod = 'GET') {
+  const m = method.toLowerCase() as Lowercase<HttpMethod>;
+  const builder = e[m](path);
+  builder.output(z.object({ message: z.string() }));
+  return builder.handle(async () => ({ message: `Hello from ${path}` }));
+}
+
+export function createTestFunction(timeout: number = 30) {
+  const builder = new FunctionBuilder();
+  builder.input(z.object({ name: z.string() }));
+  builder.output(z.object({ greeting: z.string() }));
+  builder.timeout(timeout);
+  return builder.handle(async ({ input }: any) => ({
+    greeting: `Hello, ${input.name}!`,
+  }));
+}
+
+export function createTestCron(
+  schedule: ScheduleExpression = 'rate(1 hour)',
+  timeout: number = 30,
+) {
+  const builder = new CronBuilder();
+  builder.schedule(schedule);
+  builder.output(z.object({ processed: z.number() }));
+  builder.timeout(timeout);
+  return builder.handle(async () => {
+    return { processed: 10 };
+  });
+}
+
+/**
+ * Creates a mock build context
+ */
+export function createMockBuildContext() {
+  return {
+    envParserPath: './env',
+    envParserImportPattern: 'envParser',
+    loggerPath: './logger',
+    loggerImportPattern: 'logger',
+  };
+}
+
+/**
+ * Waits for a condition to be true
+ */
+export async function waitFor(
+  condition: () => boolean,
+  timeout = 5000,
+  interval = 100,
+): Promise<void> {
+  const start = Date.now();
+  while (!condition() && Date.now() - start < timeout) {
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  if (!condition()) {
+    throw new Error('Timeout waiting for condition');
+  }
+}
+
+import { dirname } from 'node:path';
+import { FunctionBuilder } from '@geekmidas/constructs/functions';
+import type { HttpMethod } from '../../../api/src/constructs/types';