@noego/forge 0.0.11 → 0.0.13

package/dist-ssr/server.cjs

@@ -26,36 +26,27 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const express = require("express");
 const path = require("path");
-const deepmerge = require("deepmerge");
 const fs = require("fs");
+const deepmerge = require("deepmerge");
+const url = require("url");
 const Handlebars = require("handlebars");
 const fs$1 = require("fs/promises");
 const yaml = require("js-yaml");
 require("clone-deep");
 const join = require("url-join");
 const path$1 = require("./path-sxXxpB6R.cjs");
-const url = require("url");
 const server = require("svelte/server");
 const pathToRegex = require("path-to-regex");
-const ApplicationRenderer = require("../src/components/RecursiveRender.svelte");
 class ViteComponentLoader {
   constructor(basePath, vite) {
     this.basePath = basePath;
     this.vite = vite;
   }
   async load(componentPath, options = { use_base_path: true }) {
-    let absoluteComponentPath;
-    const use_base_path = options.use_base_path || false;
-    if (use_base_path) {
-      absoluteComponentPath = path.join(this.basePath, componentPath);
-    } else {
-      if (path.isAbsolute(componentPath)) {
-        absoluteComponentPath = componentPath;
-      } else {
-        absoluteComponentPath = componentPath;
-      }
-    }
+    const absoluteComponentPath = this.getComponentFullPath(componentPath, options);
     console.log(`[ViteComponentLoader] Loading component from path: ${absoluteComponentPath}`);
+    const jsPath = absoluteComponentPath.replace(/\.svelte$/, ".js");
+    fs.existsSync(jsPath);
     let vitePath = path.relative(process.cwd(), absoluteComponentPath);
     vitePath = vitePath.replace(/\\/g, "/");
     if (!vitePath.startsWith("/")) {
@@ -80,16 +71,74 @@ class ViteComponentLoader {
       throw error;
     }
   }
+  getComponentFullPath(componentPath, options = { use_base_path: true }) {
+    const use_base_path = options.use_base_path || false;
+    if (use_base_path) {
+      return path.join(this.basePath, componentPath);
+    }
+    if (path.isAbsolute(componentPath)) {
+      return componentPath;
+    }
+    return componentPath;
+  }
 }
 class ProdComponentLoader {
   constructor(base_path) {
+    __publicField(this, "componentMapPromise", null);
     this.base_path = base_path;
   }
   async load(componentPath) {
-    const component_path = path.join(this.base_path, componentPath);
-    const module2 = await import(component_path.replace(/\.svelte$/, ".js"));
+    const normalized = this.normalizeKey(componentPath);
+    try {
+      const map = await this.loadComponentMap();
+      const module22 = map[normalized];
+      if (module22) {
+        return module22;
+      }
+    } catch (error) {
+      console.warn(`[Forge] Failed to load component "${componentPath}" from entry manifest:`, error);
+    }
+    const component_path = this.getComponentFullPath(componentPath);
+    const fallbackPath = component_path.endsWith(".js") ? component_path : component_path.replace(/\.svelte$/, ".js");
+    const module2 = await import(url.pathToFileURL(fallbackPath).href);
     return module2;
   }
+  getComponentFullPath(componentPath) {
+    return path.join(this.base_path, componentPath);
+  }
+  normalizeKey(componentPath) {
+    const trimmed = componentPath.replace(/^\.\//, "");
+    if (trimmed.endsWith(".svelte")) {
+      return trimmed.replace(/\.svelte$/, ".js");
+    }
+    return trimmed;
+  }
+  async loadComponentMap() {
+    if (!this.componentMapPromise) {
+      const entryPath = path.join(this.base_path, "entry-ssr.js");
+      const entryUrl = url.pathToFileURL(entryPath).href;
+      this.componentMapPromise = import(entryUrl).then((mod) => {
+        const source = mod.components ?? mod.default ?? {};
+        const normalized = {};
+        for (const [key, value] of Object.entries(source)) {
+          const cleanKey = key.replace(/^\.\//, "");
+          normalized[cleanKey] = value;
+          if (cleanKey.startsWith("ui/")) {
+            normalized[cleanKey.slice(3)] = value;
+          }
+          if (cleanKey.endsWith(".svelte")) {
+            const jsKey = cleanKey.replace(/\.svelte$/, ".js");
+            normalized[jsKey] = value;
+          }
+        }
+        return normalized;
+      }).catch((error) => {
+        this.componentMapPromise = null;
+        throw error;
+      });
+    }
+    return this.componentMapPromise;
+  }
 }
 const default_template = `
 <!DOCTYPE html>
@@ -280,11 +329,9 @@ async function parse_openapi_config(openapi_config_path) {
 const defaultViteOptions = {
   appType: "custom",
   root: process.cwd(),
-  // Explicitly set root
   server: { middlewareMode: true },
   ssr: {
     noExternal: ["svelte", /^svelte\/.*/]
-    // Adjust if needed, maybe add your component specifically if still failing
   }
 };
 const defaultOptions = {
@@ -372,7 +419,7 @@ class ApiAdapter {
       layout: layout_data,
       view: view_data
     };
-    return server_data;
+    return this.mergeLoaderData(route, request_data, server_data);
   }
   async getFallbackData(route, request_data) {
     const view = await this.manager.getViewComponent(route);
@@ -397,7 +444,48 @@ class ApiAdapter {
       layout: layout_data,
       view: view_data
     };
-    return server_data;
+    return this.mergeLoaderData(route, request_data, server_data);
+  }
+  async mergeLoaderData(route, request_data, server_data) {
+    if (!await this.manager.hasLoaders(route)) {
+      return server_data;
+    }
+    const loaders = await this.manager.getLoaders(route);
+    const layoutLoaderResults = await Promise.all(
+      loaders.layouts.map(async (loader) => {
+        if (!loader) {
+          return null;
+        }
+        const data = await loader(request_data);
+        return data ?? null;
+      })
+    );
+    const baseLayoutData = server_data.layout || [];
+    const maxLayouts = Math.max(baseLayoutData.length, layoutLoaderResults.length);
+    const mergedLayouts = Array.from({ length: maxLayouts }, (_, index) => {
+      const baseLayoutEntry = baseLayoutData[index];
+      const loaderResult = layoutLoaderResults[index];
+      if (!loaderResult) {
+        return baseLayoutEntry;
+      }
+      if (baseLayoutEntry && typeof baseLayoutEntry === "object") {
+        return { ...baseLayoutEntry, ...loaderResult };
+      }
+      return loaderResult;
+    });
+    const viewLoaderResult = loaders.view ? await loaders.view(request_data) : null;
+    let mergedView = server_data.view;
+    if (viewLoaderResult) {
+      if (mergedView && typeof mergedView === "object") {
+        mergedView = { ...mergedView, ...viewLoaderResult };
+      } else {
+        mergedView = viewLoaderResult;
+      }
+    }
+    return {
+      layout: mergedLayouts,
+      view: mergedView
+    };
   }
 }
 class ComponentManager {
@@ -430,6 +518,50 @@ class ComponentManager {
   async getViewComponent(route) {
     return await this.componentLoader.load(route.view);
   }
+  async hasLoaders(route) {
+    const componentPaths = [...route.layout || [], route.view];
+    for (const componentPath of componentPaths) {
+      const loader = await this.resolveLoader(componentPath);
+      if (loader) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async getLoaders(route) {
+    const layoutPaths = route.layout || [];
+    const layouts = await Promise.all(layoutPaths.map((layoutPath) => this.resolveLoader(layoutPath)));
+    const view = await this.resolveLoader(route.view);
+    return {
+      layouts,
+      view
+    };
+  }
+  getLoaderFilePath(componentPath) {
+    if (!componentPath) {
+      return null;
+    }
+    const fullPath = this.componentLoader.getComponentFullPath(componentPath);
+    const { dir, name } = path.parse(fullPath);
+    return path.join(dir, `${name}.load.ts`);
+  }
+  async resolveLoader(componentPath) {
+    const loaderFilePath = this.getLoaderFilePath(componentPath);
+    if (!loaderFilePath) {
+      return null;
+    }
+    try {
+      const module2 = await import(url.pathToFileURL(loaderFilePath).href);
+      const loader = module2 == null ? void 0 : module2.default;
+      return typeof loader === "function" ? loader : null;
+    } catch (error) {
+      if ((error == null ? void 0 : error.code) === "MODULE_NOT_FOUND" || (error == null ? void 0 : error.code) === "ERR_MODULE_NOT_FOUND") {
+        return null;
+      }
+      console.error(`[ComponentManager] Failed to load loader for ${componentPath}:`, error);
+      return null;
+    }
+  }
   async getView(route) {
     const view = await this.componentLoader.load(route.view);
     return view.default;
@@ -634,8 +766,9 @@ function initialize_route_matchers(routes) {
 class ServerAdapter {
 }
 class ExpressServerAdapter extends ServerAdapter {
-  constructor(server2, manager, htmlRender, api_adapter, middleware_adapter, context_builder, isProd = false) {
+  constructor(server2, manager, htmlRender, api_adapter, middleware_adapter, context_builder, isProd = false, componentDir) {
     super();
+    __publicField(this, "clientRoutes", []);
     this.server = server2;
     this.manager = manager;
     this.htmlRender = htmlRender;
@@ -643,6 +776,27 @@ class ExpressServerAdapter extends ServerAdapter {
     this.middleware_adapter = middleware_adapter;
     this.context_builder = context_builder;
     this.isProd = isProd;
+    this.componentDir = componentDir;
+  }
+  async loadApplicationRenderer(componentRoot) {
+    if (!this.isProd) {
+      const mod = await import("../src/components/RecursiveRender.svelte");
+      return mod.default ?? mod;
+    }
+    const candidates = [
+      path.join(componentRoot, "RecursiveRender.js"),
+      path.join(componentRoot, "ssr", "RecursiveRender.js")
+    ];
+    let lastError;
+    for (const fp of candidates) {
+      try {
+        const mod = await import(fp);
+        return mod.default ?? mod;
+      } catch (e) {
+        lastError = e;
+      }
+    }
+    throw lastError ?? new Error("Unable to locate precompiled RecursiveRender.js");
   }
   transformRoutesForClient(routes) {
     var _a, _b;
@@ -660,7 +814,9 @@ class ExpressServerAdapter extends ServerAdapter {
     return transformed;
   }
   async handleRoutes(routes, manifest) {
-    const matchers = initialize_route_matchers(routes);
+    const transformedRoutes = this.transformRoutesForClient(routes);
+    this.clientRoutes = transformedRoutes;
+    const matchers = initialize_route_matchers(transformedRoutes);
     this.server.use((req, res, next) => {
       (async () => {
         if (res.headersSent) {
@@ -677,13 +833,13 @@ class ExpressServerAdapter extends ServerAdapter {
           await not_found();
           return;
         }
-        const route_options = routes.filter((r) => r.path === matcher.pattern);
+        const route_options = transformedRoutes.filter((r) => r.path === matcher.pattern);
         const route = route_options.find((r) => r.method.toLowerCase() === method);
         if (!route) {
           await not_found();
           return;
         }
-        await this.handleResponse(fullUrl, matcher, route, routes, manifest, req, res).catch((e) => {
+        await this.handleResponse(fullUrl, matcher, route, transformedRoutes, manifest, req, res).catch((e) => {
           res.status(500).send(`
                         <h1>500 Internal Server Error</h1>
                         <pre>${e}</pre>
@@ -694,7 +850,7 @@ class ExpressServerAdapter extends ServerAdapter {
     });
   }
   async handleResponse(url2, matcher, route, routes, manifest, req, res) {
-    var _a, _b;
+    var _a, _b, _c;
     let accepts = req.headers.accept || "";
     let server_api_call = accepts.toLowerCase().includes("application/json");
     if (res.headersSent) {
@@ -768,7 +924,12 @@ ${e.stack}</pre>
         params: request_data.params || {},
         query: request_data.query
       };
-      let { head: head_render, body: body_render, css } = server.render(ApplicationRenderer, {
+      console.log("[SSR DEBUG] layouts:", layouts.map((l) => typeof l), "view:", typeof view);
+      const loader = ((_a = this.manager) == null ? void 0 : _a["componentLoader"]) || {};
+      const componentRoot = loader["base_path"] || loader["basePath"] || "";
+      const applicationRenderer = await this.loadApplicationRenderer(componentRoot);
+      console.log("[SSR DEBUG] applicationRenderer:", typeof applicationRenderer);
+      const { head: head_render, html: renderedHtml, css } = server.render(applicationRenderer, {
         props: {
           layouts,
           view,
@@ -779,9 +940,12 @@ ${e.stack}</pre>
           page
         }
       });
+      const body_render = renderedHtml;
+      console.log("[SSR DEBUG] render result - body length:", (body_render == null ? void 0 : body_render.length) || 0);
+      const clientComponentDir = this.isProd ? "assets" : this.componentDir;
       const head_routing = `
             <script type='text/javascript'>
-            window.__ROUTING__ = ${JSON.stringify(this.transformRoutesForClient(routes))}
+            window.__ROUTING__ = ${JSON.stringify(this.clientRoutes)}
             <\/script>
 
             <script type='text/javascript'>
@@ -791,16 +955,22 @@ ${e.stack}</pre>
             <script type='text/javascript'>
             window.__INITIAL_DATA__ = ${JSON.stringify(server_data || {}).trim()}
             <\/script>
+
+            <script type='text/javascript'>
+            window.__COMPONENT_DIR__ = ${JSON.stringify(clientComponentDir)}
+            <\/script>
             `;
+      console.log("[SSR DEBUG] About to render HTML with APP length:", (body_render == null ? void 0 : body_render.length) || 0);
       html_render = await this.htmlRender.renderHTML({
         HEAD: head_routing + (head_render || ""),
         CSS: css,
         APP: body_render
       });
+      console.log("[SSR DEBUG] Final HTML length:", (html_render == null ? void 0 : html_render.length) || 0, "contains APP div:", html_render == null ? void 0 : html_render.includes('<div id="app">'));
     } catch (e) {
       response_code = 500;
       const new_body = `<pre>Error rendering HTML:
-${e}` + (((_a = route.layout) == null ? void 0 : _a.length) ? `layouts: ${(_b = route.layout) == null ? void 0 : _b.join(",\n")}` : "") + `
+${e}` + (((_b = route.layout) == null ? void 0 : _b.length) ? `layouts: ${(_c = route.layout) == null ? void 0 : _c.join(",\n")}` : "") + `
 view: ${route.view}</pre>`;
       html_render = await this.htmlRender.renderHTML({
         APP: new_body
@@ -812,6 +982,7 @@ view: ${route.view}</pre>`;
     res.end(html_render);
   }
   async handleFallback(req, res, server_config) {
+    var _a;
     if (res.headersSent) {
       console.log("Reply already sent");
       return;
@@ -852,7 +1023,10 @@ view: ${route.view}</pre>`;
     const view = await this.manager.getView(route);
     console.log("Fallback view", view);
     console.log("Fallback layouts", layouts);
-    let { head: head_render, body: body_render, css } = server.render(ApplicationRenderer, {
+    const loader = ((_a = this.manager) == null ? void 0 : _a["componentLoader"]) || {};
+    const componentRoot = loader["base_path"] || loader["basePath"] || "";
+    const applicationRenderer = await this.loadApplicationRenderer(componentRoot);
+    let { head: head_render, html, css } = server.render(applicationRenderer, {
       props: {
         layouts,
         view,
@@ -860,6 +1034,7 @@ view: ${route.view}</pre>`;
         params: request_data.params
       }
     });
+    const body_render = html;
     const html_render = await this.htmlRender.renderHTML({
       HEAD: head_render,
       CSS: css,
@@ -868,21 +1043,53 @@ view: ${route.view}</pre>`;
     res.type("text/html").status(404).send(html_render);
   }
 }
+function pathExistsSync(p) {
+  try {
+    return fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+function resolveRuntimeRoot(candidate) {
+  var _a;
+  const envRoot = process.env.FORGE_ROOT;
+  if (envRoot && path.isAbsolute(envRoot) && pathExistsSync(envRoot)) {
+    return path.normalize(envRoot);
+  }
+  if (candidate && path.isAbsolute(candidate) && pathExistsSync(candidate)) {
+    return path.normalize(candidate);
+  }
+  const entry = (_a = process.argv) == null ? void 0 : _a[1];
+  if (entry) {
+    const entryDir = path.dirname(path.resolve(entry));
+    if (pathExistsSync(entryDir)) return entryDir;
+  }
+  return process.cwd();
+}
 async function createServer(app, options) {
+  var _a;
   options = options || defaultOptions;
   const full_options = deepmerge(defaultOptions, options);
   full_options.open_api_path = ensureFullPath(full_options.viteOptions.root, full_options.open_api_path);
-  const isProd = full_options.development === false;
-  console.log(`Running in ${isProd ? "production" : "development"} mode (development flag: ${full_options.development}, NODE_ENV: ${process.env.NODE_ENV})`);
-  const COMPONENT_DIR = !full_options.component_dir ? full_options.viteOptions.root : path.join(full_options.viteOptions.root, full_options.component_dir);
-  const root = full_options.viteOptions.root;
+  const root = resolveRuntimeRoot((_a = full_options.viteOptions) == null ? void 0 : _a.root);
+  const COMPONENT_DIR = !full_options.component_dir ? root : path.join(root, full_options.component_dir);
+  const isBuiltEnvironment = process.env.FORGE_BUILT === "true";
+  const isProd = isBuiltEnvironment || full_options.development === false;
+  console.log(`Running in ${isProd ? "production" : "development"} mode (built environment: ${isBuiltEnvironment}, development flag: ${full_options.development}, NODE_ENV: ${process.env.NODE_ENV})`);
   let componentLoader;
   let vite;
   console.log(`Serving components from ${COMPONENT_DIR}`);
+  const rendererFullPath = typeof full_options.renderer === "string" && full_options.renderer !== "default" ? ensureFullPath(root, full_options.renderer) : ensureFullPath(root, "index.html");
+  path.dirname(rendererFullPath);
+  const resolveAssetRoot = (entry) => {
+    if (!entry || typeof entry !== "string") return root;
+    const cleaned = entry.replace(/^\/+/, "");
+    return path.resolve(root, cleaned);
+  };
   if (full_options.assets) {
     for (const [asset_path, asset_dir] of Object.entries(full_options.assets)) {
       for (const asset of asset_dir) {
-        const asset_root = path.join(full_options.viteOptions.root, asset);
+        const asset_root = resolveAssetRoot(asset);
         app.use(asset_path, express.static(asset_root));
         console.log(`Serving assets from ${asset_root} at ${asset_path}`);
       }
@@ -899,8 +1106,16 @@ ${JSON.stringify(options, null, 2)}`);
     componentLoader = new ViteComponentLoader(COMPONENT_DIR, vite);
   } else {
     console.log("Starting Vite in production mode...");
-    app.use("/", express.static(path.join(full_options.viteOptions.root, full_options.build_dir)));
-    console.log(`Serving static files from ${path.join(full_options.viteOptions.root, full_options.build_dir)} at /`);
+    const staticDir = path.join(full_options.viteOptions.root, full_options.build_dir);
+    if (pathExistsSync(staticDir)) {
+      app.use("/", express.static(staticDir));
+      console.log(`Serving static files from ${staticDir} at /`);
+    } else {
+      console.log(`Skipping static file serving (build_dir ${staticDir} not found - using asset configuration)`);
+    }
+    const componentPath = `/${full_options.component_dir}`;
+    app.use(componentPath, express.static(COMPONENT_DIR));
+    console.log(`Serving components at ${componentPath} from ${COMPONENT_DIR}`);
     componentLoader = new ProdComponentLoader(COMPONENT_DIR);
   }
   const manifest = await new ManifestBuilder(
@@ -925,7 +1140,8 @@ ${JSON.stringify(options, null, 2)}`);
     api_adapter,
     middleware_adapter,
     full_options.context_builder,
-    isProd
+    isProd,
+    full_options.component_dir
   );
   await adapter.handleRoutes(routeDefs, manifest);
   console.log("Routes registered");