@geekmidas/cli 0.0.26 → 0.2.0

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

@@ -0,0 +1,394 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { Endpoint } from '@geekmidas/constructs/endpoints';
+import { itWithDir } from '@geekmidas/testkit/os';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import type { HttpMethod } from '@geekmidas/constructs';
+import {
+  createMockBuildContext,
+  createMockEndpointFile,
+  createTestEndpoint,
+} from '../../__tests__/test-helpers';
+import { EndpointGenerator } from '../EndpointGenerator';
+import type { GeneratedConstruct } from '../Generator';
+
+describe('EndpointGenerator', () => {
+  let tempDir: string;
+  let outputDir: string;
+  let generator: EndpointGenerator;
+  let context: ReturnType<typeof createMockBuildContext>;
+
+  beforeEach(async () => {
+    generator = new EndpointGenerator();
+    context = createMockBuildContext();
+  });
+
+  afterEach(async () => {});
+
+  it('should identify valid endpoints', () => {
+    const testEndpoint = createTestEndpoint('/test', 'GET');
+    expect(generator.isConstruct(testEndpoint)).toBe(true);
+  });
+
+  it('should reject invalid constructs', () => {
+    expect(generator.isConstruct({})).toBe(false);
+    expect(generator.isConstruct('string')).toBe(false);
+    expect(generator.isConstruct(null)).toBe(false);
+  });
+
+  const createTestEndpointConstruct = (
+    key: string,
+    path: string,
+    method: HttpMethod,
+    dir: string,
+  ): GeneratedConstruct<Endpoint<any, any, any, any, any, any>> => ({
+    key,
+    name: key.toLowerCase(),
+    construct: createTestEndpoint(path, method),
+    path: {
+      absolute: join(dir, `${key}.ts`),
+      relative: `./${key}.ts`,
+    },
+  });
+
+  itWithDir('should generate a single server app file', async ({ dir }) => {
+    const outputDir = join(dir, 'output');
+    const routesDir = join(dir, 'routes');
+    await mkdir(outputDir, { recursive: true });
+
+    await Promise.all([
+      createMockEndpointFile(
+        routesDir,
+        'testEndpoint.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      ),
+      createMockEndpointFile(
+        routesDir,
+        'anotherEndpoint.ts',
+        'anotherEndpoint',
+        '/another',
+        'POST',
+      ),
+    ]);
+
+    const constructs = await generator.load('**/routes/*.ts', dir);
+
+    const routes = await generator.build(context, constructs, outputDir, {
+      provider: 'server',
+      enableOpenApi: true,
+    });
+
+    expect(routes).toHaveLength(1);
+    expect(routes[0]).toMatchObject({
+      path: '*',
+      method: 'ALL',
+      handler: expect.stringContaining('app.ts'),
+    });
+
+    // Check that the app.ts file was created
+    const appPath = join(outputDir, 'app.ts');
+    const appContent = await readFile(appPath, 'utf-8');
+
+    expect(appContent).toContain('import { setupEndpoints }');
+    expect(appContent).toContain('import { setupSubscribers }');
+    expect(appContent).toContain('function createApp');
+    expect(appContent).toContain('app?: HonoType');
+    expect(appContent).toContain('enableOpenApi: boolean = true');
+    expect(appContent).toContain('interface ServerApp');
+    expect(appContent).toContain('async start(options');
+    expect(appContent).toContain('serve: (app: HonoType, port: number)');
+
+    // Check that the endpoints.ts file was created with endpoint logic
+    const endpointsPath = join(outputDir, 'endpoints.ts');
+    const endpointsContent = await readFile(endpointsPath, 'utf-8');
+
+    expect(endpointsContent).toContain('import { HonoEndpoint }');
+    expect(endpointsContent).toContain('import { testEndpoint }');
+    expect(endpointsContent).toContain('import { anotherEndpoint }');
+    // Function signature always defaults to true
+    expect(endpointsContent).toContain('enableOpenApi: boolean = true');
+    // OpenAPI options are configured based on the parameter
+    expect(endpointsContent).toContain("docsPath: '/docs'");
+  });
+
+  itWithDir(
+    'should generate server app without OpenAPI when disabled',
+    async ({ dir }) => {
+      const outputDir = join(dir, 'output');
+      const routesDir = join(dir, 'routes');
+      await mkdir(outputDir, { recursive: true });
+
+      await createMockEndpointFile(
+        routesDir,
+        'testEndpoint.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      const constructs = await generator.load('**/routes/*.ts', dir);
+
+      await generator.build(context, constructs, outputDir, {
+        provider: 'server',
+        enableOpenApi: false,
+      });
+
+      const appPath = join(outputDir, 'app.ts');
+      const appContent = await readFile(appPath, 'utf-8');
+
+      expect(appContent).toContain('function createApp');
+
+      // Check that the endpoints.ts file defaults to true (but can be overridden)
+      const endpointsPath = join(outputDir, 'endpoints.ts');
+      const endpointsContent = await readFile(endpointsPath, 'utf-8');
+
+      // The function signature always defaults to true
+      expect(endpointsContent).toContain('enableOpenApi: boolean = true');
+      // But the OpenAPI options are configured dynamically based on the parameter
+      expect(endpointsContent).toContain('docsPath: false');
+    },
+  );
+
+  itWithDir(
+    'should generate individual handlers in routes subdirectory',
+    async ({ dir }) => {
+      const outputDir = join(dir, 'output');
+      const routesDir = join(dir, 'routes');
+      await mkdir(outputDir, { recursive: true });
+
+      await Promise.all([
+        createMockEndpointFile(
+          routesDir,
+          'testEndpoint.ts',
+          'testEndpoint',
+          '/test',
+          'GET',
+        ),
+        createMockEndpointFile(
+          routesDir,
+          'anotherEndpoint.ts',
+          'anotherEndpoint',
+          '/another',
+          'POST',
+        ),
+      ]);
+
+      const constructs = await generator.load('**/routes/*.ts', dir);
+
+      const routes = await generator.build(context, constructs, outputDir, {
+        provider: 'aws-lambda',
+      });
+
+      expect(routes).toHaveLength(2);
+
+      // Find routes by their path since order may vary
+      const testRoute = routes.find((r) => r.path === '/test');
+      const anotherRoute = routes.find((r) => r.path === '/another');
+
+      expect(testRoute).toMatchObject({
+        path: '/test',
+        method: 'GET',
+        handler: expect.stringContaining('routes/testEndpoint.handler'),
+      });
+      expect(anotherRoute).toMatchObject({
+        path: '/another',
+        method: 'POST',
+        handler: expect.stringContaining('routes/anotherEndpoint.handler'),
+      });
+
+      // Check that handler files were created
+      const testHandlerPath = join(outputDir, 'routes', 'testEndpoint.ts');
+      const testHandlerContent = await readFile(testHandlerPath, 'utf-8');
+      expect(testHandlerContent).toContain('AmazonApiGatewayV2Endpoint');
+      expect(testHandlerContent).toContain('import { testEndpoint }');
+
+      const anotherHandlerPath = join(
+        outputDir,
+        'routes',
+        'anotherEndpoint.ts',
+      );
+      const anotherHandlerContent = await readFile(anotherHandlerPath, 'utf-8');
+      expect(anotherHandlerContent).toContain('AmazonApiGatewayV2Endpoint');
+      expect(anotherHandlerContent).toContain('import { anotherEndpoint }');
+    },
+  );
+
+  itWithDir(
+    'should generate individual handlers with v1 adapter',
+    async ({ dir }) => {
+      const outputDir = join(dir, 'output');
+      const routesDir = join(dir, 'routes');
+      await mkdir(outputDir, { recursive: true });
+
+      await createMockEndpointFile(
+        routesDir,
+        'testEndpoint.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      const constructs = await generator.load('**/routes/*.ts', dir);
+
+      const routes = await generator.build(context, constructs, outputDir, {
+        provider: 'aws-apigatewayv1',
+      });
+
+      expect(routes).toHaveLength(1);
+
+      const handlerPath = join(outputDir, 'testEndpoint.ts');
+      const handlerContent = await readFile(handlerPath, 'utf-8');
+      expect(handlerContent).toContain('AmazonApiGatewayV1Endpoint');
+      expect(handlerContent).toContain('import { testEndpoint }');
+    },
+  );
+
+  itWithDir(
+    'should generate individual handlers with v2 adapter',
+    async ({ dir }) => {
+      const outputDir = join(dir, 'output');
+      const routesDir = join(dir, 'routes');
+      await mkdir(outputDir, { recursive: true });
+
+      await createMockEndpointFile(
+        routesDir,
+        'testEndpoint.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      const constructs = await generator.load('**/routes/*.ts', dir);
+
+      const routes = await generator.build(context, constructs, outputDir, {
+        provider: 'aws-apigatewayv2',
+      });
+
+      expect(routes).toHaveLength(1);
+
+      const handlerPath = join(outputDir, 'testEndpoint.ts');
+      const handlerContent = await readFile(handlerPath, 'utf-8');
+      expect(handlerContent).toContain('AmazonApiGatewayV2Endpoint');
+      expect(handlerContent).toContain('import { testEndpoint }');
+    },
+  );
+
+  itWithDir(
+    'should return empty array for empty constructs',
+    async ({ dir }) => {
+      const outputDir = join(dir, 'output');
+      const routes = await generator.build(context, [], outputDir);
+      expect(routes).toEqual([]);
+    },
+  );
+
+  itWithDir(
+    'should use default provider when none specified',
+    async ({ dir }) => {
+      const outputDir = join(dir, 'output');
+      const routesDir = join(dir, 'routes');
+      await mkdir(outputDir, { recursive: true });
+
+      await createMockEndpointFile(
+        routesDir,
+        'testEndpoint.ts',
+        'testEndpoint',
+        '/test',
+        'GET',
+      );
+
+      const constructs = await generator.load('**/routes/*.ts', dir);
+
+      const routes = await generator.build(context, constructs, outputDir);
+
+      expect(routes).toHaveLength(1);
+
+      // Should use default aws-apigatewayv2
+      const handlerPath = join(outputDir, 'testEndpoint.ts');
+      const handlerContent = await readFile(handlerPath, 'utf-8');
+      expect(handlerContent).toContain('AmazonApiGatewayV2Endpoint');
+    },
+  );
+
+  itWithDir('should throw error for unsupported provider', async ({ dir }) => {
+    const outputDir = join(dir, 'output');
+    const constructs = [
+      createTestEndpointConstruct('testEndpoint', '/test', 'GET', dir),
+    ];
+
+    await expect(
+      generator.build(context, constructs, outputDir, {
+        provider: 'unsupported' as any,
+      }),
+    ).rejects.toThrow('Unsupported provider: unsupported');
+  });
+
+  itWithDir(
+    'should generate correct import paths for nested files',
+    async ({ dir }) => {
+      const outputDir = join(dir, 'output');
+      const nestedDir = join(dir, 'src', 'api', 'endpoints');
+      await mkdir(outputDir, { recursive: true });
+
+      await createMockEndpointFile(
+        nestedDir,
+        'deepEndpoint.ts',
+        'deepEndpoint',
+        '/deep',
+        'GET',
+      );
+
+      const constructs = await generator.load('**/src/api/endpoints/*.ts', dir);
+
+      await generator.build(context, constructs, outputDir, {
+        provider: 'aws-apigatewayv2',
+      });
+
+      const handlerPath = join(outputDir, 'deepEndpoint.ts');
+      const handlerContent = await readFile(handlerPath, 'utf-8');
+
+      // Check that relative imports are correct
+      expect(handlerContent).toContain(
+        "from '../src/api/endpoints/deepEndpoint.js'",
+      );
+      expect(handlerContent).toMatch(/from ['"]\.\.\/\.\.\/\.\.\/.*\/env['"]/);
+    },
+  );
+
+  itWithDir('should log generation progress', async ({ dir }) => {
+    const logSpy = vi.spyOn(console, 'log');
+    const outputDir = join(dir, 'output');
+    const routesDir = join(dir, 'routes');
+    await mkdir(outputDir, { recursive: true });
+
+    await Promise.all([
+      createMockEndpointFile(
+        routesDir,
+        'endpoint1.ts',
+        'endpoint1',
+        '/test1',
+        'GET',
+      ),
+      createMockEndpointFile(
+        routesDir,
+        'endpoint2.ts',
+        'endpoint2',
+        '/test2',
+        'POST',
+      ),
+    ]);
+
+    const constructs = await generator.load('**/routes/*.ts', dir);
+
+    await generator.build(context, constructs, outputDir, {
+      provider: 'server',
+    });
+
+    expect(logSpy).toHaveBeenCalledWith('Generated server with 2 endpoints');
+
+    logSpy.mockRestore();
+  });
+});

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

@@ -0,0 +1,256 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { f } from '@geekmidas/constructs/functions';
+import type { Function } from '@geekmidas/constructs/functions';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { z } from 'zod';
+import {
+  cleanupDir,
+  createMockBuildContext,
+  createTempDir,
+} from '../../__tests__/test-helpers';
+import { FunctionGenerator } from '../FunctionGenerator';
+import type { GeneratedConstruct } from '../Generator';
+
+describe('FunctionGenerator', () => {
+  let tempDir: string;
+  let outputDir: string;
+  let generator: FunctionGenerator;
+  let context: ReturnType<typeof createMockBuildContext>;
+
+  beforeEach(async () => {
+    tempDir = await createTempDir();
+    outputDir = join(tempDir, 'output');
+    generator = new FunctionGenerator();
+    context = createMockBuildContext();
+  });
+
+  afterEach(async () => {
+    await cleanupDir(tempDir);
+  });
+
+  describe('isConstruct', () => {
+    it('should identify valid functions', () => {
+      const testFunction = f
+        .input(z.object({ name: z.string() }))
+        .output(z.object({ greeting: z.string() }))
+        .timeout(30)
+        .handle(async ({ input }) => ({
+          greeting: `Hello, ${input.name}!`,
+        }));
+
+      expect(generator.isConstruct(testFunction)).toBe(true);
+    });
+
+    it('should reject invalid constructs', () => {
+      expect(generator.isConstruct({})).toBe(false);
+      expect(generator.isConstruct('string')).toBe(false);
+      expect(generator.isConstruct(null)).toBe(false);
+    });
+  });
+
+  describe('build', () => {
+    const createTestFunctionConstruct = (
+      key: string,
+      timeout: number = 30,
+    ): GeneratedConstruct<Function<any, any, any, any>> => {
+      const func = f
+        .timeout(timeout)
+        .handle(async () => ({ greeting: 'Hello!' }));
+
+      return {
+        key,
+        name: key.toLowerCase(),
+        construct: func,
+        path: {
+          absolute: join(tempDir, `${key}.ts`),
+          relative: `${key}.ts`,
+        },
+      };
+    };
+
+    describe('aws-lambda provider', () => {
+      it('should generate function handlers', async () => {
+        const constructs = [
+          createTestFunctionConstruct('processData', 60),
+          createTestFunctionConstruct('sendEmail', 30),
+        ];
+
+        const functionInfos = await generator.build(
+          context,
+          constructs,
+          outputDir,
+          { provider: 'aws-lambda' },
+        );
+
+        expect(functionInfos).toHaveLength(2);
+        expect(functionInfos[0]).toMatchObject({
+          name: 'processData',
+          handler: expect.stringContaining('functions/processData.handler'),
+          timeout: 60,
+        });
+        expect(functionInfos[1]).toMatchObject({
+          name: 'sendEmail',
+          handler: expect.stringContaining('functions/sendEmail.handler'),
+          timeout: 30,
+        });
+
+        // Check that handler files were created
+        const processDataHandlerPath = join(
+          outputDir,
+          'functions',
+          'processData.ts',
+        );
+        const processDataContent = await readFile(
+          processDataHandlerPath,
+          'utf-8',
+        );
+        expect(processDataContent).toContain('AWSLambdaFunction');
+        expect(processDataContent).toContain('import { processData }');
+        expect(processDataContent).toContain('import envParser');
+        expect(processDataContent).toContain('import logger');
+
+        const sendEmailHandlerPath = join(
+          outputDir,
+          'functions',
+          'sendEmail.ts',
+        );
+        const sendEmailContent = await readFile(sendEmailHandlerPath, 'utf-8');
+        expect(sendEmailContent).toContain('AWSLambdaFunction');
+        expect(sendEmailContent).toContain('import { sendEmail }');
+      });
+
+      it('should generate correct relative import paths', async () => {
+        const construct: GeneratedConstruct<Function<any, any, any, any>> = {
+          key: 'deepFunction',
+          name: 'deep-function',
+          construct: createTestFunctionConstruct('deepFunction', 45).construct,
+          path: {
+            absolute: join(tempDir, 'src/functions/deep/processor.ts'),
+            relative: 'src/functions/deep/processor.ts',
+          },
+        };
+
+        await generator.build(context, [construct], outputDir, {
+          provider: 'aws-lambda',
+        });
+
+        const handlerPath = join(outputDir, 'functions', 'deepFunction.ts');
+        const handlerContent = await readFile(handlerPath, 'utf-8');
+
+        // Check relative imports are correct - the path will be relative from outputDir
+        expect(handlerContent).toMatch(
+          /from ['"].*src\/functions\/deep\/processor\.js['"]/,
+        );
+        expect(handlerContent).toMatch(/from ['"].*\/env['"]/);
+        expect(handlerContent).toMatch(/from ['"].*\/logger['"]/);
+      });
+
+      it('should log generation progress', async () => {
+        const logSpy = vi.spyOn(console, 'log');
+
+        const constructs = [createTestFunctionConstruct('testFunction', 30)];
+
+        await generator.build(context, constructs, outputDir, {
+          provider: 'aws-lambda',
+        });
+
+        expect(logSpy).toHaveBeenCalledWith(
+          'Generated function handler: testFunction',
+        );
+
+        logSpy.mockRestore();
+      });
+    });
+
+    describe('non aws-lambda provider', () => {
+      it('should return empty array for server provider', async () => {
+        const constructs = [createTestFunctionConstruct('testFunction', 30)];
+
+        const functionInfos = await generator.build(
+          context,
+          constructs,
+          outputDir,
+          { provider: 'server' },
+        );
+
+        expect(functionInfos).toEqual([]);
+      });
+
+      it('should return empty array for aws-apigatewayv1 provider', async () => {
+        const constructs = [createTestFunctionConstruct('testFunction', 30)];
+
+        const functionInfos = await generator.build(
+          context,
+          constructs,
+          outputDir,
+          { provider: 'aws-apigatewayv1' },
+        );
+
+        expect(functionInfos).toEqual([]);
+      });
+    });
+
+    it('should return empty array for empty constructs', async () => {
+      const functionInfos = await generator.build(context, [], outputDir, {
+        provider: 'aws-lambda',
+      });
+      expect(functionInfos).toEqual([]);
+    });
+
+    it('should use default provider when none specified', async () => {
+      const constructs = [createTestFunctionConstruct('defaultFunction', 30)];
+
+      const functionInfos = await generator.build(
+        context,
+        constructs,
+        outputDir,
+      );
+
+      expect(functionInfos).toHaveLength(1);
+      expect(functionInfos[0].name).toBe('defaultFunction');
+
+      // Check that handler was created (default is aws-lambda)
+      const handlerPath = join(outputDir, 'functions', 'defaultFunction.ts');
+      const handlerContent = await readFile(handlerPath, 'utf-8');
+      expect(handlerContent).toContain('AWSLambdaFunction');
+    });
+
+    it('should handle functions with different timeout values', async () => {
+      const constructs = [
+        createTestFunctionConstruct('quickFunction', 15),
+        createTestFunctionConstruct('slowFunction', 300),
+      ];
+
+      const functionInfos = await generator.build(
+        context,
+        constructs,
+        outputDir,
+        { provider: 'aws-lambda' },
+      );
+
+      expect(functionInfos[0].timeout).toBe(15);
+      expect(functionInfos[1].timeout).toBe(300);
+    });
+
+    it('should handle functions with custom environment parser patterns', async () => {
+      const customContext = {
+        ...context,
+        envParserImportPattern: '{ customParser as envParser }',
+        loggerImportPattern: '{ customLogger as logger }',
+      };
+
+      const constructs = [createTestFunctionConstruct('customFunction', 30)];
+
+      await generator.build(customContext, constructs, outputDir, {
+        provider: 'aws-lambda',
+      });
+
+      const handlerPath = join(outputDir, 'functions', 'customFunction.ts');
+      const handlerContent = await readFile(handlerPath, 'utf-8');
+
+      expect(handlerContent).toContain('import { customParser as envParser }');
+      expect(handlerContent).toContain('import { customLogger as logger }');
+    });
+  });
+});