@noego/app 0.0.1

package/src/config.js

@@ -0,0 +1,584 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import deepmerge from 'deepmerge';
+import YAML from 'yaml';
+
+const CONFIG_FILENAMES = [
+  // Primary App config filenames
+  'noego.yaml',
+  'noego.yml',
+  'noego.config.yaml',
+  'noego.config.yml',
+  'noego.config.json',
+  // Common App config filenames
+  'app.yaml',
+  'app.yml',
+  'app.config.yaml',
+  'app.config.yml',
+  'app.config.json',
+  // Back-compat with legacy Hammer config filenames
+  'hammer.yaml',
+  'hammer.yml',
+  'hammer.config.yaml',
+  'hammer.config.yml',
+  'hammer.config.json'
+];
+const OVERRIDE_FILE_KEY = '__appFromFile';
+
+const DEFAULTS = {
+  mode: 'production',
+  outDir: 'dist',
+  assets: ['ui/resources/**', 'ui/styles/**', 'database/**'],
+  server: {
+    entry: 'index.ts',
+    rootDir: '.',
+    controllers: 'server/controller',
+    middleware: 'middleware',
+    openapi: 'server/stitch.yaml',
+    sqlGlobs: []
+  },
+  ui: {
+    page: 'ui/index.html',
+    rootDir: null,
+    openapi: 'ui/stitch.yaml',
+    assets: [],
+    clientExclude: ['server/**', 'middleware/**'],
+    options: 'ui/options.ts'
+  },
+  vite: {
+    client: {
+      configFile: null,
+      override: null
+    },
+    ssr: {
+      configFile: null,
+      override: null
+    }
+  },
+  dev: {
+    watch: false,
+    watchPaths: [],
+    splitServe: false,
+    frontendCmd: 'vite'
+  }
+};
+
+export async function loadBuildConfig(cliOptions = {}, { cwd = process.cwd() } = {}) {
+  const rootDir = resolvePath(cliOptions.root ?? '.', cwd);
+  const configFilePath = await findConfigFile(rootDir, cliOptions.configFile);
+
+  const fileRaw =
+    configFilePath != null ? await loadConfigFile(configFilePath) : {};
+  const fileNormalized =
+    configFilePath != null
+      ? normalizeExternalConfig(fileRaw, { baseDir: path.dirname(configFilePath) })
+      : {};
+
+  const cliNormalized = normalizeCliOptions(cliOptions);
+
+  const mergedRaw = deepmerge.all(
+    [DEFAULTS, fileNormalized, cliNormalized],
+    {
+      arrayMerge: (_target, source) => Array.isArray(source) ? source : []
+    }
+  );
+
+  const overrides = await resolveOverrides(mergedRaw);
+  const finalConfig = finalizeConfig(overrides, { rootDir });
+
+  return {
+    ...finalConfig,
+    sources: {
+      rootDir,
+      configFile: configFilePath ?? null
+    }
+  };
+}
+
+async function findConfigFile(rootDir, explicit) {
+  if (explicit) {
+    const candidate = resolvePath(explicit, rootDir);
+    await assertFile(candidate, `Config file not found: ${explicit}`);
+    return candidate;
+  }
+
+  for (const fileName of CONFIG_FILENAMES) {
+    const candidate = path.join(rootDir, fileName);
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+async function loadConfigFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext === '.yaml' || ext === '.yml') {
+    return loadYamlConfig(filePath);
+  }
+  if (ext === '.json') {
+    return loadJsonConfig(filePath);
+  }
+  throw new Error(`Unsupported App config extension for ${filePath}`);
+}
+
+async function loadYamlConfig(filePath) {
+  const content = await fs.readFile(filePath, 'utf8');
+  const parsed = YAML.parse(content);
+  if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error(`Invalid YAML configuration in ${filePath}: expected an object`);
+  }
+  return parsed;
+}
+
+async function loadJsonConfig(filePath) {
+  const content = await fs.readFile(filePath, 'utf8');
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('expected an object');
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(`Invalid JSON configuration in ${filePath}: ${error.message}`);
+  }
+}
+
+function normalizeExternalConfig(raw, { baseDir }) {
+  const result = {};
+
+  if (raw.mode != null) {
+    result.mode = raw.mode;
+  }
+
+  if (raw.outDir != null) {
+    result.outDir = resolveMaybePath(raw.outDir, baseDir);
+  }
+
+  // Top-level page shortcut
+  if (raw.page != null) {
+    result.ui = result.ui || {};
+    result.ui.page = resolveMaybePath(raw.page, baseDir);
+  }
+  if (raw.options != null) {
+    result.ui = result.ui || {};
+    result.ui.options = resolveMaybePath(raw.options, baseDir);
+  }
+
+  if (raw.assets != null) {
+    result.assets = normalizeList(raw.assets).map((glob) =>
+      resolveMaybePath(glob, baseDir)
+    );
+  }
+
+  if (raw.server) {
+    result.server = {};
+    if (raw.server.entry != null) {
+      result.server.entry = resolveMaybePath(raw.server.entry, baseDir);
+    }
+    if (raw.server.rootDir != null) {
+      result.server.rootDir = resolveMaybePath(raw.server.rootDir, baseDir);
+    }
+    if (raw.server.controllers != null) {
+      result.server.controllers = resolveMaybePath(raw.server.controllers, baseDir);
+    }
+    if (raw.server.middleware != null) {
+      result.server.middleware = resolveMaybePath(raw.server.middleware, baseDir);
+    }
+    if (raw.server.openapi != null) {
+      result.server.openapi = resolveMaybePath(raw.server.openapi, baseDir);
+    }
+    if (raw.server.sqlGlobs != null) {
+      result.server.sqlGlobs = normalizeList(raw.server.sqlGlobs).map((glob) =>
+        resolveMaybePath(glob, baseDir)
+      );
+    }
+  }
+
+  if (raw.ui) {
+    result.ui = {};
+    if (raw.ui.page != null) {
+      result.ui.page = resolveMaybePath(raw.ui.page, baseDir);
+    }
+    if (raw.ui.options != null) {
+      result.ui.options = resolveMaybePath(raw.ui.options, baseDir);
+    }
+    if (raw.ui.rootDir != null) {
+      result.ui.rootDir = resolveMaybePath(raw.ui.rootDir, baseDir);
+    }
+    if (raw.ui.openapi != null) {
+      result.ui.openapi = resolveMaybePath(raw.ui.openapi, baseDir);
+    }
+    if (raw.ui.assets != null) {
+      result.ui.assets = normalizeList(raw.ui.assets).map((glob) =>
+        resolveMaybePath(glob, baseDir)
+      );
+    }
+    if (raw.ui.clientExclude != null) {
+      result.ui.clientExclude = normalizeList(raw.ui.clientExclude).map((glob) =>
+        resolveMaybePath(glob, baseDir)
+      );
+    }
+  }
+
+  if (raw.vite) {
+    result.vite = {};
+    if (raw.vite.client) {
+      result.vite.client = {};
+      if (raw.vite.client.configFile != null) {
+        result.vite.client.configFile = resolveMaybePath(raw.vite.client.configFile, baseDir);
+      }
+      if (raw.vite.client.override != null) {
+        result.vite.client.override = wrapOverride(raw.vite.client.override, baseDir);
+      }
+    }
+    if (raw.vite.ssr) {
+      result.vite.ssr = {};
+      if (raw.vite.ssr.configFile != null) {
+        result.vite.ssr.configFile = resolveMaybePath(raw.vite.ssr.configFile, baseDir);
+      }
+      if (raw.vite.ssr.override != null) {
+        result.vite.ssr.override = wrapOverride(raw.vite.ssr.override, baseDir);
+      }
+    }
+  }
+
+  if (raw.dev) {
+    result.dev = {};
+    if (raw.dev.watch != null) {
+      result.dev.watch = Boolean(raw.dev.watch);
+    }
+    if (raw.dev.watchPaths != null) {
+      result.dev.watchPaths = normalizeList(raw.dev.watchPaths).map((glob) =>
+        resolveMaybePath(glob, baseDir)
+      );
+    }
+    if (raw.dev.splitServe != null) {
+      result.dev.splitServe = Boolean(raw.dev.splitServe);
+    }
+    if (raw.dev.frontendCmd != null) {
+      result.dev.frontendCmd = raw.dev.frontendCmd;
+    }
+  }
+
+  return result;
+}
+
+function normalizeCliOptions(options) {
+  const result = {};
+
+  if (options.out != null) {
+    result.outDir = options.out;
+  }
+  if (options.mode != null) {
+    result.mode = options.mode;
+  }
+
+  if (options.server != null || options.serverRoot != null || options.controllers != null || options.middleware != null || options.openapi != null || options.sqlGlob != null) {
+    result.server = {};
+    if (options.server != null) result.server.entry = options.server;
+    if (options.serverRoot != null) result.server.rootDir = options.serverRoot;
+    if (options.controllers != null) result.server.controllers = options.controllers;
+    if (options.middleware != null) result.server.middleware = options.middleware;
+    if (options.openapi != null) result.server.openapi = options.openapi;
+    if (options.sqlGlob != null) result.server.sqlGlobs = normalizeList(options.sqlGlob);
+  }
+
+  if (options.page != null || options.uiRoot != null || options.uiOpenapi != null || options.uiOptions != null || options.clientExclude != null) {
+    result.ui = {};
+    if (options.page != null) result.ui.page = options.page;
+    if (options.uiRoot != null) result.ui.rootDir = options.uiRoot;
+    if (options.uiOpenapi != null) result.ui.openapi = options.uiOpenapi;
+    if (options.uiOptions != null) result.ui.options = options.uiOptions;
+    if (options.clientExclude != null) result.ui.clientExclude = normalizeList(options.clientExclude);
+  }
+
+  if (options.assets != null) {
+    result.assets = normalizeList(options.assets);
+  }
+
+  if (options.clientViteConfig != null || options.clientViteOverride != null || options.ssrViteConfig != null || options.ssrViteOverride != null) {
+    result.vite = {};
+    if (options.clientViteConfig != null || options.clientViteOverride != null) {
+      result.vite.client = {};
+      if (options.clientViteConfig != null) {
+        result.vite.client.configFile = options.clientViteConfig;
+      }
+      if (options.clientViteOverride != null) {
+        result.vite.client.override = parseJsonOption(options.clientViteOverride, '--client-vite-override');
+      }
+    }
+    if (options.ssrViteConfig != null || options.ssrViteOverride != null) {
+      result.vite.ssr = {};
+      if (options.ssrViteConfig != null) {
+        result.vite.ssr.configFile = options.ssrViteConfig;
+      }
+      if (options.ssrViteOverride != null) {
+        result.vite.ssr.override = parseJsonOption(options.ssrViteOverride, '--ssr-vite-override');
+      }
+    }
+  }
+
+  if (options.watch != null || options.watchPath != null || options.splitServe != null || options.frontendCmd != null) {
+    result.dev = {};
+    if (options.watch != null) result.dev.watch = Boolean(options.watch);
+    if (options.watchPath != null) result.dev.watchPaths = normalizeList(options.watchPath);
+    if (options.splitServe != null) result.dev.splitServe = Boolean(options.splitServe);
+    if (options.frontendCmd != null) result.dev.frontendCmd = options.frontendCmd;
+  }
+
+  return result;
+}
+
+async function resolveOverrides(raw) {
+  const resolved = structuredClone(raw);
+
+  const clientOverride = raw?.vite?.client?.override;
+  if (clientOverride && typeof clientOverride === 'object' && OVERRIDE_FILE_KEY in clientOverride) {
+    const loaded = await readJsonFile(clientOverride[OVERRIDE_FILE_KEY]);
+    resolved.vite.client.override = loaded;
+  }
+
+  const ssrOverride = raw?.vite?.ssr?.override;
+  if (ssrOverride && typeof ssrOverride === 'object' && OVERRIDE_FILE_KEY in ssrOverride) {
+    const loaded = await readJsonFile(ssrOverride[OVERRIDE_FILE_KEY]);
+    resolved.vite.ssr.override = loaded;
+  }
+
+  return resolved;
+}
+
+function finalizeConfig(raw, { rootDir }) {
+  const outDir = resolvePath(raw.outDir ?? DEFAULTS.outDir, rootDir);
+
+  const serverRootDir = resolvePath(raw.server?.rootDir ?? DEFAULTS.server.rootDir ?? '.', rootDir);
+  const serverEntryRaw = raw.server?.entry ?? DEFAULTS.server.entry;
+  const serverEntryAbs = resolveWithBase(serverEntryRaw, serverRootDir);
+
+  const controllersDir = resolvePath(raw.server?.controllers ?? DEFAULTS.server.controllers, rootDir);
+  const middlewareDir = resolvePath(raw.server?.middleware ?? DEFAULTS.server.middleware, rootDir);
+  const openapiFile = resolvePath(raw.server?.openapi ?? DEFAULTS.server.openapi, rootDir);
+  const sqlGlobs = normalizeGlobList(raw.server?.sqlGlobs ?? DEFAULTS.server.sqlGlobs, rootDir);
+
+  const pageRaw = raw.ui?.page ?? DEFAULTS.ui.page;
+  const pageAbs = resolveWithBase(pageRaw, rootDir);
+  const uiRootDir = resolvePath(raw.ui?.rootDir ?? path.dirname(pageAbs), rootDir);
+  const optionsRaw = raw.ui?.options ?? DEFAULTS.ui.options;
+  const optionsAbs = resolveWithBase(optionsRaw, rootDir);
+  const uiOpenapiFile = resolvePath(raw.ui?.openapi ?? DEFAULTS.ui.openapi, rootDir);
+  const assetSources = collectAssetPatterns({
+    topLevel: raw.assets,
+    topLevelDefault: DEFAULTS.assets,
+    uiLevel: raw.ui?.assets,
+    uiDefault: DEFAULTS.ui.assets
+  });
+  const assetGlobs = normalizeGlobList(assetSources, rootDir);
+  const clientExclude = normalizeGlobList(raw.ui?.clientExclude ?? DEFAULTS.ui.clientExclude, rootDir);
+
+  const uiRelRoot = path.relative(rootDir, uiRootDir);
+  const layout = {
+    outDir,
+    serverOutDir: path.join(outDir, 'server'),
+    // Place client bundle under .app
+    clientOutDir: path.join(outDir, '.app', 'assets'),
+    // Mirror UI outputs under the same relative root (no hardcoded 'ui')
+    uiOutDir: path.join(outDir, uiRelRoot),
+    // SSR precompile staging (build-only); will be overlaid into uiOutDir
+    ssrOutDir: path.join(outDir, '.app', 'ssr'),
+    middlewareOutDir: path.join(outDir, 'middleware'),
+    tempDir: path.join(outDir, '.app'),
+    tsOutDir: path.join(outDir, '.app', 'tsc')
+  };
+
+  return {
+    mode: raw.mode ?? DEFAULTS.mode,
+    rootDir,
+    outDir,
+    // publicPaths removed; client base is fixed to '/.app/client'
+    layout,
+    server: {
+      rootDir: serverRootDir,
+      entry: {
+        raw: serverEntryRaw,
+        absolute: serverEntryAbs,
+        relativeToRoot: path.relative(rootDir, serverEntryAbs),
+        relativeToServerRoot: path.relative(serverRootDir, serverEntryAbs)
+      },
+      controllersDir,
+      middlewareDir,
+      openapiFile,
+      sqlGlobs
+    },
+    ui: {
+      rootDir: uiRootDir,
+      page: {
+        raw: pageRaw,
+        absolute: pageAbs,
+        relativeToRoot: path.relative(rootDir, pageAbs)
+      },
+      options: {
+        raw: optionsRaw,
+        absolute: optionsAbs,
+        relativeToRoot: path.relative(rootDir, optionsAbs),
+        relativeToUiRoot: path.relative(uiRootDir, optionsAbs)
+      },
+      openapiFile: uiOpenapiFile,
+      assets: assetGlobs,
+      clientExclude
+    },
+    assets: assetGlobs,
+    vite: {
+      client: {
+        configFile: raw?.vite?.client?.configFile
+          ? resolveMaybePath(raw.vite.client.configFile, rootDir)
+          : null,
+        override: raw?.vite?.client?.override ?? null
+      },
+      ssr: {
+        configFile: raw?.vite?.ssr?.configFile
+          ? resolveMaybePath(raw.vite.ssr.configFile, rootDir)
+          : null,
+        override: raw?.vite?.ssr?.override ?? null
+      }
+    },
+    dev: {
+      watch: Boolean(raw?.dev?.watch ?? DEFAULTS.dev.watch),
+      watchPaths: normalizeGlobList(raw?.dev?.watchPaths ?? DEFAULTS.dev.watchPaths, rootDir),
+      splitServe: Boolean(raw?.dev?.splitServe ?? DEFAULTS.dev.splitServe),
+      frontendCmd: raw?.dev?.frontendCmd ?? DEFAULTS.dev.frontendCmd
+    }
+  };
+}
+
+function collectAssetPatterns({ topLevel, topLevelDefault, uiLevel, uiDefault }) {
+  const patterns = new Set();
+
+  const addAll = (value) => {
+    if (value == null) return;
+    for (const entry of normalizeList(value)) {
+      if (entry == null || entry === '') continue;
+      patterns.add(entry);
+    }
+  };
+
+  if (topLevel != null) {
+    addAll(topLevel);
+  } else {
+    addAll(topLevelDefault);
+  }
+
+  if (uiLevel != null) {
+    addAll(uiLevel);
+  } else {
+    addAll(uiDefault);
+  }
+
+  return Array.from(patterns);
+}
+
+function normalizeGlobList(values, baseDir) {
+  return normalizeList(values).map((pattern) => ({
+    pattern,
+    isAbsolute: path.isAbsolute(pattern),
+    cwd: path.isAbsolute(pattern) ? undefined : baseDir,
+    absolute: path.isAbsolute(pattern) ? pattern : path.resolve(baseDir, pattern)
+  }));
+}
+
+function wrapOverride(value, baseDir) {
+  if (value == null) return null;
+  if (typeof value === 'object' && !Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      const resolved = resolveMaybePath(trimmed, baseDir);
+      return { [OVERRIDE_FILE_KEY]: resolved };
+    }
+  }
+  throw new Error('Unsupported override configuration value');
+}
+
+function normalizeList(value) {
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => normalizeList(item));
+  }
+  if (typeof value === 'string') {
+    if (value.includes(',')) {
+      return value
+        .split(',')
+        .map((part) => part.trim())
+        .filter(Boolean);
+    }
+    return value.trim() ? [value.trim()] : [];
+  }
+  if (value == null) {
+    return [];
+  }
+  return [String(value)];
+}
+
+function resolveMaybePath(value, baseDir) {
+  if (value == null || value === '') {
+    return value;
+  }
+  if (path.isAbsolute(value)) {
+    return path.normalize(value);
+  }
+  return path.resolve(baseDir, value);
+}
+
+function resolveWithBase(value, baseDir) {
+  if (path.isAbsolute(value)) {
+    return path.normalize(value);
+  }
+  return path.resolve(baseDir, value);
+}
+
+function resolvePath(input, baseDir) {
+  if (input == null || input === '') {
+    return path.resolve(baseDir);
+  }
+  if (path.isAbsolute(input)) {
+    return path.normalize(input);
+  }
+  return path.resolve(baseDir, input);
+}
+
+// No public base normalization; client assets served from '/.app/client'
+
+async function pathExists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function assertFile(filePath, message) {
+  if (!(await pathExists(filePath))) {
+    throw new Error(message);
+  }
+}
+
+async function readJsonFile(filePath) {
+  const content = await fs.readFile(filePath, 'utf8');
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON override at ${filePath}: ${error.message}`);
+  }
+}
+
+function parseJsonOption(value, flagName) {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Invalid JSON passed to ${flagName}: ${error.message}`);
+  }
+}

package/src/logger.js

@@ -0,0 +1,16 @@
+import process from 'node:process';
+
+export function createLogger({ verbose = false } = {}) {
+  const debugEnabled = verbose || Boolean(process.env.APP_DEBUG || process.env.HAMMER_DEBUG);
+
+  return {
+    info: (...args) => console.log('[app]', ...args),
+    warn: (...args) => console.warn('[app]', ...args),
+    error: (...args) => console.error('[app]', ...args),
+    debug: (...args) => {
+      if (debugEnabled) {
+        console.log('[app:debug]', ...args);
+      }
+    }
+  };
+}

package/src/utils/command.js

@@ -0,0 +1,23 @@
+import { spawn } from 'node:child_process';
+
+export function runCommand(command, args = [], { cwd, env, logger } = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      env: { ...process.env, ...env },
+      stdio: 'inherit',
+      shell: false
+    });
+
+    child.on('error', reject);
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        const error = new Error(`Command "${command} ${args.join(' ')}" exited with code ${code}`);
+        error.code = 'COMMAND_FAILED';
+        reject(error);
+      }
+    });
+  });
+}