@noego/app 0.0.1

package/src/build/openapi.js

@@ -0,0 +1,249 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import YAML from 'yaml';
+
+const HTTP_METHODS = new Set([
+  'get',
+  'post',
+  'put',
+  'delete',
+  'patch',
+  'head',
+  'options',
+  'trace'
+]);
+
+export async function discoverProject(context) {
+  const [serverDoc, uiDoc] = await Promise.all([
+    loadOpenApiDocumentIfPresent(context, context.config.server.openapiFile),
+    loadOpenApiDocumentIfPresent(context, context.config.ui.openapiFile)
+  ]);
+
+  const serverRoutes = collectRoutes(serverDoc);
+  const uiRoutes = collectRoutes(uiDoc);
+
+  const serverControllers = new Set();
+  const serverMiddleware = new Set();
+  for (const route of serverRoutes) {
+    if (route.controller) {
+      serverControllers.add(route.controller);
+    }
+    for (const middleware of route.middleware) {
+      serverMiddleware.add(middleware);
+    }
+  }
+
+  const uiViews = new Set();
+  const uiLayouts = new Set();
+  const uiMiddleware = new Set();
+  for (const route of uiRoutes) {
+    if (route.view) {
+      uiViews.add(route.view);
+    }
+    for (const layout of route.layout) {
+      uiLayouts.add(layout);
+    }
+    for (const middleware of route.middleware) {
+      uiMiddleware.add(middleware);
+    }
+  }
+
+  const fallback = uiDoc
+    ? {
+        view: ensureString(uiDoc['x-fallback-view']),
+        layouts: ensureArray(uiDoc['x-fallback-layout']),
+        middleware: ensureArray(uiDoc['x-fallback-middleware'])
+      }
+    : { view: null, layouts: [], middleware: [] };
+
+  return {
+    server: {
+      document: serverDoc,
+      routes: serverRoutes,
+      controllers: Array.from(serverControllers),
+      middleware: Array.from(serverMiddleware)
+    },
+    ui: {
+      document: uiDoc,
+      routes: uiRoutes,
+      views: Array.from(uiViews),
+      layouts: Array.from(uiLayouts),
+      middleware: Array.from(uiMiddleware),
+      fallback
+    }
+  };
+}
+
+async function loadOpenApiDocument(context, filePath) {
+  const absolutePath = path.resolve(filePath);
+  const content = await fs.readFile(absolutePath, 'utf8');
+  const parsed = YAML.parse(content);
+
+  if (isStitchConfig(parsed)) {
+    const StitchEngine = await loadStitchEngine(context);
+    const engine = new StitchEngine();
+    const result = engine.buildSync(absolutePath, { format: 'json' });
+    if (!result.success) {
+      throw new Error(`Stitch build failed for ${absolutePath}: ${result.error}`);
+    }
+    const data = typeof result.data === 'string' ? JSON.parse(result.data) : result.data;
+    return data;
+  }
+
+  if (!isOpenApiDocument(parsed)) {
+    throw new Error(`Unsupported OpenAPI document at ${absolutePath}: expected stitch or OpenAPI structure`);
+  }
+
+  return parsed;
+}
+
+async function loadOpenApiDocumentIfPresent(context, filePath) {
+  try {
+    return await loadOpenApiDocument(context, filePath);
+  } catch (err) {
+    if (err && (err.code === 'ENOENT' || String(err.message || '').includes('no such file'))) {
+      return null;
+    }
+    // If the path is falsy or undefined, also treat as absent
+    if (!filePath) return null;
+    // For YAML parse errors or stitch failures, surface them
+    throw err;
+  }
+}
+
+function collectRoutes(document) {
+  const routes = [];
+  const inheritedMiddleware = ensureArray(document?.paths?.['x-middleware']);
+
+  routes.push(...parsePaths(document, inheritedMiddleware));
+  routes.push(...parseModules(document, inheritedMiddleware));
+
+  return routes;
+}
+
+function parseModules(document, inheritedMiddleware = []) {
+  const modulesConfig = document.modules || document.module;
+  if (!modulesConfig) return [];
+
+  const modules = Array.isArray(modulesConfig)
+    ? modulesConfig
+    : Object.values(modulesConfig);
+
+  const routes = [];
+  for (const moduleConfig of modules) {
+    if (!moduleConfig || typeof moduleConfig !== 'object') continue;
+
+    const basePath = moduleConfig.basePath || '';
+    const baseLayouts = ensureArray(moduleConfig.baseLayouts);
+    const moduleMiddleware = ensureArray(moduleConfig['x-middleware']);
+    const combinedMiddleware = [...inheritedMiddleware, ...moduleMiddleware];
+
+    const moduleRoutes = parsePaths(moduleConfig, combinedMiddleware);
+    for (const route of moduleRoutes) {
+      route.path = joinPaths(basePath, route.path);
+      route.layout = [...baseLayouts, ...route.layout];
+      routes.push(route);
+    }
+  }
+
+  return routes;
+}
+
+function parsePaths(document, inheritedMiddleware = []) {
+  const paths = document.paths;
+  if (!paths || typeof paths !== 'object') {
+    return [];
+  }
+
+  const routes = [];
+  const globalMiddleware = [
+    ...inheritedMiddleware,
+    ...ensureArray(paths['x-middleware'])
+  ];
+
+  for (const [routePath, definition] of Object.entries(paths)) {
+    if (!routePath || typeof definition !== 'object') continue;
+    if (!routePath.startsWith('/')) continue;
+
+    for (const [method, config] of Object.entries(definition)) {
+      if (!HTTP_METHODS.has(method.toLowerCase())) continue;
+      routes.push(createRoute(routePath, method.toLowerCase(), config, globalMiddleware));
+    }
+  }
+
+  return routes;
+}
+
+function createRoute(routePath, method, config, inheritedMiddleware) {
+  const layout = ensureArray(config?.['x-layout']);
+  const middleware = [
+    ...inheritedMiddleware,
+    ...ensureArray(config?.['x-middleware'])
+  ];
+
+  return {
+    path: routePath,
+    method,
+    view: ensureString(config?.['x-view']),
+    layout,
+    middleware,
+    controller: ensureString(config?.['x-controller'])
+  };
+}
+
+function ensureArray(value) {
+  if (value == null) return [];
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === 'string' && item.length > 0);
+  }
+  if (typeof value === 'string' && value.length > 0) {
+    return [value];
+  }
+  return [];
+}
+
+function ensureString(value) {
+  return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+function joinPaths(basePath, child) {
+  if (!basePath) return child;
+  if (!child) return basePath;
+  const base = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
+  const tail = child.startsWith('/') ? child : `/${child}`;
+  return `${base}${tail}`;
+}
+
+function isStitchConfig(document) {
+  return document && typeof document === 'object' && 'stitch' in document;
+}
+
+function isOpenApiDocument(document) {
+  return document && typeof document === 'object' && ('paths' in document || 'modules' in document || 'module' in document);
+}
+
+async function loadStitchEngine(context) {
+  try {
+    const mod = context.requireFromRoot('@noego/stitch');
+    const Engine =
+      mod?.StitchEngine ??
+      mod?.default?.StitchEngine ??
+      mod?.default;
+    if (Engine) return Engine;
+  } catch {
+    // Fallback to dynamic import
+  }
+
+  const resolved = context.requireFromRoot.resolve('@noego/stitch');
+  const imported = await import(pathToFileURL(resolved).href);
+  const Engine =
+    imported?.StitchEngine ??
+    imported?.default?.StitchEngine ??
+    imported?.default;
+  if (!Engine) {
+    throw new Error('Unable to resolve StitchEngine from @noego/stitch');
+  }
+  return Engine;
+}

package/src/build/plugins/client-exclude.js

@@ -0,0 +1,90 @@
+import path from 'node:path';
+
+import picomatch from 'picomatch';
+
+export function clientExcludePlugin(specs, { projectRoot }) {
+  if (!Array.isArray(specs) || specs.length === 0) {
+    return {
+      name: 'hammer-client-exclude'
+    };
+  }
+
+  const matchers = specs.map((spec) => createMatcher(spec, projectRoot));
+
+  return {
+    name: 'hammer-client-exclude',
+    enforce: 'pre',
+    load(id) {
+      if (!id || !isFile(id)) return null;
+      if (!shouldExclude(id, matchers)) return null;
+      const messagePath = toPosix(path.relative(projectRoot, id));
+      return generateStubModule(messagePath.startsWith('..') ? id : messagePath);
+    }
+  };
+}
+
+function createMatcher(spec, projectRoot) {
+  const options = { dot: true };
+  if (spec.isAbsolute) {
+    const matcher = picomatch(toPosix(spec.pattern), options);
+    return (id) => matcher(toPosix(id));
+  }
+
+  const cwd = spec.cwd ? path.resolve(spec.cwd) : projectRoot;
+  const matcher = picomatch(toPosix(spec.pattern), options);
+  return (id) => {
+    const relative = path.relative(cwd, id);
+    if (relative.startsWith('..')) {
+      return false;
+    }
+    return matcher(toPosix(relative));
+  };
+}
+
+function shouldExclude(id, matchers) {
+  return matchers.some((matches) => {
+    try {
+      return matches(id);
+    } catch {
+      return false;
+    }
+  });
+}
+
+function generateStubModule(displayPath) {
+  const message = `Excluded from client bundle: ${displayPath}`;
+  return `
+const error = new Error(${JSON.stringify(message)});
+
+const thrower = () => {
+  throw error;
+};
+
+const handler = {
+  apply() { throw error; },
+  construct() { throw error; },
+  get() { throw error; },
+  set() { throw error; },
+  has() { return false; }
+};
+
+const callableProxy = new Proxy(thrower, handler);
+const namespaceProxy = new Proxy({}, {
+  get() { throw error; },
+  set() { throw error; },
+  has() { return false; }
+});
+
+export default callableProxy;
+export const __namespace = namespaceProxy;
+export const __esModule = true;
+  `;
+}
+
+function toPosix(input) {
+  return input.split(path.sep).join('/');
+}
+
+function isFile(id) {
+  return !id.includes('\0');
+}

package/src/build/runtime-manifest.js

@@ -0,0 +1,64 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+export async function writeRuntimeManifest(context, artifacts) {
+  const { config } = context;
+  const targetPath = path.join(config.layout.serverOutDir, 'runtime-manifest.json');
+
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    mode: config.mode,
+    rootDir: config.rootDir,
+    outDir: config.outDir,
+    server: {
+      entry: config.server.entry.relativeToRoot,
+      controllersDir: path.relative(config.rootDir, config.server.controllersDir),
+      middlewareDir: path.relative(config.rootDir, config.server.middlewareDir),
+      openapi: path.relative(config.rootDir, config.server.openapiFile),
+      sqlGlobs: config.server.sqlGlobs.map((spec) => spec.pattern)
+    },
+    ui: {
+      page: config.ui.page.relativeToRoot,
+      openapi: path.relative(config.rootDir, config.ui.openapiFile),
+      assets: config.assets.map((spec) => spec.pattern),
+      clientExclude: config.ui.clientExclude.map((spec) => spec.pattern)
+    },
+    discovery: {
+      server: {
+        controllers: artifacts.discovery.server.controllers,
+        middleware: artifacts.discovery.server.middleware
+      },
+      ui: {
+        views: artifacts.discovery.ui.views,
+        layouts: artifacts.discovery.ui.layouts,
+        middleware: artifacts.discovery.ui.middleware
+      }
+    },
+    client: {
+      manifest: relativeToOut(config, artifacts.client.manifestPath),
+      entry: artifacts.client.entryGraph.entry?.file
+        ? `/assets/${toPosix(artifacts.client.entryGraph.entry.file)}`
+        : null
+    },
+    ssr: {
+      manifest: artifacts.ssr.manifestPath
+        ? relativeToOut(config, artifacts.ssr.manifestPath)
+        : null
+    }
+  };
+
+  await fs.writeFile(targetPath, JSON.stringify(payload, null, 2));
+  return targetPath;
+}
+
+function relativeToRoot(config, absolutePath) {
+  return path.relative(config.rootDir, absolutePath);
+}
+
+function relativeToOut(config, absolutePath) {
+  return path.relative(config.outDir, absolutePath);
+}
+
+function toPosix(value) {
+  return value.split(path.sep).join('/');
+}

package/src/build/server.js

@@ -0,0 +1,294 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+// No URL utilities needed when not vendoring Forge
+
+import { runCommand } from '../utils/command.js';
+import { fixImportExtensions } from './fix-imports.js';
+
+export async function buildServer(context, discovery) {
+  const { logger } = context;
+  logger.info('Building server bundle');
+
+  await runTypeScriptCompiler(context);
+  await reorganizeServerOutputs(context);
+  await mirrorUiModules(context);
+  await syncRootEntry(context);
+  await copyServerAssets(context);
+  await fixImportExtensions(context.config.outDir);
+}
+
+async function runTypeScriptCompiler(context) {
+  const { config, logger, requireFromRoot } = context;
+  const tsconfigPath = path.join(config.rootDir, 'tsconfig.json');
+  if (!(await pathExists(tsconfigPath))) {
+    throw new Error(`Cannot find tsconfig.json at ${tsconfigPath}`);
+  }
+
+  const tscBin = requireFromRoot.resolve('typescript/bin/tsc');
+  logger.info('Running TypeScript compiler');
+
+  await fs.rm(config.layout.tsOutDir, { recursive: true, force: true });
+  await fs.mkdir(config.layout.tsOutDir, { recursive: true });
+
+  try {
+    await runCommand(
+      process.execPath,
+      [
+        tscBin,
+        '--project',
+        tsconfigPath,
+        '--outDir',
+        config.layout.tsOutDir,
+        '--pretty',
+        'false',
+        '--noEmitOnError',
+        'false'
+      ],
+      { cwd: config.rootDir }
+    );
+  } catch (error) {
+    if (error?.code === 'COMMAND_FAILED') {
+      logger.warn('TypeScript reported errors; continuing with emitted output.');
+    } else {
+      throw error;
+    }
+  }
+}
+
+async function reorganizeServerOutputs(context) {
+  const { config, logger } = context;
+  const { tsOutDir, serverOutDir, middlewareOutDir } = config.layout;
+
+  await fs.rm(serverOutDir, { recursive: true, force: true });
+  await fs.mkdir(serverOutDir, { recursive: true });
+  await fs.cp(tsOutDir, serverOutDir, { recursive: true });
+
+  const nestedServerDir = path.join(serverOutDir, 'server');
+  if (await pathExists(nestedServerDir)) {
+    await fs.cp(nestedServerDir, serverOutDir, { recursive: true, force: true });
+    await fs.rm(nestedServerDir, { recursive: true, force: true });
+  }
+
+  const compiledEntryRel = replaceExtension(
+    path.relative(config.rootDir, config.server.entry.absolute),
+    '.js'
+  );
+  const compiledEntryPath = path.join(serverOutDir, compiledEntryRel);
+  if (!(await pathExists(compiledEntryPath))) {
+    throw new Error(`Compiled server entry not found at ${compiledEntryPath}`);
+  }
+
+  // Mirror middleware directory into dist root for Dinner runtime lookup
+  await fs.rm(middlewareOutDir, { recursive: true, force: true });
+  const middlewareRel = path.relative(config.rootDir, config.server.middlewareDir);
+  if (!middlewareRel.startsWith('..')) {
+    const compiledMiddleware = path.join(serverOutDir, middlewareRel);
+    await copyTree(compiledMiddleware, middlewareOutDir);
+  }
+
+  logger.info('Server TypeScript output staged');
+}
+
+// Vendoring of @noego/forge removed to preserve 1:1 layout
+
+async function copyServerAssets(context) {
+  const { config, logger, requireFromRoot } = context;
+  const globModule = requireFromRoot('glob');
+  const glob = typeof globModule === 'function' ? globModule : globModule.glob.bind(globModule);
+
+  // SQL files: must live next to compiled JS under dist/server/**
+  const copiedSql = new Set();
+  for (const spec of config.server.sqlGlobs) {
+    const matches = await glob(spec.pattern, {
+      cwd: spec.cwd,
+      absolute: true,
+      nodir: false,
+      dot: true
+    });
+    for (const absoluteSrc of matches) {
+      await copyRelativeTo(absoluteSrc, config.layout.serverOutDir, config, logger, {
+        seen: copiedSql,
+        stripSegments: ['server']
+      });
+    }
+  }
+
+  // Server OpenAPI + openapi directory (optional)
+  await copyRelativeTo(config.server.openapiFile, config.outDir, config, logger, { allowMissing: true });
+  const serverOpenapiDir = path.join(path.dirname(config.server.openapiFile), 'openapi');
+  await copyRelativeTo(serverOpenapiDir, config.outDir, config, logger, { allowMissing: true });
+
+  // UI OpenAPI + openapi directory (optional)
+  await copyRelativeTo(config.ui.openapiFile, config.outDir, config, logger, { allowMissing: true });
+  const uiOpenapiDir = path.join(path.dirname(config.ui.openapiFile), 'openapi');
+  await copyRelativeTo(uiOpenapiDir, config.outDir, config, logger, { allowMissing: true });
+
+  // Additional assets (ui/resources, database, etc.)
+  const copied = new Set();
+  for (const spec of config.assets) {
+    const matches = await glob(spec.pattern, {
+      cwd: spec.cwd,
+      absolute: true,
+      nodir: false,
+      dot: true
+    });
+    for (const absoluteSrc of matches) {
+      const relative = path.relative(config.rootDir, absoluteSrc);
+      if (relative.startsWith('..')) {
+        logger.warn(`Skipping asset outside project root: ${absoluteSrc}`);
+        continue;
+      }
+      if (copied.has(relative)) continue;
+      copied.add(relative);
+
+      const destination = path.join(config.outDir, relative);
+      const stat = await fs.stat(absoluteSrc);
+      if (stat.isDirectory()) {
+        await copyTree(absoluteSrc, destination);
+      } else {
+        await ensureParentDir(destination);
+        await fs.copyFile(absoluteSrc, destination);
+      }
+    }
+  }
+
+  logger.info('Server runtime assets copied');
+}
+
+async function mirrorUiModules(context) {
+  const { config } = context;
+  const destinationDir = config.layout.uiOutDir;
+  await fs.rm(destinationDir, { recursive: true, force: true }).catch(() => {});
+
+  // Overlay compiled UI outputs from tsc emit so .ts becomes .js under mirrored UI root
+  const compiledUiDir = path.join(
+    config.layout.serverOutDir,
+    path.relative(config.rootDir, config.ui.rootDir)
+  );
+  if (await pathExists(compiledUiDir)) {
+    await fs.cp(compiledUiDir, destinationDir, { recursive: true, force: true });
+  }
+}
+
+async function syncRootEntry(context) {
+  const { config } = context;
+  const compiledEntryRel = replaceExtension(
+    path.relative(config.rootDir, config.server.entry.absolute),
+    '.js'
+  );
+  const sourcePath = path.join(config.layout.serverOutDir, compiledEntryRel);
+  if (!(await pathExists(sourcePath))) {
+    return;
+  }
+  const destinationPath = path.join(config.outDir, compiledEntryRel);
+  await ensureParentDir(destinationPath);
+  await fs.copyFile(sourcePath, destinationPath);
+  await copyIfExists(`${sourcePath}.map`, `${destinationPath}.map`);
+}
+
+// No options wrapper; we mirror compiled UI files as-is.
+
+async function copyRelativeTo(
+  sourcePath,
+  targetRoot,
+  config,
+  logger,
+  { allowMissing = false, seen, stripSegments } = {}
+) {
+  if (!(await pathExists(sourcePath))) {
+    if (!allowMissing) {
+      logger.warn(`Skipping missing path: ${sourcePath}`);
+    }
+    return;
+  }
+  let relative = path.relative(config.rootDir, sourcePath);
+  if (relative.startsWith('..')) {
+    logger.warn(`Skipping path outside project root: ${sourcePath}`);
+    return;
+  }
+  if (seen && seen.has(relative)) {
+    return;
+  }
+  if (seen) {
+    seen.add(relative);
+  }
+
+  if (Array.isArray(stripSegments) && stripSegments.length > 0) {
+    const relParts = relative.split(path.sep).filter(Boolean);
+    let match = true;
+    for (let i = 0; i < stripSegments.length; i += 1) {
+      if (relParts[i] !== stripSegments[i]) {
+        match = false;
+        break;
+      }
+    }
+    if (match) {
+      relative = relParts.slice(stripSegments.length).join(path.sep);
+    }
+  }
+
+  const destination = path.join(targetRoot, relative);
+  const stat = await fs.stat(sourcePath);
+  if (stat.isDirectory()) {
+    await copyTree(sourcePath, destination);
+  } else {
+    await ensureParentDir(destination);
+    await fs.copyFile(sourcePath, destination);
+  }
+}
+
+async function copyTree(source, destination) {
+  if (!(await pathExists(source))) {
+    return;
+  }
+  await fs.rm(destination, { recursive: true, force: true });
+  await fs.mkdir(path.dirname(destination), { recursive: true });
+  await fs.cp(source, destination, { recursive: true });
+}
+
+async function ensureParentDir(targetPath) {
+  await fs.mkdir(path.dirname(targetPath), { recursive: true });
+}
+
+async function copyIfExists(source, destination) {
+  if (await pathExists(source)) {
+    await ensureParentDir(destination);
+    await fs.copyFile(source, destination);
+  }
+}
+
+async function pathExists(target) {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function replaceExtension(filePath, ext) {
+  const parsed = path.parse(filePath);
+  return path.join(parsed.dir, `${parsed.name}${ext}`);
+}
+
+function relativeFromRoot(config, absolutePath) {
+  const relative = path.relative(config.rootDir, absolutePath);
+  if (relative.startsWith('..')) {
+    return null;
+  }
+  return toPosix(relative);
+}
+
+function toPosix(value) {
+  return value.split(path.sep).join('/');
+}
+
+async function replaceInFile(filePath, searchValue, replaceValue) {
+  if (!(await pathExists(filePath))) return;
+  const content = await fs.readFile(filePath, 'utf8');
+  if (!content.includes(searchValue)) return;
+  const updated = content.split(searchValue).join(replaceValue);
+  await fs.writeFile(filePath, updated, 'utf8');
+}
+
+// No vendoring helpers needed