@noego/app 0.0.2 → 0.0.4

package/src/runtime/config-loader.js

@@ -0,0 +1,203 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import YAML from 'yaml';
+
+const CONFIG_FILENAMES = [
+  'noego.yaml', 'noego.yml', 'noego.config.yaml', 'noego.config.yml',
+  'app.yaml', 'app.yml', 'app.config.yaml', 'app.config.yml',
+  'hammer.yaml', 'hammer.yml', 'hammer.config.yaml', 'hammer.config.yml'
+];
+
+export async function loadConfig(configFilePath, cliRoot) {
+  const baseDir = path.dirname(configFilePath);
+  
+  const content = await fs.readFile(configFilePath, 'utf8');
+  const config = YAML.parse(content);
+  
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    throw new Error(`Invalid YAML configuration in ${configFilePath}: expected an object`);
+  }
+  
+  // 1. Determine Project Root
+  const root = cliRoot 
+    ? path.resolve(cliRoot)
+    : (config.root 
+      ? path.resolve(baseDir, config.root)
+      : baseDir);
+  config.root = root;
+  process.env.NOEGO_ROOT = root;
+
+  const resolvedOutDir = path.resolve(root, config.outDir ?? 'dist');
+  config.outDir = config.outDir ?? 'dist';
+  config.outDir_abs = resolvedOutDir;
+
+  // 2. Resolve All Paths to Absolute & Validate
+  if (config.app?.boot) {
+    config.app.boot_abs = path.resolve(root, config.app.boot);
+  } else {
+    throw new Error('Configuration Error: `app.boot` is a required field.');
+  }
+
+  if (config.server) {
+    if (!config.server.main) {
+      throw new Error('Configuration Error: `server.main` is required when a `server` block is defined.');
+    }
+    config.server.main_abs = path.resolve(root, config.server.main);
+    if (config.server.controllers) {
+      config.server.controllers_abs = path.resolve(root, config.server.controllers);
+      config.server.controllers_base_path = config.server.controllers_abs;
+      process.env.NOEGO_CONTROLLERS_PATH = config.server.controllers_abs;
+    }
+    if (config.server.middleware) {
+      config.server.middleware_abs = path.resolve(root, config.server.middleware);
+      config.server.middleware_path = config.server.middleware_abs;
+      process.env.NOEGO_MIDDLEWARE_PATH = config.server.middleware_abs;
+    }
+    if (config.server.openapi) {
+      config.server.openapi_abs = path.resolve(root, config.server.openapi);
+      config.server.openapi_path = config.server.openapi_abs;
+      process.env.NOEGO_OPENAPI_PATH = config.server.openapi_abs;
+    }
+  }
+
+  if (config.client) {
+    if (!config.client.main) {
+      throw new Error('Configuration Error: `client.main` is required when a `client` block is defined.');
+    }
+    if (!config.client.shell) {
+      throw new Error('Configuration Error: `client.shell` is required when a `client` block is defined.');
+    }
+    config.client.main_abs = path.resolve(root, config.client.main);
+    config.client.shell_abs = path.resolve(root, config.client.shell);
+    config.client.shell_path = config.client.shell;
+    process.env.NOEGO_CLIENT_SHELL = config.client.shell_abs;
+    if (config.client.openapi) {
+      config.client.openapi_abs = path.resolve(root, config.client.openapi);
+      config.client.openapi_path = config.client.openapi;
+      process.env.NOEGO_CLIENT_OPENAPI = config.client.openapi_abs;
+    }
+    const inferredComponentDir = config.client.componentDir
+      ? config.client.componentDir
+      : path.relative(root, path.dirname(config.client.main_abs));
+    config.client.component_dir = inferredComponentDir;
+    config.client.componentDir_abs = path.resolve(root, inferredComponentDir);
+  }
+
+  // 3. Set Ports and Environment Variables
+  const frontendPort = process.env.PORT ? parseInt(process.env.PORT, 10) : (config.dev?.port || 3000);
+  
+  let backendPort;
+  if (process.env.BACKEND_PORT) {
+    backendPort = parseInt(process.env.BACKEND_PORT, 10);
+  } else if (process.env.PORT) {
+    backendPort = frontendPort + 1;
+  } else {
+    backendPort = config.dev?.backendPort || frontendPort + 1;
+  }
+  
+  // Only set environment variables if not already set by parent process
+  if (!process.env.NOEGO_PORT) {
+    process.env.NOEGO_PORT = String(frontendPort);
+  }
+  if (!process.env.NOEGO_BACKEND_PORT) {
+    process.env.NOEGO_BACKEND_PORT = String(backendPort);
+  }
+  
+  if (!config.dev) config.dev = {};
+  config.dev.port = frontendPort;
+  config.dev.backendPort = backendPort;
+  
+  config.assets = Array.isArray(config.assets) ? config.assets : [];
+  if (config.client) {
+    config.client.exclude = Array.isArray(config.client.exclude) ? config.client.exclude : [];
+    config.client.assetDirs = [];
+    const relativeResourcesDir = config.client.resourcesDir ?? path.join(path.dirname(config.client.shell ?? ''), 'resources');
+    const resourcesDirAbs = path.resolve(root, relativeResourcesDir);
+    config.client.assetDirs.push({ mountPath: '/css', absolutePath: path.join(resourcesDirAbs, 'tailwind') });
+    config.client.assetDirs.push({ mountPath: '/images', absolutePath: path.join(resourcesDirAbs, 'images') });
+  }
+  
+  process.env.NOEGO_CONFIGURATION = JSON.stringify(config);
+  
+  return { root, config, configFilePath };
+}
+
+/**
+ * Load configuration from NOEGO_CONFIGURATION environment variable
+ * Used when running from a generated bootstrap file (production builds)
+ */
+export function loadConfigFromEnv() {
+  if (!process.env.NOEGO_CONFIGURATION) {
+    throw new Error('NOEGO_CONFIGURATION environment variable is not set');
+  }
+
+  try {
+    const config = JSON.parse(process.env.NOEGO_CONFIGURATION);
+
+    // Validate critical fields
+    if (!config?.root) {
+      throw new Error('config.root is required in NOEGO_CONFIGURATION');
+    }
+    if (!config?.app?.boot_abs) {
+      throw new Error('config.app.boot_abs is required in NOEGO_CONFIGURATION');
+    }
+
+    // Set individual env vars for backwards compatibility
+    process.env.NOEGO_ROOT = config.root;
+
+    if (config.server?.controllers_abs) {
+      process.env.NOEGO_CONTROLLERS_PATH = config.server.controllers_abs;
+    }
+    if (config.server?.middleware_abs) {
+      process.env.NOEGO_MIDDLEWARE_PATH = config.server.middleware_abs;
+    }
+    if (config.server?.openapi_abs) {
+      process.env.NOEGO_OPENAPI_PATH = config.server.openapi_abs;
+    }
+
+    if (config.client?.shell_abs) {
+      process.env.NOEGO_CLIENT_SHELL = config.client.shell_abs;
+    }
+    if (config.client?.openapi_abs) {
+      process.env.NOEGO_CLIENT_OPENAPI = config.client.openapi_abs;
+    }
+
+    if (config.dev?.port) {
+      process.env.NOEGO_PORT = String(config.dev.port);
+    }
+    if (config.dev?.backendPort) {
+      process.env.NOEGO_BACKEND_PORT = String(config.dev.backendPort);
+    }
+
+    return { root: config.root, config, configFilePath: null };
+  } catch (error) {
+    throw new Error(`Failed to parse NOEGO_CONFIGURATION: ${error.message}`);
+  }
+}
+
+export async function findConfigFile(rootDir, explicit) {
+  if (explicit) {
+    const candidate = path.isAbsolute(explicit) ? explicit : path.resolve(rootDir, explicit);
+    try {
+      await fs.access(candidate);
+      return candidate;
+    } catch {
+      throw new Error(`Config file not found: ${explicit}`);
+    }
+  }
+  
+  for (const fileName of CONFIG_FILENAMES) {
+    const candidate = path.join(rootDir, fileName);
+    try {
+      await fs.access(candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  
+  throw new Error(
+    `No configuration file found in ${rootDir}.\nPlease create hammer.config.yml (or a similar named file) in your project root.`
+  );
+}
+

package/src/runtime/html-parser.js

@@ -0,0 +1,47 @@
+import fs from 'node:fs/promises';
+
+export async function parseHtmlScripts(htmlFilePath) {
+  const content = await fs.readFile(htmlFilePath, 'utf8');
+  const scripts = [];
+  
+  // Match script tags with src attribute
+  const scriptRegex = /<script[^>]*src=["']([^"']+)["'][^>]*><\/script>/gi;
+  let match;
+  
+  while ((match = scriptRegex.exec(content)) !== null) {
+    const src = match[1];
+    // Skip Vite dev client
+    if (src.includes('/@vite/client')) continue;
+    scripts.push(src);
+  }
+  
+  return scripts;
+}
+
+/**
+ * Injects configuration into HTML template as window.__CONFIGURATION__
+ * 
+ * @param {string} htmlFilePath - Path to HTML template
+ * @param {object} config - Configuration object to inject
+ * @returns {Promise<string>} HTML content with injected configuration
+ */
+export async function injectConfiguration(htmlFilePath, config) {
+  let html = await fs.readFile(htmlFilePath, 'utf8');
+  
+  // Create the configuration script
+  const configScript = `<script>window.__CONFIGURATION__ = ${JSON.stringify(config)};</script>`;
+  
+  // Inject before closing </head> tag, or at the beginning of <body> if no </head>
+  if (html.includes('</head>')) {
+    html = html.replace('</head>', `${configScript}\n</head>`);
+  } else if (html.includes('<body')) {
+    // Find the opening body tag and inject after it
+    html = html.replace(/(<body[^>]*>)/, `$1\n${configScript}`);
+  } else {
+    // Fallback: inject at the beginning
+    html = configScript + '\n' + html;
+  }
+  
+  return html;
+}
+

package/src/runtime/index.js

@@ -0,0 +1,4 @@
+export { runRuntime } from './runtime.js';
+export { loadConfig, findConfigFile } from './config-loader.js';
+export { parseHtmlScripts } from './html-parser.js';
+