@geekmidas/cli 0.2.2 → 0.2.4

package/src/dev/__tests__/index.spec.ts

@@ -0,0 +1,208 @@
+import { createServer } from 'node:net';
+import { describe, expect, it } from 'vitest';
+import { findAvailablePort, isPortAvailable } from '../index';
+
+/**
+ * Helper to occupy a port for testing
+ */
+function occupyPort(port: number): Promise<ReturnType<typeof createServer>> {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+
+    server.once('error', (err) => {
+      reject(err);
+    });
+
+    server.once('listening', () => {
+      resolve(server);
+    });
+
+    server.listen(port);
+  });
+}
+
+describe('Port Availability Functions', () => {
+  describe('isPortAvailable', () => {
+    it('should return true for an available port', async () => {
+      // Use a high port number to avoid conflicts
+      const port = 45000;
+      const available = await isPortAvailable(port);
+      expect(available).toBe(true);
+    });
+
+    it('should return false for a port in use', async () => {
+      const port = 45001;
+      const server = await occupyPort(port);
+
+      try {
+        const available = await isPortAvailable(port);
+        expect(available).toBe(false);
+      } finally {
+        server.close();
+      }
+    });
+
+    it('should handle multiple sequential checks correctly', async () => {
+      const port = 45002;
+
+      // First check - port should be available
+      const firstCheck = await isPortAvailable(port);
+      expect(firstCheck).toBe(true);
+
+      // Occupy the port
+      const server = await occupyPort(port);
+
+      try {
+        // Second check - port should be unavailable
+        const secondCheck = await isPortAvailable(port);
+        expect(secondCheck).toBe(false);
+      } finally {
+        server.close();
+      }
+
+      // Give a moment for the port to be released
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      // Third check - port should be available again
+      const thirdCheck = await isPortAvailable(port);
+      expect(thirdCheck).toBe(true);
+    });
+  });
+
+  describe('findAvailablePort', () => {
+    it('should return the preferred port if available', async () => {
+      const preferredPort = 45100;
+      const foundPort = await findAvailablePort(preferredPort);
+      expect(foundPort).toBe(preferredPort);
+    });
+
+    it('should return the next available port if preferred is in use', async () => {
+      const preferredPort = 45101;
+      const server = await occupyPort(preferredPort);
+
+      try {
+        const foundPort = await findAvailablePort(preferredPort);
+        expect(foundPort).toBe(preferredPort + 1);
+      } finally {
+        server.close();
+      }
+    });
+
+    it('should skip multiple occupied ports', async () => {
+      const preferredPort = 45102;
+      const server1 = await occupyPort(preferredPort);
+      const server2 = await occupyPort(preferredPort + 1);
+      const server3 = await occupyPort(preferredPort + 2);
+
+      try {
+        const foundPort = await findAvailablePort(preferredPort);
+        expect(foundPort).toBe(preferredPort + 3);
+      } finally {
+        server1.close();
+        server2.close();
+        server3.close();
+      }
+    });
+
+    it('should throw error if no available port found within max attempts', async () => {
+      const preferredPort = 45103;
+      const maxAttempts = 3;
+
+      // Occupy ports 45103, 45104, 45105
+      const servers = await Promise.all([
+        occupyPort(preferredPort),
+        occupyPort(preferredPort + 1),
+        occupyPort(preferredPort + 2),
+      ]);
+
+      try {
+        await expect(
+          findAvailablePort(preferredPort, maxAttempts),
+        ).rejects.toThrow(
+          `Could not find an available port after trying ${maxAttempts} ports starting from ${preferredPort}`,
+        );
+      } finally {
+        servers.forEach((server) => server.close());
+      }
+    });
+
+    it('should respect custom maxAttempts parameter', async () => {
+      const preferredPort = 45104;
+      const maxAttempts = 5;
+
+      // Occupy first 4 ports
+      const servers = await Promise.all([
+        occupyPort(preferredPort),
+        occupyPort(preferredPort + 1),
+        occupyPort(preferredPort + 2),
+        occupyPort(preferredPort + 3),
+      ]);
+
+      try {
+        const foundPort = await findAvailablePort(preferredPort, maxAttempts);
+        // Should find port at preferredPort + 4 (within 5 attempts)
+        expect(foundPort).toBe(preferredPort + 4);
+      } finally {
+        servers.forEach((server) => server.close());
+      }
+    });
+  });
+});
+
+describe('DevServer', () => {
+  describe('port selection', () => {
+    it('should use requested port when available', async () => {
+      // This is more of an integration test that would need the actual DevServer
+      // For now, we test the underlying logic
+      const requestedPort = 45200;
+      const actualPort = await findAvailablePort(requestedPort);
+      expect(actualPort).toBe(requestedPort);
+    });
+
+    it('should select alternative port when requested is in use', async () => {
+      const requestedPort = 45201;
+      const server = await occupyPort(requestedPort);
+
+      try {
+        const actualPort = await findAvailablePort(requestedPort);
+        expect(actualPort).not.toBe(requestedPort);
+        expect(actualPort).toBeGreaterThan(requestedPort);
+        expect(actualPort).toBeLessThanOrEqual(requestedPort + 10);
+      } finally {
+        server.close();
+      }
+    });
+  });
+});
+
+describe('devCommand edge cases', () => {
+  it('should handle port conflicts gracefully', async () => {
+    const port = 45300;
+    const server = await occupyPort(port);
+
+    try {
+      // The dev command should find an alternative port
+      const alternativePort = await findAvailablePort(port);
+      expect(alternativePort).toBeGreaterThan(port);
+    } finally {
+      server.close();
+    }
+  });
+
+  it('should handle concurrent port checks', async () => {
+    const basePort = 45400;
+
+    // Run multiple port checks concurrently
+    const results = await Promise.all([
+      findAvailablePort(basePort),
+      findAvailablePort(basePort + 5),
+      findAvailablePort(basePort + 10),
+    ]);
+
+    // All should succeed and return valid ports
+    expect(results).toHaveLength(3);
+    results.forEach((port) => {
+      expect(port).toBeGreaterThanOrEqual(basePort);
+    });
+  });
+});

package/src/dev/index.ts

@@ -0,0 +1,377 @@
+import { type ChildProcess, spawn } from 'node:child_process';
+import { mkdir } from 'node:fs/promises';
+import { createServer } from 'node:net';
+import { join } from 'node:path';
+import chokidar from 'chokidar';
+import { resolveProviders } from '../build/providerResolver';
+import type { BuildContext } from '../build/types';
+import { loadConfig } from '../config';
+import {
+  CronGenerator,
+  EndpointGenerator,
+  FunctionGenerator,
+  SubscriberGenerator,
+} from '../generators';
+import type { LegacyProvider } from '../types';
+
+const logger = console;
+
+/**
+ * Check if a port is available
+ * @internal Exported for testing
+ */
+export async function isPortAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = createServer();
+
+    server.once('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE') {
+        resolve(false);
+      } else {
+        resolve(false);
+      }
+    });
+
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+
+    server.listen(port);
+  });
+}
+
+/**
+ * Find an available port starting from the preferred port
+ * @internal Exported for testing
+ */
+export async function findAvailablePort(
+  preferredPort: number,
+  maxAttempts = 10,
+): Promise<number> {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = preferredPort + i;
+    if (await isPortAvailable(port)) {
+      return port;
+    }
+    logger.log(`⚠️  Port ${port} is in use, trying ${port + 1}...`);
+  }
+
+  throw new Error(
+    `Could not find an available port after trying ${maxAttempts} ports starting from ${preferredPort}`,
+  );
+}
+
+export interface DevOptions {
+  port?: number;
+  enableOpenApi?: boolean;
+}
+
+export async function devCommand(options: DevOptions): Promise<void> {
+  const config = await loadConfig();
+
+  // Force server provider for dev mode
+  const resolved = resolveProviders(config, { provider: 'server' });
+
+  logger.log('🚀 Starting development server...');
+  logger.log(`Loading routes from: ${config.routes}`);
+  if (config.functions) {
+    logger.log(`Loading functions from: ${config.functions}`);
+  }
+  if (config.crons) {
+    logger.log(`Loading crons from: ${config.crons}`);
+  }
+  if (config.subscribers) {
+    logger.log(`Loading subscribers from: ${config.subscribers}`);
+  }
+  logger.log(`Using envParser: ${config.envParser}`);
+
+  // Parse envParser configuration
+  const [envParserPath, envParserName] = config.envParser.split('#');
+  const envParserImportPattern = !envParserName
+    ? 'envParser'
+    : envParserName === 'envParser'
+      ? '{ envParser }'
+      : `{ ${envParserName} as envParser }`;
+
+  // Parse logger configuration
+  const [loggerPath, loggerName] = config.logger.split('#');
+  const loggerImportPattern = !loggerName
+    ? 'logger'
+    : loggerName === 'logger'
+      ? '{ logger }'
+      : `{ ${loggerName} as logger }`;
+
+  const buildContext: BuildContext = {
+    envParserPath,
+    envParserImportPattern,
+    loggerPath,
+    loggerImportPattern,
+  };
+
+  // Build initial version
+  await buildServer(
+    config,
+    buildContext,
+    resolved.providers[0] as LegacyProvider,
+    resolved.enableOpenApi,
+  );
+
+  // Start the dev server
+  const devServer = new DevServer(
+    resolved.providers[0] as LegacyProvider,
+    options.port || 3000,
+    resolved.enableOpenApi,
+  );
+
+  await devServer.start();
+
+  // Watch for file changes
+  const watchPatterns = [
+    config.routes,
+    ...(config.functions ? [config.functions] : []),
+    ...(config.crons ? [config.crons] : []),
+    ...(config.subscribers ? [config.subscribers] : []),
+    config.envParser.split('#')[0],
+    config.logger.split('#')[0],
+  ].flat();
+
+  logger.log(`👀 Watching for changes in: ${watchPatterns.join(', ')}`);
+
+  const watcher = chokidar.watch(watchPatterns, {
+    ignored: /(^|[\/\\])\../, // ignore dotfiles
+    persistent: true,
+    ignoreInitial: true,
+  });
+
+  let rebuildTimeout: NodeJS.Timeout | null = null;
+
+  watcher.on('change', async (path) => {
+    logger.log(`📝 File changed: ${path}`);
+
+    // Debounce rebuilds
+    if (rebuildTimeout) {
+      clearTimeout(rebuildTimeout);
+    }
+
+    rebuildTimeout = setTimeout(async () => {
+      try {
+        logger.log('🔄 Rebuilding...');
+        await buildServer(
+          config,
+          buildContext,
+          resolved.providers[0] as LegacyProvider,
+          resolved.enableOpenApi,
+        );
+        logger.log('✅ Rebuild complete, restarting server...');
+        await devServer.restart();
+      } catch (error) {
+        logger.error('❌ Rebuild failed:', (error as Error).message);
+      }
+    }, 300);
+  });
+
+  // Handle graceful shutdown
+  const shutdown = async () => {
+    logger.log('\n🛑 Shutting down...');
+    await watcher.close();
+    await devServer.stop();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+async function buildServer(
+  config: any,
+  context: BuildContext,
+  provider: LegacyProvider,
+  enableOpenApi: boolean,
+): Promise<void> {
+  // Initialize generators
+  const endpointGenerator = new EndpointGenerator();
+  const functionGenerator = new FunctionGenerator();
+  const cronGenerator = new CronGenerator();
+  const subscriberGenerator = new SubscriberGenerator();
+
+  // Load all constructs
+  const [allEndpoints, allFunctions, allCrons, allSubscribers] =
+    await Promise.all([
+      endpointGenerator.load(config.routes),
+      config.functions ? functionGenerator.load(config.functions) : [],
+      config.crons ? cronGenerator.load(config.crons) : [],
+      config.subscribers ? subscriberGenerator.load(config.subscribers) : [],
+    ]);
+
+  // Ensure .gkm directory exists
+  const outputDir = join(process.cwd(), '.gkm', provider);
+  await mkdir(outputDir, { recursive: true });
+
+  // Build for server provider
+  await Promise.all([
+    endpointGenerator.build(context, allEndpoints, outputDir, {
+      provider,
+      enableOpenApi,
+    }),
+    functionGenerator.build(context, allFunctions, outputDir, { provider }),
+    cronGenerator.build(context, allCrons, outputDir, { provider }),
+    subscriberGenerator.build(context, allSubscribers, outputDir, { provider }),
+  ]);
+}
+
+class DevServer {
+  private serverProcess: ChildProcess | null = null;
+  private isRunning = false;
+  private actualPort: number;
+
+  constructor(
+    private provider: LegacyProvider,
+    private requestedPort: number,
+    private enableOpenApi: boolean,
+  ) {
+    this.actualPort = requestedPort;
+  }
+
+  async start(): Promise<void> {
+    if (this.isRunning) {
+      await this.stop();
+    }
+
+    // Find an available port
+    this.actualPort = await findAvailablePort(this.requestedPort);
+
+    if (this.actualPort !== this.requestedPort) {
+      logger.log(
+        `ℹ️  Port ${this.requestedPort} was in use, using port ${this.actualPort} instead`,
+      );
+    }
+
+    const serverEntryPath = join(
+      process.cwd(),
+      '.gkm',
+      this.provider,
+      'server.ts',
+    );
+
+    // Create server entry file
+    await this.createServerEntry();
+
+    logger.log(`\n✨ Starting server on port ${this.actualPort}...`);
+
+    // Start the server using tsx (TypeScript execution)
+    this.serverProcess = spawn(
+      'npx',
+      ['tsx', serverEntryPath, '--port', this.actualPort.toString()],
+      {
+        stdio: 'inherit',
+        env: { ...process.env, NODE_ENV: 'development' },
+      },
+    );
+
+    this.isRunning = true;
+
+    this.serverProcess.on('error', (error) => {
+      logger.error('❌ Server error:', error);
+    });
+
+    this.serverProcess.on('exit', (code, signal) => {
+      if (code !== null && code !== 0 && signal !== 'SIGTERM') {
+        logger.error(`❌ Server exited with code ${code}`);
+      }
+      this.isRunning = false;
+    });
+
+    // Give the server a moment to start
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    if (this.isRunning) {
+      logger.log(`\n🎉 Server running at http://localhost:${this.actualPort}`);
+      if (this.enableOpenApi) {
+        logger.log(
+          `📚 API Docs available at http://localhost:${this.actualPort}/docs`,
+        );
+      }
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (this.serverProcess && this.isRunning) {
+      this.serverProcess.kill('SIGTERM');
+
+      // Wait for process to exit
+      await new Promise<void>((resolve) => {
+        const timeout = setTimeout(() => {
+          this.serverProcess?.kill('SIGKILL');
+          resolve();
+        }, 5000);
+
+        this.serverProcess?.on('exit', () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+      });
+
+      this.serverProcess = null;
+      this.isRunning = false;
+    }
+  }
+
+  async restart(): Promise<void> {
+    await this.stop();
+    await this.start();
+  }
+
+  private async createServerEntry(): Promise<void> {
+    const { writeFile } = await import('node:fs/promises');
+    const { relative, dirname } = await import('node:path');
+
+    const serverPath = join(process.cwd(), '.gkm', this.provider, 'server.ts');
+
+    const relativeAppPath = relative(
+      dirname(serverPath),
+      join(dirname(serverPath), 'app.js'),
+    );
+
+    const content = `#!/usr/bin/env node
+/**
+ * Development server entry point
+ * This file is auto-generated by 'gkm dev'
+ */
+import { createApp } from './${relativeAppPath.startsWith('.') ? relativeAppPath : './' + relativeAppPath}';
+
+const port = process.argv.includes('--port')
+  ? Number.parseInt(process.argv[process.argv.indexOf('--port') + 1])
+  : 3000;
+
+const { app, start } = createApp(undefined, ${this.enableOpenApi});
+
+// Start the server
+start({
+  port,
+  serve: async (app, port) => {
+    // Detect runtime and use appropriate server
+    if (typeof Bun !== 'undefined') {
+      // Bun runtime
+      Bun.serve({
+        port,
+        fetch: app.fetch,
+      });
+    } else {
+      // Node.js runtime with @hono/node-server
+      const { serve } = await import('@hono/node-server');
+      serve({
+        fetch: app.fetch,
+        port,
+      });
+    }
+  },
+}).catch((error) => {
+  console.error('Failed to start server:', error);
+  process.exit(1);
+});
+`;
+
+    await writeFile(serverPath, content);
+  }
+}

package/src/generators/CronGenerator.ts

@@ -10,12 +10,14 @@ import {
 } from './Generator';
 
 export class CronGenerator extends ConstructGenerator<
-  Cron<any, any, any, any>,
+  Cron<any, any, any, any, any, any, any, any>,
   CronInfo[]
 > {
   async build(
     context: BuildContext,
-    constructs: GeneratedConstruct<Cron<any, any, any, any>>[],
+    constructs: GeneratedConstruct<
+      Cron<any, any, any, any, any, any, any, any>
+    >[],
     outputDir: string,
     options?: GeneratorOptions,
   ): Promise<CronInfo[]> {
@@ -48,6 +50,7 @@ export class CronGenerator extends ConstructGenerator<
         ),
         schedule: construct.schedule || 'rate(1 hour)',
         timeout: construct.timeout,
+        memorySize: construct.memorySize,
         environment: await construct.getEnvironment(),
       });
 
@@ -57,7 +60,9 @@ export class CronGenerator extends ConstructGenerator<
     return cronInfos;
   }
 
-  isConstruct(value: any): value is Cron<any, any, any, any> {
+  isConstruct(
+    value: any,
+  ): value is Cron<any, any, any, any, any, any, any, any> {
     return Cron.isCron(value);
   }