@noego/app 0.0.1

package/src/build/ssr.js

@@ -0,0 +1,257 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { buildWithVite } from './vite.js';
+import { createUiBuildConfig } from './ui-common.js';
+import { resolveClientEntry } from './client.js';
+
+export async function resolveSsrBuildConfig(context, discovery) {
+  const { config } = context;
+  const { entryAbsolute } = await resolveClientEntry(context);
+  const shared = await createUiBuildConfig(context, {
+    discovery,
+    entryAbsolute,
+    outDir: config.layout.ssrOutDir,
+    ssr: true,
+    configFileOption: config.vite.ssr.configFile,
+    overrideOption: config.vite.ssr.override,
+    emptyOutDir: true,
+    manifest: true
+  });
+
+  if (!shared.config) {
+    return { config: null, components: [] };
+  }
+
+  return {
+    config: shared.config,
+    components: shared.components,
+    missing: shared.missing
+  };
+}
+
+export async function buildSsr(context, discovery) {
+  const { logger, config } = context;
+
+  const resolution = await resolveSsrBuildConfig(context, discovery);
+
+  if (!resolution.config) {
+    logger.info('No .svelte components found; skipping SSR build.');
+    return { manifestPath: null, manifest: { routes: {}, fallback: null } };
+  }
+
+  logger.info(`Precompiling ${resolution.components.length} Svelte component(s) for SSR`);
+
+  await buildWithVite(context, resolution.config);
+
+  if (Array.isArray(resolution.missing) && resolution.missing.length > 0) {
+    resolution.missing.forEach((component) => {
+      logger.warn(`Skipping missing UI component during SSR build: ${component}`);
+    });
+  }
+
+  await buildForgeRecursiveRenderer(context);
+
+  const manifest = buildSsrManifest(config, discovery);
+  const manifestPath = path.join(config.layout.ssrOutDir, 'manifest.json');
+  await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+
+  // Overlay SSR compiled modules into the mirrored UI root so runtime imports
+  // like component_path.replace('.svelte', '.js') resolve without loaders.
+  try {
+    await fs.mkdir(config.layout.uiOutDir, { recursive: true });
+    await fs.cp(config.layout.ssrOutDir, config.layout.uiOutDir, { recursive: true, force: true });
+  } catch (err) {
+    // non-fatal; report via console for visibility
+    console.warn('Failed to overlay SSR output into UI root:', err?.message || err);
+  }
+
+  await writeSsrEntryModule(context, resolution.components).catch((err) => {
+    logger.warn(`Failed to generate SSR entry module: ${err?.message || err}`);
+  });
+
+  return {
+    manifestPath,
+    manifest
+  };
+}
+
+export async function resolveRecursiveRendererBuildConfig(context) {
+  const { config, requireFromRoot } = context;
+  const forgeEntry = requireFromRoot.resolve('@noego/forge');
+  const forgeRoot = await findPackageRoot(forgeEntry, '@noego/forge');
+  const entryPath = path.join(forgeRoot, 'src', 'components', 'RecursiveRender.svelte');
+
+  const pluginModule = await loadSveltePluginModule(context, [config.rootDir, forgeRoot]);
+  const createSveltePlugin = pluginModule?.svelte ?? pluginModule?.default;
+  if (typeof createSveltePlugin !== 'function') {
+    throw new Error('Unable to load @sveltejs/vite-plugin-svelte');
+  }
+  const sveltePlugin = createSveltePlugin();
+
+  const baseConfig = {
+    configFile: false,
+    mode: config.mode,
+    root: forgeRoot,
+    plugins: [sveltePlugin],
+    build: {
+      ssr: true,
+      outDir: config.layout.ssrOutDir,
+      emptyOutDir: false,
+      rollupOptions: {
+        input: entryPath,
+        preserveEntrySignatures: 'strict',
+        output: {
+          entryFileNames: 'RecursiveRender.js',
+          chunkFileNames: 'chunks/[name]-[hash].js',
+          assetFileNames: 'chunks/[name]-[hash][extname]'
+        }
+      }
+    }
+  };
+
+  const printableConfig = {
+    ...baseConfig,
+    plugins: baseConfig.plugins.map((plugin) => plugin?.name || 'anonymous')
+  };
+
+  return {
+    config: baseConfig,
+    printableConfig
+  };
+}
+
+async function buildForgeRecursiveRenderer(context) {
+  const { logger } = context;
+  try {
+    const resolution = await resolveRecursiveRendererBuildConfig(context);
+    await buildWithVite(context, resolution.config);
+  } catch (e) {
+    logger.warn(`Skipping Forge RecursiveRender precompile: ${e?.message || e}`);
+  }
+}
+
+async function writeSsrEntryModule(context, componentList = []) {
+  const { config } = context;
+  const uiOutDir = config.layout.uiOutDir;
+  const entryPath = path.join(uiOutDir, 'entry-ssr.js');
+
+  const uniqueComponents = Array.from(
+    new Set(
+      componentList
+        .filter(Boolean)
+        .filter((component) => typeof component === 'string' && component.endsWith('.svelte'))
+    )
+  ).sort();
+
+  const importLines = [];
+  const mapLines = [];
+  let index = 0;
+
+  for (const component of uniqueComponents) {
+    const jsPathRelative = toPosix(component.replace(/\.svelte$/, '.js'));
+    const absoluteJsPath = path.join(uiOutDir, jsPathRelative);
+    try {
+      await fs.access(absoluteJsPath);
+    } catch {
+      continue;
+    }
+    const identifier = `mod${index++}`;
+    const importPath = `./${jsPathRelative}`;
+    importLines.push(`import * as ${identifier} from ${JSON.stringify(importPath)};`);
+    const key = toPosix(component);
+    mapLines.push(`  ${JSON.stringify(key)}: ${identifier}`);
+  }
+
+  const contents = [
+    '// Generated by Hammer: maps Svelte components to precompiled SSR modules.',
+    ...importLines,
+    '',
+    'export const components = {',
+    mapLines.join(',\n'),
+    '};',
+    '',
+    'export default components;',
+    ''
+  ].join('\n');
+
+  await fs.mkdir(path.dirname(entryPath), { recursive: true });
+  await fs.writeFile(entryPath, contents, 'utf8');
+}
+
+function toPosix(value) {
+  return value.split(path.sep).join('/');
+}
+
+async function loadSveltePluginModule(context, searchRoots = []) {
+  const attempted = new Set();
+  for (const root of searchRoots.filter(Boolean)) {
+    const candidate = path.join(root, 'node_modules', '@sveltejs', 'vite-plugin-svelte', 'src', 'index.js');
+    if (attempted.has(candidate)) continue;
+    attempted.add(candidate);
+    try {
+      return await import(pathToFileURL(candidate).href);
+    } catch (err) {
+      if (err?.code !== 'ERR_MODULE_NOT_FOUND' && err?.code !== 'ENOENT') {
+        throw err;
+      }
+    }
+  }
+  return import('@sveltejs/vite-plugin-svelte');
+}
+
+async function findPackageRoot(entryPath, packageName) {
+  let current = path.dirname(entryPath);
+  const filesystemRoot = path.parse(current).root;
+  while (current && current !== filesystemRoot) {
+    const pkgPath = path.join(current, 'package.json');
+    try {
+      const content = await fs.readFile(pkgPath, 'utf8');
+      const pkg = JSON.parse(content);
+      if (pkg.name === packageName) return current;
+    } catch {}
+    current = path.dirname(current);
+  }
+  throw new Error(`Unable to locate package root for ${packageName}`);
+}
+
+function buildSsrManifest(config, discovery) {
+  const routesManifest = {};
+  for (const route of discovery.ui.routes) {
+    routesManifest[route.path] = {
+      method: route.method,
+      view: route.view ? componentToSsrPath(route.view, config) : null,
+      layouts: route.layout.map((item) => componentToSsrPath(item, config)),
+      middleware: route.middleware
+    };
+  }
+
+  const fallback = discovery.ui.fallback;
+  const normalizedFallback = fallback
+    ? {
+        view: fallback.view ? componentToSsrPath(fallback.view, config) : null,
+        layouts: fallback.layouts.map((item) => componentToSsrPath(item, config)),
+        middleware: fallback.middleware
+      }
+    : null;
+
+  return {
+    routes: routesManifest,
+    fallback: normalizedFallback
+  };
+}
+
+function componentToSsrPath(componentPath, config) {
+  const relative = componentPath.startsWith('.')
+    ? path.normalize(componentPath)
+    : componentPath;
+  const trimmed = relative.startsWith(config.ui.rootDir)
+    ? path.relative(config.ui.rootDir, relative)
+    : relative;
+  // Mirror SSR outputs under the same relative UI root within dist
+  const uiRelRoot = path.relative(config.rootDir, config.ui.rootDir);
+  const withoutExt = trimmed.replace(/\.svelte$/, '.js');
+  const joined = path.join(uiRelRoot, withoutExt);
+  return joined.split(path.sep).join('/');
+}

package/src/build/ui-common.js

@@ -0,0 +1,188 @@
+import path from 'node:path';
+
+import { clientExcludePlugin } from './plugins/client-exclude.js';
+import { resolveConfigFile, fileExists } from './helpers.js';
+import { mergeViteConfig } from './vite.js';
+
+export async function collectUiComponentEntries(context, discovery) {
+  const { config, requireFromRoot } = context;
+  const components = new Set([
+    ...(discovery?.ui?.views || []),
+    ...(discovery?.ui?.layouts || [])
+  ]);
+
+  const fallback = discovery?.ui?.fallback;
+  if (fallback) {
+    if (fallback.view) components.add(fallback.view);
+    (fallback.layouts || []).forEach((layout) => components.add(layout));
+  }
+
+  try {
+    const globModule = requireFromRoot('glob');
+    const glob = typeof globModule === 'function'
+      ? globModule
+      : globModule.glob.bind(globModule);
+    const discovered = await glob('**/*.svelte', {
+      cwd: config.ui.rootDir,
+      absolute: false,
+      nodir: true,
+      dot: false
+    });
+    discovered.forEach((rel) => components.add(rel));
+  } catch (err) {
+    // glob is optional; ignore if not available
+    if (err && err.code !== 'MODULE_NOT_FOUND') {
+      throw err;
+    }
+  }
+
+  return Array.from(components).sort();
+}
+
+export async function createUiBuildConfig(context, options) {
+  const {
+    discovery,
+    entryAbsolute,
+    outDir,
+    ssr,
+    configFileOption,
+    overrideOption,
+    emptyOutDir = true,
+    manifest = true
+  } = options;
+
+  const { config } = context;
+  const entryResolved = entryAbsolute ? path.resolve(entryAbsolute) : null;
+
+  const componentRelatives = await collectUiComponentEntries(context, discovery);
+  const presentComponents = [];
+  const missingComponents = [];
+  const inputSet = new Set();
+
+  if (entryResolved) inputSet.add(entryResolved);
+
+  for (const relative of componentRelatives) {
+    const absolute = path.resolve(config.ui.rootDir, relative);
+    // eslint-disable-next-line no-await-in-loop
+    if (await fileExists(absolute)) {
+      presentComponents.push(relative);
+      inputSet.add(absolute);
+    } else {
+      missingComponents.push(relative);
+    }
+  }
+
+  const inputs = Array.from(inputSet).sort();
+
+  const configFile = await resolveConfigFile(
+    configFileOption,
+    path.join(config.rootDir, 'vite.config.js')
+  );
+
+  const baseConfig = {
+    configFile,
+    mode: config.mode,
+    root: config.ui.rootDir,
+    plugins: [
+      clientExcludePlugin(config.ui.clientExclude, { projectRoot: config.rootDir })
+    ],
+    build: {
+      outDir,
+      emptyOutDir,
+      manifest,
+      assetsDir: '',
+      ssr,
+      rollupOptions: {
+        input: inputs,
+        preserveEntrySignatures: 'strict',
+        output: {
+          entryFileNames: createEntryFileNames(context, entryResolved),
+          chunkFileNames: 'chunks/[name]-[hash].js',
+          assetFileNames: 'chunks/[name]-[hash][extname]'
+        }
+      }
+    }
+  };
+
+  let finalConfig = baseConfig;
+  if (overrideOption) {
+    finalConfig = await mergeViteConfig(context, baseConfig, overrideOption);
+  }
+
+  finalConfig.configFile = configFile;
+  finalConfig.mode = config.mode;
+  finalConfig.root = config.ui.rootDir;
+  finalConfig.plugins = ensureExcludePlugin(finalConfig.plugins, config);
+
+  finalConfig.build = finalConfig.build || {};
+  finalConfig.build.outDir = outDir;
+  finalConfig.build.emptyOutDir = emptyOutDir;
+  finalConfig.build.manifest = manifest;
+  finalConfig.build.assetsDir = '';
+  finalConfig.build.ssr = ssr;
+
+  finalConfig.build.rollupOptions = finalConfig.build.rollupOptions || {};
+  finalConfig.build.rollupOptions.input = inputs;
+  finalConfig.build.rollupOptions.preserveEntrySignatures = 'strict';
+
+  const output = finalConfig.build.rollupOptions.output || {};
+  output.entryFileNames = createEntryFileNames(context, entryResolved);
+  output.chunkFileNames = 'chunks/[name]-[hash].js';
+  output.assetFileNames = 'chunks/[name]-[hash][extname]';
+  finalConfig.build.rollupOptions.output = output;
+
+  return {
+    config: finalConfig,
+    entryAbsolute: entryResolved,
+    inputs,
+    components: presentComponents,
+    missing: missingComponents
+  };
+}
+
+function ensureExcludePlugin(plugins, config) {
+  let list = Array.isArray(plugins) ? [...plugins] : (plugins ? [plugins] : []);
+  const hasPlugin = list.some((plugin) => plugin?.name === 'hammer-client-exclude');
+  if (!hasPlugin) {
+    list.unshift(
+      clientExcludePlugin(config.ui.clientExclude, { projectRoot: config.rootDir })
+    );
+  }
+  return list;
+}
+
+function createEntryFileNames(context, entryResolved) {
+  const { config } = context;
+  const entryPath = entryResolved ? path.resolve(entryResolved) : null;
+  return (chunkInfo) => {
+    const facade = chunkInfo.facadeModuleId
+      ? path.resolve(chunkInfo.facadeModuleId)
+      : null;
+    if (facade && entryPath && facade === entryPath) {
+      return `${chunkInfo.name}-[hash].js`;
+    }
+    if (facade) {
+      const relToUi = path.relative(config.ui.rootDir, facade);
+      if (!relToUi.startsWith('..')) {
+        return toOutputPath(relToUi);
+      }
+      const relToRoot = path.relative(config.rootDir, facade);
+      if (!relToRoot.startsWith('..')) {
+        return toOutputPath(relToRoot);
+      }
+    }
+    return `chunks/${chunkInfo.name}-[hash].js`;
+  };
+}
+
+function toOutputPath(relativePath) {
+  const normalized = toPosix(relativePath);
+  if (/\.(svelte|ts|tsx|js|mjs)$/.test(normalized)) {
+    return normalized.replace(/\.(svelte|ts|tsx|js|mjs)$/, '.js');
+  }
+  return normalized;
+}
+
+function toPosix(value) {
+  return value.split(path.sep).join('/');
+}

package/src/build/vite.js

@@ -0,0 +1,45 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+let cachedModule = null;
+
+async function getViteModule(context) {
+  if (cachedModule) {
+    return cachedModule;
+  }
+  const resolved = context.requireFromRoot.resolve('vite');
+  cachedModule = await import(pathToFileURL(resolved).href);
+  return cachedModule;
+}
+
+export async function buildWithVite(context, inlineConfig) {
+  const vite = await getViteModule(context);
+  return vite.build(inlineConfig);
+}
+
+export async function mergeViteConfig(context, baseConfig, overrideConfig) {
+  if (!overrideConfig) return baseConfig;
+  const vite = await getViteModule(context);
+  return vite.mergeConfig(baseConfig, overrideConfig);
+}
+
+export async function loadUserViteConfig(context, configFile, command) {
+  if (!configFile) return null;
+  const vite = await getViteModule(context);
+  const result = await vite.loadConfigFromFile(
+    {
+      command,
+      mode: context.config.mode
+    },
+    configFile,
+    context.config.rootDir
+  );
+  return result?.config ?? null;
+}
+
+export function toRelativeInput(filePath, rootDir) {
+  if (!filePath) return null;
+  const absolute = path.resolve(filePath);
+  const relative = path.relative(rootDir, absolute);
+  return relative.split(path.sep).join('/');
+}

package/src/cli.js

@@ -0,0 +1,72 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import process from 'node:process';
+
+import { parseCliArgs, printHelpAndExit } from './args.js';
+import { loadBuildConfig } from './config.js';
+import { runBuild } from './commands/build.js';
+import { runServe } from './commands/serve.js';
+import { runPreview } from './commands/preview.js';
+
+async function main() {
+  try {
+    const { command, options } = parseCliArgs(process.argv.slice(2));
+
+    if (options.help || !command) {
+      printHelpAndExit();
+    }
+
+    if (options.version) {
+      const packageJson = await loadOwnPackage();
+      process.stdout.write(`${packageJson.version}\n`);
+      process.exit(0);
+    }
+
+    switch (command) {
+      case 'build': {
+        const config = await loadBuildConfig(options, { cwd: process.cwd() });
+        await runBuild(config);
+        break;
+      }
+      case 'serve': {
+        const config = await loadBuildConfig(options, { cwd: process.cwd() });
+        await runServe(config);
+        break;
+      }
+      case 'preview': {
+        const config = await loadBuildConfig(options, { cwd: process.cwd() });
+        await runPreview(config);
+        break;
+      }
+      default:
+        throw cliError(`Unknown command "${command}"`);
+    }
+  } catch (error) {
+    if (error?.code === 'CLI_USAGE') {
+      process.stderr.write(`app: ${error.message}\n`);
+      process.stderr.write(`Run "app --help" for usage.\n`);
+      process.exitCode = 1;
+      return;
+    }
+
+    process.stderr.write(`[app] ${error?.message || error}\n`);
+    if (process.env.APP_DEBUG || process.env.HAMMER_DEBUG) {
+      console.error(error);
+    }
+    process.exitCode = 1;
+  }
+}
+
+async function loadOwnPackage() {
+  const pkgPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..', 'package.json');
+  const content = await readFile(pkgPath, 'utf8');
+  return JSON.parse(content);
+}
+
+function cliError(message) {
+  const error = new Error(message);
+  error.code = 'CLI_USAGE';
+  return error;
+}
+
+await main();

package/src/commands/build.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { createBuildContext } from '../build/context.js';
+import { buildServer } from '../build/server.js';
+import { discoverProject } from '../build/openapi.js';
+import { buildClient } from '../build/client.js';
+import { buildClientModules } from '../build/client-modules.js';
+import { buildSsr } from '../build/ssr.js';
+import { rewriteHtmlTemplate } from '../build/html.js';
+import { writeRuntimeManifest } from '../build/runtime-manifest.js';
+import { generateBootstrap } from '../build/bootstrap.js';
+
+export async function runBuild(config) {
+  const context = createBuildContext(config);
+  const { logger } = context;
+
+  await prepareWorkspace(context);
+  const discovery = await discoverProject(context);
+  const serverArtifacts = await buildServer(context, discovery);
+  const clientArtifacts = await buildClient(context, discovery);
+  await buildClientModules(context, discovery);
+  await rewriteHtmlTemplate(context, clientArtifacts);
+  const ssrArtifacts = await buildSsr(context, discovery);
+  const runtimeManifestPath = await writeRuntimeManifest(context, {
+    discovery,
+    server: serverArtifacts || {},
+    client: clientArtifacts,
+    ssr: ssrArtifacts
+  });
+
+  logger.info(`Runtime manifest: ${path.relative(config.rootDir, runtimeManifestPath)}`);
+  logger.info(`Client manifest: ${path.relative(config.outDir, clientArtifacts.manifestPath)}`);
+  if (ssrArtifacts.manifestPath) {
+    logger.info(`SSR manifest: ${path.relative(config.outDir, ssrArtifacts.manifestPath)}`);
+  }
+
+  await generateBootstrap(context);
+
+  logger.info('Build complete');
+}
+
+async function prepareWorkspace(context) {
+  const { config, logger } = context;
+  const { outDir, layout, rootDir } = config;
+
+  if (path.resolve(outDir) === path.resolve(rootDir)) {
+    throw new Error('Refusing to clean output: --out resolves to project root');
+  }
+
+  logger.info(`Cleaning output directory ${outDir}`);
+  await fs.rm(outDir, { recursive: true, force: true });
+  await fs.mkdir(layout.tempDir, { recursive: true });
+  await fs.mkdir(layout.serverOutDir, { recursive: true });
+  await fs.mkdir(layout.middlewareOutDir, { recursive: true });
+  await fs.mkdir(layout.clientOutDir, { recursive: true });
+  await fs.mkdir(layout.uiOutDir, { recursive: true });
+  await fs.mkdir(layout.ssrOutDir, { recursive: true });
+}

package/src/commands/preview.js

@@ -0,0 +1,33 @@
+import util from 'node:util';
+
+import { createBuildContext } from '../build/context.js';
+import { discoverProject } from '../build/openapi.js';
+import { resolveClientBuildConfig } from '../build/client.js';
+import { resolveClientModulesConfig } from '../build/client-modules.js';
+import {
+  resolveSsrBuildConfig,
+  resolveRecursiveRendererBuildConfig
+} from '../build/ssr.js';
+
+const INSPECT_OPTIONS = { depth: null, colors: false };
+
+function printSection(heading, payload) {
+  console.log(`========== ${heading} ==========`);
+  console.log(util.inspect(payload, INSPECT_OPTIONS));
+  console.log();
+}
+
+export async function runPreview(config) {
+  const context = createBuildContext(config);
+  const discovery = await discoverProject(context);
+
+  const client = await resolveClientBuildConfig(context, discovery);
+  const clientModules = await resolveClientModulesConfig(context, discovery);
+  const ssr = await resolveSsrBuildConfig(context, discovery);
+  const recursive = await resolveRecursiveRendererBuildConfig(context);
+
+  printSection('UI CSR', client.config);
+  printSection('UI SSR', ssr.config);
+  printSection('Recursive Renderer CSR', clientModules.config);
+  printSection('Recursive Renderer SSR', recursive?.printableConfig ?? recursive?.config ?? recursive);
+}