@noego/app 0.0.2 → 0.0.4

package/src/commands/dev.js

@@ -0,0 +1,624 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { spawn } from 'node:child_process';
+import { createBuildContext } from '../build/context.js';
+import { findConfigFile } from '../runtime/index.js';
+import { loadConfig } from '../runtime/config-loader.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export async function runDev(config) {
+  const context = createBuildContext(config);
+  const { logger } = context;
+  
+  // Find config file
+  const configFilePath = await findConfigFile(config.rootDir, config.sources?.configFile);
+  const cliRoot = config.sources?.rootDir;
+  
+  // Load config to get dev settings
+  const { config: yamlConfig, root: yamlRoot } = await loadConfig(configFilePath, cliRoot);
+  
+  logger.info(`Loading config from ${path.relative(cliRoot || config.rootDir, configFilePath)}`);
+  
+  // Create requireFromRoot using YAML root (user's project root)
+  const { createRequire } = await import('node:module');
+  const requireFromRoot = createRequire(path.join(yamlRoot, 'package.json'));
+  
+  // Resolve tsx runner
+  let tsxExecutable;
+  let tsxArgs = [];
+  try {
+    // Try to find tsx binary in node_modules/.bin first
+    const fs = await import('node:fs/promises');
+    const tsxBin = path.join(yamlRoot, 'node_modules', '.bin', 'tsx');
+    if (await fs.access(tsxBin).then(() => true).catch(() => false)) {
+      tsxExecutable = tsxBin;
+    } else {
+      // Fallback to resolving tsx package.json to get package root, then find CLI
+      const tsxPackageJson = requireFromRoot.resolve('tsx/package.json');
+      const tsxPackageDir = path.dirname(tsxPackageJson);
+      const cliMjs = path.join(tsxPackageDir, 'dist', 'cli.mjs');
+      const cliJs = path.join(tsxPackageDir, 'dist', 'cli.js');
+      if (await fs.access(cliMjs).then(() => true).catch(() => false)) {
+        tsxExecutable = process.execPath;
+        tsxArgs = [cliMjs];
+      } else if (await fs.access(cliJs).then(() => true).catch(() => false)) {
+        tsxExecutable = process.execPath;
+        tsxArgs = [cliJs];
+      } else {
+        throw new Error('tsx CLI not found');
+      }
+    }
+  } catch (err) {
+    logger.error(`Failed to resolve tsx: ${err.message}`);
+    throw new Error('tsx not found. Please install "tsx" as a dev dependency.');
+  }
+  
+  // If Forge dev loader is available, attach it
+  // For Node.js loaders, we need to resolve the actual file path
+  const fs = await import('node:fs/promises');
+  let forgeLoaderPath;
+  
+  // Try to find loader.mjs directly in node_modules
+  const forgeLoader = path.join(yamlRoot, 'node_modules', '@noego', 'forge', 'loader.mjs');
+  if (await fs.access(forgeLoader).then(() => true).catch(() => false)) {
+    forgeLoaderPath = forgeLoader;
+  } else {
+    // Try to find @noego/forge package and look for loader.mjs
+    try {
+      const forgePackageDir = path.dirname(requireFromRoot.resolve('@noego/forge'));
+      const loaderMjs = path.join(forgePackageDir, 'loader.mjs');
+      if (await fs.access(loaderMjs).then(() => true).catch(() => false)) {
+        forgeLoaderPath = loaderMjs;
+      }
+    } catch {
+      // Package not found or not accessible
+    }
+  }
+  
+  if (forgeLoaderPath) {
+    tsxArgs.push('--loader', forgeLoaderPath);
+    logger.info(`Using @noego/forge/loader for Svelte file support: ${forgeLoaderPath}`);
+  } else {
+    // Fallback to package name resolution (tsx will resolve it)
+    tsxArgs.push('--loader', '@noego/forge/loader');
+    logger.info('Using @noego/forge/loader for Svelte file support (package name)');
+  }
+  
+  // Runtime entry file (TypeScript)
+  const runtimeEntryPath = path.resolve(__dirname, 'runtime-entry.ts');
+  tsxArgs.push(runtimeEntryPath);
+  
+  // Set environment variables
+  const env = {
+    ...process.env,
+    NODE_ENV: 'development',
+    NOEGO_CONFIG_FILE: configFilePath,
+    NOEGO_CLI_ROOT: cliRoot || config.rootDir
+  };
+
+  // Check if split-serve mode
+  const splitServe = yamlConfig.dev?.splitServe || false;
+  
+  if (splitServe) {
+    // Validate configuration for split-serve
+    if (!yamlConfig.server?.main) {
+      logger.error('splitServe requires server.main to be configured');
+      process.exit(1);
+    }
+    if (!yamlConfig.client?.main) {
+      logger.error('splitServe requires client.main to be configured');
+      process.exit(1);
+    }
+
+    // Split-serve mode: run router in main process, spawn frontend and backend
+    logger.info('Running in split-serve mode with router architecture...');
+
+    // Port assignment: router on main port, frontend on +1, backend on +2
+    const routerPort = yamlConfig.dev?.port || 3000;
+    const frontendPort = routerPort + 1;
+    const backendPort = routerPort + 2;
+
+    if (yamlConfig.dev?.watch) {
+      // With watching: monitor files and restart appropriate process
+      await runSplitServeWithWatch(context, tsxExecutable, tsxArgs, env, yamlConfig, configFilePath, routerPort, frontendPort, backendPort, logger);
+    } else {
+      // Without watching: run router and spawn processes
+      await runSplitServeNoWatch(tsxExecutable, tsxArgs, env, routerPort, frontendPort, backendPort, config.rootDir, logger);
+    }
+  } else if (yamlConfig.dev?.watch) {
+    // Non-split mode with watching
+    const watcher = await createWatcher(context, yamlConfig, configFilePath);
+    await runWithRestart(context, tsxExecutable, tsxArgs, env, watcher, logger);
+  } else {
+    // No watching: run server in background (don't wait for exit)
+    logger.info('Starting dev server...');
+    logger.debug(`Running: ${tsxExecutable} ${tsxArgs.join(' ')}`);
+    const child = spawn(tsxExecutable, tsxArgs, {
+      cwd: config.rootDir,
+      env,
+      stdio: 'inherit',
+      detached: false // Keep attached so signals propagate correctly
+    });
+    
+    // Handle shutdown gracefully
+    const shutdown = () => {
+      if (child && !child.killed) {
+        child.kill('SIGTERM');
+      }
+      process.exit(0);
+    };
+    
+    child.on('exit', (code) => {
+      if (code !== null && code !== 0) {
+        logger.info(`Dev server exited with code ${code}`);
+      }
+      // Only exit if there was an error or explicit exit
+      if (code !== null) {
+        process.exit(code || 0);
+      }
+    });
+    
+    child.on('error', (err) => {
+      logger.error(`Failed to start dev server: ${err.message}`);
+      process.exit(1);
+    });
+    
+    // Set up signal handlers to clean up on termination
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    
+    // Keep process alive - don't return immediately
+    // The process will stay alive as long as child processes are running
+    // Event handlers above will handle cleanup
+  }
+}
+
+/**
+ * Run split-serve without watching: spawn backend and frontend processes
+ */
+async function runSplitServeNoWatch(tsxExecutable, tsxArgs, baseEnv, routerPort, frontendPort, backendPort, rootDir, logger) {
+  logger.info(`Starting router on port ${routerPort}...`);
+  logger.info(`Starting frontend on port ${frontendPort}...`);
+  logger.info(`Starting backend on port ${backendPort}...`);
+
+  console.log('[dev.js] Port assignments:');
+  console.log('  routerPort:', routerPort);
+  console.log('  frontendPort:', frontendPort);
+  console.log('  backendPort:', backendPort);
+  console.log('[dev.js] baseEnv NOEGO_PORT:', baseEnv.NOEGO_PORT);
+  console.log('[dev.js] baseEnv NOEGO_BACKEND_PORT:', baseEnv.NOEGO_BACKEND_PORT);
+
+  // Spawn backend process
+  const backendEnv = {
+    ...baseEnv,
+    NOEGO_SERVICE: 'backend',
+    NOEGO_PORT: String(backendPort)
+  };
+
+  console.log('[dev.js] Backend env NOEGO_PORT:', backendEnv.NOEGO_PORT);
+
+  const backendProc = spawn(tsxExecutable, tsxArgs, {
+    cwd: rootDir,
+    env: backendEnv,
+    stdio: 'inherit',
+    detached: false
+  });
+
+  // Spawn frontend process
+  const frontendEnv = {
+    ...baseEnv,
+    NOEGO_SERVICE: 'frontend',
+    NOEGO_PORT: String(frontendPort),
+    // Frontend doesn't proxy to backend anymore - router handles that
+  };
+
+  console.log('[dev.js] Frontend env NOEGO_PORT:', frontendEnv.NOEGO_PORT);
+
+  const frontendProc = spawn(tsxExecutable, tsxArgs, {
+    cwd: rootDir,
+    env: frontendEnv,
+    stdio: 'inherit',
+    detached: false
+  });
+
+  // Handle shutdown
+  const shutdown = (exitCode = 0) => {
+    logger.info('Shutting down split-serve processes...');
+    if (backendProc && !backendProc.killed) {
+      backendProc.kill('SIGTERM');
+    }
+    if (frontendProc && !frontendProc.killed) {
+      frontendProc.kill('SIGTERM');
+    }
+    process.exit(exitCode);
+  };
+
+  // If either spawned process crashes, kill both and exit
+  backendProc.on('exit', (code) => {
+    if (code !== null && code !== 0) {
+      logger.error(`Backend exited with code ${code}. Shutting down...`);
+      shutdown(code);
+    }
+  });
+
+  frontendProc.on('exit', (code) => {
+    if (code !== null && code !== 0) {
+      logger.error(`Frontend exited with code ${code}. Shutting down...`);
+      shutdown(code);
+    }
+  });
+
+  backendProc.on('error', (err) => {
+    logger.error(`Backend error: ${err.message}. Shutting down...`);
+    shutdown(1);
+  });
+
+  frontendProc.on('error', (err) => {
+    logger.error(`Frontend error: ${err.message}. Shutting down...`);
+    shutdown(1);
+  });
+
+  // Set up signal handlers to clean up on termination
+  process.on('SIGINT', () => shutdown(0));
+  process.on('SIGTERM', () => shutdown(0));
+
+  // Wait a moment for spawned processes to start
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  // Now run the router in the main process
+  // Set environment for router
+  const routerEnv = {
+    ...baseEnv,
+    NOEGO_SERVICE: 'router',
+    NOEGO_PORT: String(routerPort),
+    NOEGO_FRONTEND_PORT: String(frontendPort),
+    NOEGO_BACKEND_PORT: String(backendPort)
+  };
+
+  // Merge router env into process.env
+  Object.assign(process.env, routerEnv);
+
+  // Execute the router runtime in the current process
+  logger.info('Starting router service in main process...');
+  const runtimeEntryPath = tsxArgs[tsxArgs.length - 1];
+  // Use dynamic import instead of require for ES module compatibility
+  await import(runtimeEntryPath);
+}
+
+/**
+ * Run split-serve with watching: spawn backend and frontend processes, restart on file changes
+ */
+async function runSplitServeWithWatch(context, tsxExecutable, tsxArgs, baseEnv, yamlConfig, configFilePath, routerPort, frontendPort, backendPort, logger) {
+  const { createRequire } = await import('node:module');
+  const root = yamlConfig.root || path.dirname(configFilePath);
+  const requireFromRoot = createRequire(path.join(root, 'package.json'));
+  const chokidar = requireFromRoot('chokidar');
+  const picomatch = (await import('picomatch')).default;
+  
+  const resolvePattern = (pattern) => {
+    if (path.isAbsolute(pattern)) return pattern;
+    return path.resolve(root, pattern);
+  };
+  
+  // Collect watch patterns
+  const backendPatterns = [];
+  const frontendPatterns = [];
+  const sharedPatterns = [];
+  
+  // App watch patterns (restart both)
+  if (yamlConfig.app?.watch) {
+    for (const pattern of yamlConfig.app.watch) {
+      sharedPatterns.push(resolvePattern(pattern));
+    }
+  }
+  
+  // Server watch patterns (restart backend only)
+  if (yamlConfig.server?.watch) {
+    for (const pattern of yamlConfig.server.watch) {
+      backendPatterns.push(resolvePattern(pattern));
+    }
+  }
+  
+  // Client watch patterns (restart frontend only)
+  if (yamlConfig.client?.watch) {
+    for (const pattern of yamlConfig.client.watch) {
+      frontendPatterns.push(resolvePattern(pattern));
+    }
+  }
+  
+  // Combine all patterns for chokidar
+  const allPatterns = [...sharedPatterns, ...backendPatterns, ...frontendPatterns];
+  
+  if (allPatterns.length === 0) {
+    logger.warn('No watch patterns configured. Watching disabled.');
+    return await runSplitServeNoWatch(tsxExecutable, tsxArgs, baseEnv, routerPort, frontendPort, backendPort, context.config.rootDir, logger);
+  }
+  
+  logger.info('Watching for changes...');
+  logger.info(`  Shared: ${sharedPatterns.length} patterns`);
+  logger.info(`  Backend: ${backendPatterns.length} patterns`);
+  logger.info(`  Frontend: ${frontendPatterns.length} patterns`);
+  
+  // Create matchers
+  const sharedMatcher = sharedPatterns.length > 0 ? picomatch(sharedPatterns) : null;
+  const backendMatcher = backendPatterns.length > 0 ? picomatch(backendPatterns) : null;
+  const frontendMatcher = frontendPatterns.length > 0 ? picomatch(frontendPatterns) : null;
+  
+  let backendProc = null;
+  let frontendProc = null;
+  let pending = false;
+  
+  const startBackend = () => {
+    logger.info(`Starting backend on port ${backendPort}...`);
+    const backendEnv = {
+      ...baseEnv,
+      NOEGO_SERVICE: 'backend',
+      NOEGO_PORT: String(backendPort)
+    };
+    
+    backendProc = spawn(tsxExecutable, tsxArgs, {
+      cwd: context.config.rootDir,
+      env: backendEnv,
+      stdio: 'inherit',
+      detached: false
+    });
+    
+    backendProc.on('exit', (code) => {
+      if (code !== null && code !== 0) {
+        logger.error(`Backend exited with code ${code}`);
+      }
+    });
+  };
+  
+  const startFrontend = () => {
+    logger.info(`Starting frontend on port ${frontendPort}...`);
+    const frontendEnv = {
+      ...baseEnv,
+      NOEGO_SERVICE: 'frontend',
+      NOEGO_PORT: String(frontendPort)
+    };
+    
+    frontendProc = spawn(tsxExecutable, tsxArgs, {
+      cwd: context.config.rootDir,
+      env: frontendEnv,
+      stdio: 'inherit',
+      detached: false
+    });
+    
+    frontendProc.on('exit', (code) => {
+      if (code !== null && code !== 0) {
+        logger.error(`Frontend exited with code ${code}`);
+      }
+    });
+  };
+  
+  const stopBackend = () =>
+    new Promise((resolve) => {
+      if (!backendProc) return resolve();
+      const to = setTimeout(resolve, 2000);
+      backendProc.once('exit', () => {
+        clearTimeout(to);
+        resolve();
+      });
+      try {
+        backendProc.kill('SIGTERM');
+      } catch {
+        resolve();
+      }
+    });
+  
+  const stopFrontend = () =>
+    new Promise((resolve) => {
+      if (!frontendProc) return resolve();
+      const to = setTimeout(resolve, 2000);
+      frontendProc.once('exit', () => {
+        clearTimeout(to);
+        resolve();
+      });
+      try {
+        frontendProc.kill('SIGTERM');
+      } catch {
+        resolve();
+      }
+    });
+  
+  const handleFileChange = async (reason, file) => {
+    if (pending) return;
+    pending = true;
+    
+    const absPath = path.isAbsolute(file) ? file : path.resolve(root, file);
+    
+    // Determine which service(s) to restart
+    let restartBackend = false;
+    let restartFrontend = false;
+    
+    if (sharedMatcher && sharedMatcher(absPath)) {
+      // Shared file changed - restart both
+      logger.info(`Shared file changed (${reason}): ${file}`);
+      restartBackend = true;
+      restartFrontend = true;
+    } else if (backendMatcher && backendMatcher(absPath)) {
+      // Backend file changed
+      logger.info(`Backend file changed (${reason}): ${file}`);
+      restartBackend = true;
+    } else if (frontendMatcher && frontendMatcher(absPath)) {
+      // Frontend file changed
+      logger.info(`Frontend file changed (${reason}): ${file}`);
+      restartFrontend = true;
+    }
+    
+    // Restart appropriate service(s)
+    if (restartBackend) {
+      await stopBackend();
+      startBackend();
+    }
+    if (restartFrontend) {
+      await stopFrontend();
+      startFrontend();
+    }
+    
+    pending = false;
+  };
+  
+  // Create watcher
+  const watcher = chokidar.watch(allPatterns, {
+    ignoreInitial: true,
+    cwd: root
+  });
+  
+  watcher
+    .on('add', (p) => handleFileChange('add', p))
+    .on('change', (p) => handleFileChange('change', p))
+    .on('unlink', (p) => handleFileChange('unlink', p));
+  
+  // Start initial processes
+  startBackend();
+  startFrontend();
+
+  // Wait a moment for spawned processes to start
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  // Now run the router in the main process
+  const routerEnv = {
+    ...baseEnv,
+    NOEGO_SERVICE: 'router',
+    NOEGO_PORT: String(routerPort),
+    NOEGO_FRONTEND_PORT: String(frontendPort),
+    NOEGO_BACKEND_PORT: String(backendPort)
+  };
+
+  // Merge router env into process.env
+  Object.assign(process.env, routerEnv);
+
+  // Execute the router runtime in the current process
+  logger.info('Starting router service in main process...');
+  const runtimeEntryPath = tsxArgs[tsxArgs.length - 1];
+  // Use dynamic import instead of require for ES module compatibility
+  await import(runtimeEntryPath);
+
+  // Handle shutdown
+  const shutdown = async () => {
+    logger.info('Shutting down split-serve processes...');
+    await stopBackend();
+    await stopFrontend();
+    await watcher.close();
+    process.exit(0);
+  };
+  
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+async function createWatcher(context, yamlConfig, configFilePath) {
+  const { logger } = context;
+  const { createRequire } = await import('node:module');
+  const root = yamlConfig.root || path.dirname(configFilePath);
+  const requireFromRoot = createRequire(path.join(root, 'package.json'));
+  const chokidar = requireFromRoot('chokidar');
+  
+  const patterns = new Set();
+  
+  const resolvePattern = (pattern) => {
+    if (path.isAbsolute(pattern)) return pattern;
+    return path.resolve(root, pattern);
+  };
+  
+  // User-supplied watch paths
+  if (yamlConfig.dev?.watchPaths) {
+    for (const pattern of yamlConfig.dev.watchPaths) {
+      patterns.add(resolvePattern(pattern));
+    }
+  }
+  
+  // Default watch patterns from config
+  if (yamlConfig.server?.controllers) {
+    patterns.add(resolvePattern(`${yamlConfig.server.controllers}/**/*.{ts,js}`));
+  }
+  if (yamlConfig.server?.middleware) {
+    patterns.add(resolvePattern(`${yamlConfig.server.middleware}/**/*.{ts,js}`));
+  }
+  if (yamlConfig.server?.openapi) {
+    patterns.add(resolvePattern(yamlConfig.server.openapi));
+    const openapiDir = path.dirname(resolvePattern(yamlConfig.server.openapi));
+    patterns.add(path.join(openapiDir, 'openapi/**/*.yaml'));
+  }
+  if (yamlConfig.client?.openapi) {
+    patterns.add(resolvePattern(yamlConfig.client.openapi));
+    const openapiDir = path.dirname(resolvePattern(yamlConfig.client.openapi));
+    patterns.add(path.join(openapiDir, 'openapi/**/*.yaml'));
+  }
+  if (yamlConfig.assets) {
+    for (const asset of yamlConfig.assets) {
+      if (asset.includes('*.sql')) {
+        patterns.add(resolvePattern(asset));
+      }
+    }
+  }
+  
+  logger.info('Watching for changes to restart server...');
+  const watcher = chokidar.watch(Array.from(patterns), {
+    ignoreInitial: true,
+    cwd: root
+  });
+  return watcher;
+}
+
+async function runWithRestart(context, tsxExecutable, tsxArgs, env, watcher, logger) {
+  let child = null;
+  
+  const start = () => {
+    child = spawn(tsxExecutable, tsxArgs, {
+      cwd: context.config.rootDir,
+      env,
+      stdio: 'inherit'
+    });
+    child.on('exit', (code) => {
+      if (code !== null && code !== 0) {
+        logger.info(`Dev server exited with code ${code}`);
+      }
+    });
+  };
+  
+  const stop = () =>
+    new Promise((resolve) => {
+      if (!child) return resolve();
+      const to = setTimeout(resolve, 2000);
+      child.once('exit', () => {
+        clearTimeout(to);
+        resolve();
+      });
+      try {
+        child.kill('SIGTERM');
+      } catch {
+        resolve();
+      }
+    });
+  
+  let pending = false;
+  const scheduleRestart = async (reason, file) => {
+    if (pending) return;
+    pending = true;
+    logger.info(`Change detected (${reason}): ${file}. Restarting...`);
+    await stop();
+    start();
+    pending = false;
+  };
+  
+  watcher
+    .on('add', (p) => scheduleRestart('add', p))
+    .on('change', (p) => scheduleRestart('change', p))
+    .on('unlink', (p) => scheduleRestart('unlink', p));
+  
+  // Start initial server
+  start();
+  
+  // Keep process alive until SIGINT/SIGTERM
+  const shutdown = async () => {
+    await stop();
+    await watcher.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}

package/src/commands/runtime-entry.ts

@@ -0,0 +1,16 @@
+import { runRuntime } from '../runtime/runtime.js';
+
+// This file is run via tsx, so it can import TypeScript files
+const configFilePath = process.env.NOEGO_CONFIG_FILE;
+const cliRoot = process.env.NOEGO_CLI_ROOT;
+
+if (!configFilePath) {
+  console.error('NOEGO_CONFIG_FILE environment variable is required');
+  process.exit(1);
+}
+
+runRuntime(configFilePath, cliRoot || undefined).catch((error) => {
+  console.error('Runtime error:', error);
+  process.exit(1);
+});
+