@geekmidas/cli 0.0.26 → 0.1.0

package/src/__tests__/config.spec.ts

@@ -0,0 +1,110 @@
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { loadConfig } from '../config';
+import { cleanupDir, createTempDir } from './test-helpers';
+
+describe('loadConfig', () => {
+  let tempDir: string;
+  let originalCwd: string;
+
+  beforeEach(async () => {
+    tempDir = await createTempDir();
+    originalCwd = process.cwd();
+    process.chdir(tempDir);
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await cleanupDir(tempDir);
+  });
+
+  it('should load configuration from gkm.config.ts', async () => {
+    const configContent = `
+export default {
+  routes: './src/endpoints/**/*.ts',
+  functions: './src/functions/**/*.ts',
+  crons: './src/crons/**/*.ts',
+  envParser: './src/config/env',
+  logger: './src/config/logger',
+};
+`;
+    await writeFile(join(tempDir, 'gkm.config.ts'), configContent);
+
+    const config = await loadConfig();
+
+    expect(config).toEqual({
+      routes: './src/endpoints/**/*.ts',
+      functions: './src/functions/**/*.ts',
+      crons: './src/crons/**/*.ts',
+      envParser: './src/config/env',
+      logger: './src/config/logger',
+    });
+  });
+
+  it('should load configuration from gkm.config.js', async () => {
+    const configContent = `
+module.exports = {
+  routes: './api/**/*.js',
+  envParser: './config/environment',
+  logger: './config/logging',
+};
+`;
+    await writeFile(join(tempDir, 'gkm.config.js'), configContent);
+
+    const config = await loadConfig();
+
+    expect(config.routes).toBe('./api/**/*.js');
+    expect(config.envParser).toBe('./config/environment');
+    expect(config.logger).toBe('./config/logging');
+  });
+
+  it('should handle configuration with only envParser override', async () => {
+    const configContent = `
+export default {
+  envParser: './my-env#myEnvParser',
+  logger: './my-logger#myLogger',
+};
+`;
+    await writeFile(join(tempDir, 'gkm.config.ts'), configContent);
+
+    const config = await loadConfig();
+
+    expect(config.envParser).toBe('./my-env#myEnvParser');
+    expect(config.logger).toBe('./my-logger#myLogger');
+  });
+
+  it('should handle malformed config file gracefully', async () => {
+    const invalidConfigContent = `
+export default {
+  routes: './endpoints/**/*.ts'
+  // Missing comma - syntax error
+  functions: './functions/**/*.ts'
+};
+`;
+    await writeFile(join(tempDir, 'gkm.config.ts'), invalidConfigContent);
+
+    // Should fall back to defaults when config file has syntax errors
+    await expect(loadConfig()).rejects.toThrow();
+  });
+
+  it('should prefer .ts config over .js config', async () => {
+    const jsConfigContent = `
+module.exports = {
+  routes: './js-routes/**/*.js',
+};
+`;
+    const tsConfigContent = `
+export default {
+  routes: './ts-routes/**/*.ts',
+};
+`;
+
+    await writeFile(join(tempDir, 'gkm.config.js'), jsConfigContent);
+    await writeFile(join(tempDir, 'gkm.config.ts'), tsConfigContent);
+
+    const config = await loadConfig();
+
+    expect(config.routes).toBe('./ts-routes/**/*.ts');
+  });
+});

package/src/__tests__/test-helpers.ts

@@ -0,0 +1,178 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+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';
+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/api/server';
+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 { FunctionBuilder } from '@geekmidas/api/constructs';
+import { z } from 'zod';
+
+export const ${exportName} = new FunctionBuilder()
+  .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/api/constructs';
+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 type { HttpMethod } from '../../../api/src/constructs/types';