@geekmidas/cli 0.1.0 → 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

@@ -3,10 +3,9 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import {
   CronBuilder,
-  FunctionBuilder,
   type ScheduleExpression,
-} from '@geekmidas/api/constructs';
-import { e } from '@geekmidas/api/server';
+} from '@geekmidas/constructs/crons';
+import { e } from '@geekmidas/constructs/endpoints';
 import { z } from 'zod';
 
 /**
@@ -57,7 +56,7 @@ export async function createMockEndpointFile(
   method: string = 'GET',
 ): Promise<string> {
   const content = `
-import { e } from '@geekmidas/api/server';
+import { e } from '@geekmidas/constructs/endpoints';
 import { z } from 'zod';
 
 export const ${exportName} = e
@@ -78,10 +77,10 @@ export async function createMockFunctionFile(
   timeout = 30,
 ): Promise<string> {
   const content = `
-import { FunctionBuilder } from '@geekmidas/api/constructs';
+import { f } from '@geekmidas/constructs/functions';
 import { z } from 'zod';
 
-export const ${exportName} = new FunctionBuilder()
+export const ${exportName} = f
   .input(z.object({ name: z.string() }))
   .output(z.object({ greeting: z.string() }))
   .timeout(${timeout})
@@ -100,7 +99,7 @@ export async function createMockCronFile(
   schedule = 'rate(1 hour)',
 ): Promise<string> {
   const content = `
-import { CronBuilder } from '@geekmidas/api/constructs';
+import { CronBuilder } from '@geekmidas/constructs/crons';
 import { z } from 'zod';
 
 export const ${exportName} = new CronBuilder()
@@ -129,7 +128,9 @@ export function createTestFunction(timeout: number = 30) {
   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}!` }));
+  return builder.handle(async ({ input }: any) => ({
+    greeting: `Hello, ${input.name}!`,
+  }));
 }
 
 export function createTestCron(
@@ -175,4 +176,5 @@ export async function waitFor(
 }
 
 import { dirname } from 'node:path';
+import { FunctionBuilder } from '@geekmidas/constructs/functions';
 import type { HttpMethod } from '../../../api/src/constructs/types';

package/src/build/__tests__/index-new.spec.ts

@@ -69,9 +69,19 @@ export default {
 
         // Check that output directories were created
         const serverDir = join(dir, '.gkm', 'server');
-        expect(await readFile(join(serverDir, 'app.ts'), 'utf-8')).toContain(
-          'HonoEndpoint',
+
+        // Check app.ts has the createApp function with new API
+        const appContent = await readFile(join(serverDir, 'app.ts'), 'utf-8');
+        expect(appContent).toContain('function createApp');
+        expect(appContent).toContain('interface ServerApp');
+        expect(appContent).toContain('async start(options');
+
+        // Check endpoints.ts has the HonoEndpoint setup
+        const endpointsContent = await readFile(
+          join(serverDir, 'endpoints.ts'),
+          'utf-8',
         );
+        expect(endpointsContent).toContain('HonoEndpoint');
       } finally {
         process.chdir(originalCwd);
       }
@@ -192,29 +202,38 @@ export default {
           ),
         ).toContain('AmazonApiGatewayV2Endpoint');
 
-        // Verify unified manifests were created with all construct types
-        const lambdaManifestPath = join(awsLambdaDir, 'manifest.json');
-        const apiGatewayManifestPath = join(awsApiGatewayV2Dir, 'manifest.json');
-
-        const lambdaManifest = JSON.parse(
-          await readFile(lambdaManifestPath, 'utf-8'),
-        );
-        const apiGatewayManifest = JSON.parse(
-          await readFile(apiGatewayManifestPath, 'utf-8'),
-        );
+        // Verify unified manifest was created at root .gkm directory
+        const manifestPath = join(dir, '.gkm', 'manifest.json');
+        const manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
 
-        // Verify Lambda manifest structure
-        expect(lambdaManifest).toMatchObject({
+        // Verify manifest structure includes all routes from both providers
+        expect(manifest).toMatchObject({
           routes: expect.arrayContaining([
+            // Routes from aws-lambda provider
             expect.objectContaining({
               path: '/users',
               method: 'GET',
-              handler: expect.stringContaining('routes/getUsersEndpoint.handler'),
+              handler: expect.stringContaining(
+                'routes/getUsersEndpoint.handler',
+              ),
             }),
             expect.objectContaining({
               path: '/posts',
               method: 'POST',
-              handler: expect.stringContaining('routes/getPostsEndpoint.handler'),
+              handler: expect.stringContaining(
+                'routes/getPostsEndpoint.handler',
+              ),
+            }),
+            // Routes from aws-apigatewayv2 provider
+            expect.objectContaining({
+              path: '/users',
+              method: 'GET',
+              handler: expect.stringContaining('getUsersEndpoint.handler'),
+            }),
+            expect.objectContaining({
+              path: '/posts',
+              method: 'POST',
+              handler: expect.stringContaining('getPostsEndpoint.handler'),
             }),
           ]),
           functions: expect.arrayContaining([
@@ -251,31 +270,10 @@ export default {
           ]),
         });
 
-        // Verify API Gateway manifest structure
-        expect(apiGatewayManifest).toMatchObject({
-          routes: expect.arrayContaining([
-            expect.objectContaining({
-              path: '/users',
-              method: 'GET',
-              handler: expect.stringContaining('getUsersEndpoint.handler'),
-            }),
-            expect.objectContaining({
-              path: '/posts',
-              method: 'POST',
-              handler: expect.stringContaining('getPostsEndpoint.handler'),
-            }),
-          ]),
-          functions: [],
-          crons: [],
-        });
-
-        // Verify counts
-        expect(lambdaManifest.routes).toHaveLength(2);
-        expect(lambdaManifest.functions).toHaveLength(2);
-        expect(lambdaManifest.crons).toHaveLength(2);
-        expect(apiGatewayManifest.routes).toHaveLength(2);
-        expect(apiGatewayManifest.functions).toHaveLength(0);
-        expect(apiGatewayManifest.crons).toHaveLength(0);
+        // Verify counts - should have duplicated routes (one for each provider)
+        expect(manifest.routes).toHaveLength(4); // 2 routes x 2 providers
+        expect(manifest.functions).toHaveLength(2);
+        expect(manifest.crons).toHaveLength(2);
       } finally {
         process.chdir(originalCwd);
       }
@@ -313,8 +311,9 @@ export default {
       expect(logSpy).toHaveBeenCalledWith('Found 0 endpoints');
       expect(logSpy).toHaveBeenCalledWith('Found 0 functions');
       expect(logSpy).toHaveBeenCalledWith('Found 0 crons');
+      expect(logSpy).toHaveBeenCalledWith('Found 0 subscribers');
       expect(logSpy).toHaveBeenCalledWith(
-        'No endpoints, functions, or crons found to process',
+        'No endpoints, functions, crons, or subscribers found to process',
       );
     } finally {
       process.chdir(originalCwd);