@noego/forge 0.0.7 → 0.0.9

package/dist-ssr/server.cjs

@@ -33,7 +33,8 @@ const fs$1 = require("fs/promises");
 const yaml = require("js-yaml");
 require("clone-deep");
 const join = require("url-join");
-const path$1 = require("./path-CyGuWUeq.cjs");
+const path$1 = require("./path-Dm_4PXDW.cjs");
+const url = require("url");
 const server = require("svelte/server");
 const pathToRegex = require("path-to-regex");
 const ApplicationRenderer = require("../src/components/RecursiveRender.svelte");
@@ -140,6 +141,23 @@ class LiveHTMLRender {
     return file_content;
   }
 }
+const HTTP_METHODS = /* @__PURE__ */ new Set([
+  "get",
+  "post",
+  "put",
+  "delete",
+  "patch",
+  "head",
+  "options",
+  "trace"
+]);
+function getGlobalPathsMiddleware(openapi) {
+  if (!openapi || !openapi.paths) {
+    return [];
+  }
+  const value = openapi.paths["x-middleware"];
+  return Array.isArray(value) ? [...value] : [];
+}
 function parseConfigfile(file_content) {
   let config = null;
   try {
@@ -149,7 +167,7 @@ function parseConfigfile(file_content) {
   }
   return config;
 }
-function parse_modules(openapi) {
+function parse_modules(openapi, inheritedMiddleware = []) {
   const modules_config = openapi.modules || openapi.module;
   if (!modules_config) {
     return;
@@ -157,16 +175,20 @@ function parse_modules(openapi) {
   const modules = Object.entries(modules_config).map(([_, module2]) => {
     return module2;
   });
+  const globalMiddleware = [...inheritedMiddleware, ...getGlobalPathsMiddleware(openapi)];
   const modules_path = modules.map((module2) => {
     const basePath = module2.basePath || "";
     const baseLayouts = module2.baseLayouts || [];
+    const moduleMiddleware = Array.isArray(module2["x-middleware"]) ? module2["x-middleware"] : [];
+    const inherited = [...globalMiddleware, ...moduleMiddleware];
     const paths = module2.paths;
     if (!paths) {
       return;
     }
-    const configurations = Object.entries(paths).map(([path2, method_config]) => {
-      return Object.entries(method_config).map(([method, config]) => {
-        return path$1.parsePathConfig(path2, method, config);
+    const configurations = Object.entries(paths).filter(([path2]) => typeof path2 === "string" && path2.startsWith("/")).map(([path2, method_config]) => {
+      return Object.entries(method_config).filter(([method]) => HTTP_METHODS.has(String(method).toLowerCase())).map(([method, config]) => {
+        const methodName = String(method);
+        return path$1.parsePathConfig(path2, methodName, config, inherited);
       });
     });
     const routes = configurations.reduce((flat_config, config) => {
@@ -180,19 +202,24 @@ function parse_modules(openapi) {
   });
   return modules_path.reduce(
     (flat_config, config) => {
+      if (!config) {
+        return flat_config;
+      }
       return flat_config.concat(config);
     },
     []
   );
 }
-function parse_paths(openapi) {
+function parse_paths(openapi, inheritedMiddleware = []) {
   const paths = openapi.paths;
   if (!paths) {
     return;
   }
-  const configurations = Object.entries(paths).map(([path2, method_config]) => {
-    return Object.entries(method_config).map(([method, config]) => {
-      return path$1.parsePathConfig(path2, method, config);
+  const globalMiddleware = [...inheritedMiddleware, ...getGlobalPathsMiddleware(openapi)];
+  const configurations = Object.entries(paths).filter(([path2]) => typeof path2 === "string" && path2.startsWith("/")).map(([path2, method_config]) => {
+    return Object.entries(method_config).filter(([method]) => HTTP_METHODS.has(String(method).toLowerCase())).map(([method, config]) => {
+      const methodName = String(method);
+      return path$1.parsePathConfig(path2, methodName, config, globalMiddleware);
     });
   });
   const routes = configurations.reduce((flat_config, config) => {
@@ -232,13 +259,16 @@ async function parse_openapi_config(openapi_config_path) {
   } else {
     throw new Error(`Invalid OpenAPI or stitch configuration file: ${openapi_config_path}. File must contain either 'stitch', 'paths', 'module', or 'modules' at the root level.`);
   }
+  const globalPathsMiddleware = getGlobalPathsMiddleware(openapi_config);
   let modules = parse_modules(openapi_config) || [];
   let paths = parse_paths(openapi_config) || [];
   let fallback_layout = openapi_config["x-fallback-layout"] || null;
   let fallback_view = openapi_config["x-fallback-view"] || null;
+  const fallback_middleware = Array.isArray(openapi_config["x-fallback-middleware"]) ? [...openapi_config["x-fallback-middleware"]] : [...globalPathsMiddleware];
   let fallback = {
     layout: fallback_layout ? [fallback_layout] : [],
-    view: fallback_view
+    view: fallback_view,
+    middleware: fallback_middleware
   };
   const routes = [...modules, ...paths];
   let config = {
@@ -264,7 +294,8 @@ const defaultOptions = {
   build_dir: "dist_ssr",
   renderer: "default",
   open_api_path: path.join(process.cwd(), "openapi.yaml"),
-  manifest_endpoint: "/manifest.json"
+  manifest_endpoint: "/manifest.json",
+  middleware_path: void 0
 };
 class ManifestBuilder {
   constructor(openapi_path, loader, options) {
@@ -404,61 +435,186 @@ class ComponentManager {
     return view.default;
   }
 }
+const EXTENSION_CANDIDATES = [".js", ".mjs", ".cjs", ".ts", ".tsx"];
 class MiddlewareAdapter {
-  constructor(manager) {
-    this.manager = manager;
+  constructor(middlewarePath, fallbackPath) {
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    this.middlewarePath = middlewarePath;
+    this.fallbackPath = fallbackPath;
   }
-  async handleMiddleware(req, reply, route, request_data, callback) {
-    let components = await this.manager.getLayoutComponents(route);
-    let middleware_stack = await Promise.all(components.map(async (component) => {
-      const middleware = [...component.middleware || [], ...component.middlewares || []];
-      return middleware;
-    }));
-    const layout_middlewares = middleware_stack.flat() || [];
-    console.log("middleware stack loaded", layout_middlewares);
-    req.params = request_data.params;
-    await new Promise((resolve) => {
-      this.runMiddleware(layout_middlewares, req, reply, resolve);
-    });
-    console.log("layout middleware executed");
-    console.log("view middleware loaded");
-    console.log("view middleware", route.view);
-    let view = {};
-    if (route.view) {
-      view = await this.manager.getViewComponent(route);
-    }
-    let view_middlewares = [...view.middleware || [], ...view.middlewares || []];
-    await new Promise((resolve) => {
-      this.runMiddleware(view_middlewares, req, reply, resolve);
-    });
-    callback();
+  static build(middlewarePath, fallbackPath) {
+    return new MiddlewareAdapter(middlewarePath, fallbackPath);
   }
-  runMiddleware(middleware, req, reply, callback) {
-    middleware = this.dedupe(middleware);
-    let index = 0;
-    if (middleware.length === 0) {
-      callback();
+  async handleMiddleware(req, res, middlewareConfig = []) {
+    if (!Array.isArray(middlewareConfig) || middlewareConfig.length === 0) {
       return;
     }
-    let next = () => {
-      if (index >= middleware.length) {
-        callback();
-        return;
+    const resolution = await this.resolveMiddlewareFunctions(middlewareConfig);
+    console.log(resolution);
+    if (resolution.errors.length > 0) {
+      throw new Error(`Middleware resolution failed: ${resolution.errors.join(", ")}`);
+    }
+    for (const middleware of resolution.functions) {
+      await this.executeMiddleware(middleware, req, res);
+      if (res.headersSent) {
+        break;
       }
-      const mw = middleware[index];
-      index++;
-      if (typeof mw === "function") {
-        if (!reply.sent)
-          mw(req, reply, next);
-      } else {
-        if (!reply.sent)
-          next();
+    }
+  }
+  async resolveMiddlewareFunctions(middlewareConfig) {
+    const functions = [];
+    const errors = [];
+    for (const spec of middlewareConfig) {
+      if (!spec) {
+        continue;
       }
+      try {
+        let resolved = this.cache.get(spec);
+        if (!resolved) {
+          resolved = await this.resolveMiddlewareSpec(spec);
+          this.cache.set(spec, [...resolved]);
+        }
+        functions.push(...resolved);
+      } catch (error) {
+        errors.push(`${spec}: ${error.message}`);
+      }
+    }
+    return {
+      functions: this.dedupe(functions),
+      errors
     };
-    next();
   }
-  dedupe(middlewares) {
-    return Array.from(new Set(middlewares));
+  async resolveMiddlewareSpec(spec) {
+    const [filePath, selector] = this.parseMiddlewareSpec(spec);
+    const fullPath = this.resolveMiddlewareFilePath(filePath);
+    const module2 = await this.importMiddlewareModule(fullPath, spec);
+    return this.extractMiddlewareFunctions(module2, selector, spec);
+  }
+  parseMiddlewareSpec(spec) {
+    const colonIndex = spec.indexOf(":");
+    if (colonIndex === -1) {
+      return [spec, void 0];
+    }
+    return [spec.substring(0, colonIndex), spec.substring(colonIndex + 1)];
+  }
+  resolveMiddlewareFilePath(filePath) {
+    const basePath = this.middlewarePath || this.fallbackPath || process.cwd();
+    const transformed = this.middlewareFileTransform(filePath);
+    const baseCandidate = path.resolve(process.cwd(), path.join(basePath, transformed));
+    const resolvedWithExt = this.findExistingFile(baseCandidate);
+    if (resolvedWithExt) {
+      return resolvedWithExt;
+    }
+    throw new Error(`Middleware file not found: ${transformed}`);
+  }
+  middlewareFileTransform(filePath) {
+    return filePath.split(".").join(path.sep);
+  }
+  findExistingFile(basePathWithoutExt) {
+    const ext = path.extname(basePathWithoutExt);
+    if (ext) {
+      return fs.existsSync(basePathWithoutExt) ? basePathWithoutExt : null;
+    }
+    const directCandidates = EXTENSION_CANDIDATES.map((extCandidate) => `${basePathWithoutExt}${extCandidate}`);
+    for (const candidate of directCandidates) {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const indexCandidates = EXTENSION_CANDIDATES.map((extCandidate) => path.join(basePathWithoutExt, `index${extCandidate}`));
+    for (const candidate of indexCandidates) {
+      if (fs.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+  async importMiddlewareModule(fullPath, spec) {
+    try {
+      const url$1 = url.pathToFileURL(fullPath).href;
+      return await import(url$1);
+    } catch (error) {
+      throw new Error(`Unable to import middleware '${spec}' from ${fullPath}`);
+    }
+  }
+  extractMiddlewareFunctions(module2, selector, spec) {
+    if (!selector) {
+      return this.extractDefaultFunction(module2, spec);
+    }
+    if (selector === "*") {
+      return this.extractAllFunctions(module2, spec);
+    }
+    return this.extractSpecificFunctions(module2, selector, spec);
+  }
+  extractDefaultFunction(module2, spec) {
+    if (!(module2 == null ? void 0 : module2.default)) {
+      throw new Error(`Middleware '${spec}' is missing a default export`);
+    }
+    if (typeof module2.default !== "function") {
+      throw new Error(`Default export for middleware '${spec}' is not a function`);
+    }
+    return [module2.default];
+  }
+  extractAllFunctions(module2, spec) {
+    const functions = Object.values(module2).filter((value) => typeof value === "function");
+    if (functions.length === 0) {
+      throw new Error(`No functions exported by middleware '${spec}'`);
+    }
+    return functions;
+  }
+  extractSpecificFunctions(module2, selector, spec) {
+    const names = selector.split(",").map((name) => name.trim()).filter(Boolean);
+    const functions = [];
+    const missing = [];
+    const invalid = [];
+    for (const name of names) {
+      const value = name === "default" ? module2 == null ? void 0 : module2.default : module2 == null ? void 0 : module2[name];
+      if (value === void 0) {
+        missing.push(name);
+        continue;
+      }
+      if (typeof value !== "function") {
+        invalid.push(name);
+        continue;
+      }
+      functions.push(value);
+    }
+    if (missing.length) {
+      throw new Error(`Middleware '${spec}' is missing export(s): ${missing.join(", ")}`);
+    }
+    if (invalid.length) {
+      throw new Error(`Middleware '${spec}' export(s) not functions: ${invalid.join(", ")}`);
+    }
+    if (functions.length === 0) {
+      throw new Error(`Middleware '${spec}' did not resolve any functions for selector '${selector}'`);
+    }
+    return functions;
+  }
+  executeMiddleware(fn, req, res) {
+    return new Promise((resolve, reject) => {
+      try {
+        fn(req, res, (error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  dedupe(functions) {
+    const seen = /* @__PURE__ */ new Set();
+    const ordered = [];
+    for (const fn of functions) {
+      if (!seen.has(fn)) {
+        seen.add(fn);
+        ordered.push(fn);
+      }
+    }
+    return ordered;
   }
 }
 function makeUrlParser(pattern) {
@@ -478,13 +634,14 @@ function initialize_route_matchers(routes) {
 class ServerAdapter {
 }
 class ExpressServerAdapter extends ServerAdapter {
-  constructor(server2, manager, htmlRender, api_adapter, middleware_adapter) {
+  constructor(server2, manager, htmlRender, api_adapter, middleware_adapter, context_builder) {
     super();
     this.server = server2;
     this.manager = manager;
     this.htmlRender = htmlRender;
     this.api_adapter = api_adapter;
     this.middleware_adapter = middleware_adapter;
+    this.context_builder = context_builder;
   }
   async handleRoutes(routes, manifest) {
     const matchers = initialize_route_matchers(routes);
@@ -520,13 +677,20 @@ class ExpressServerAdapter extends ServerAdapter {
       return;
     });
   }
-  async handleResponse(url, matcher, route, routes, manifest, req, res) {
+  async handleResponse(url2, matcher, route, routes, manifest, req, res) {
     var _a, _b;
     let accepts = req.headers.accept || "";
     let server_api_call = accepts.toLowerCase().includes("application/json");
+    if (res.headersSent) {
+      return;
+    }
     const context = {};
+    if (this.context_builder) {
+      const built_context = await this.context_builder(req, res);
+      Object.assign(context, built_context);
+    }
     req["context"] = context;
-    const cleanPath = url.split("?")[0];
+    const cleanPath = url2.split("?")[0];
     const pathParams = matcher.parser(cleanPath);
     const queryParams = {};
     for (const [key, value] of Object.entries(req.query)) {
@@ -540,7 +704,7 @@ class ExpressServerAdapter extends ServerAdapter {
     }
     const combinedParams = { ...pathParams, ...queryParams };
     let request_data = {
-      url,
+      url: url2,
       query: req.query,
       params: combinedParams,
       headers: req.headers,
@@ -548,20 +712,17 @@ class ExpressServerAdapter extends ServerAdapter {
       context
     };
     try {
-      await new Promise((resolve, reject) => {
-        this.middleware_adapter.handleMiddleware(req, res, route, request_data, resolve).catch(reject);
-      });
+      await this.middleware_adapter.handleMiddleware(req, res, route.middleware || []);
     } catch (e) {
       console.log("Error in middleware", e);
       res.status(500).send(`
                 <h1>500 Internal Server Error</h1>
                 <pre>${e}</pre>
+                <pre>Stack Trace:
+${e.stack}</pre>
             `);
       return;
     }
-    if (res.headersSent) {
-      return;
-    }
     let server_data = await this.api_adapter.getApiData(route, request_data);
     if (server_api_call) {
       res.header("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate").header("Pragma", "no-cache").header("Expires", "0").type("application/json").send(server_data);
@@ -577,6 +738,8 @@ class ExpressServerAdapter extends ServerAdapter {
       res.status(500).send(`
                 <h1>500 Internal Server Error</h1>
                 <pre>${e}</pre>
+                <pre>Stack Trace:
+${e.stack}</pre>
             `);
       return;
     }
@@ -640,10 +803,10 @@ view: ${route.view}</pre>`;
     let route = server_config.fallback;
     let accepts = req.headers.accept || "";
     let server_api_call = accepts.toLowerCase().includes("application/json");
-    const url = req.url || "/";
+    const url2 = req.url || "/";
     const context = {};
     let fallback_data = {
-      url,
+      url: url2,
       query: req.query,
       params: {},
       headers: req.headers,
@@ -651,9 +814,16 @@ view: ${route.view}</pre>`;
       context
     };
     let request_data = fallback_data;
-    await new Promise((resolve) => {
-      this.middleware_adapter.handleMiddleware(req, res, route, request_data, resolve);
-    });
+    try {
+      await this.middleware_adapter.handleMiddleware(req, res, route.middleware || []);
+    } catch (e) {
+      console.log("Error in fallback middleware", e);
+      res.status(500).send(`
+                <h1>500 Internal Server Error</h1>
+                <pre>${e}</pre>
+            `);
+      return;
+    }
     console.log("Completed fallback middleware");
     let server_data = await this.api_adapter.getApiData(route, request_data);
     console.log("Completed fallback API call");
@@ -727,13 +897,18 @@ ${JSON.stringify(options, null, 2)}`);
   const routeDefs = server_config.routes;
   const manager = new ComponentManager(componentLoader);
   const api_adapter = new ApiAdapter(manager);
-  const middleware_adapter = new MiddlewareAdapter(manager);
+  let middlewareRoot;
+  if (full_options.middleware_path) {
+    middlewareRoot = path.isAbsolute(full_options.middleware_path) ? full_options.middleware_path : path.resolve(full_options.viteOptions.root, full_options.middleware_path);
+  }
+  const middleware_adapter = MiddlewareAdapter.build(middlewareRoot, COMPONENT_DIR);
   const adapter = new ExpressServerAdapter(
     app,
     manager,
     htmlRenderer,
     api_adapter,
-    middleware_adapter
+    middleware_adapter,
+    full_options.context_builder
   );
   await adapter.handleRoutes(routeDefs, manifest);
   console.log("Routes registered");