@noego/forge 0.0.6 → 0.0.8

package/dist-ssr/server.js

@@ -10,7 +10,8 @@ import fs$1 from "fs/promises";
 import yaml from "js-yaml";
 import "clone-deep";
 import join from "url-join";
-import { p as parsePathConfig } from "./path-ODk1FhWY.js";
+import { p as parsePathConfig } from "./path-9twSsimy.js";
+import { pathToFileURL } from "url";
 import { render } from "svelte/server";
 import pathToRegex from "path-to-regex";
 import ApplicationRenderer from "../src/components/RecursiveRender.svelte";
@@ -31,12 +32,15 @@ class ViteComponentLoader {
         absoluteComponentPath = componentPath;
       }
     }
+    console.log(`[ViteComponentLoader] Loading component from path: ${absoluteComponentPath}`);
     let vitePath = path.relative(process.cwd(), absoluteComponentPath);
     vitePath = vitePath.replace(/\\/g, "/");
     if (!vitePath.startsWith("/")) {
       vitePath = "/" + vitePath;
     }
+    console.log(`[ViteComponentLoader] Resolved Vite path: ${vitePath} from componentPath: ${componentPath}`);
     try {
+      console.log(`[ViteComponentLoader] Loading module for vitePath: ${vitePath}`);
       const module = await this.vite.ssrLoadModule(vitePath);
       console.log(`[ViteComponentLoader] Module loaded successfully for: ${vitePath}`);
       if (!module || !module.default) {
@@ -114,6 +118,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 {
@@ -123,7 +144,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;
@@ -131,16 +152,20 @@ function parse_modules(openapi) {
   const modules = Object.entries(modules_config).map(([_, module]) => {
     return module;
   });
+  const globalMiddleware = [...inheritedMiddleware, ...getGlobalPathsMiddleware(openapi)];
   const modules_path = modules.map((module) => {
     const basePath = module.basePath || "";
     const baseLayouts = module.baseLayouts || [];
+    const moduleMiddleware = Array.isArray(module["x-middleware"]) ? module["x-middleware"] : [];
+    const inherited = [...globalMiddleware, ...moduleMiddleware];
     const paths = module.paths;
     if (!paths) {
       return;
     }
-    const configurations = Object.entries(paths).map(([path2, method_config]) => {
-      return Object.entries(method_config).map(([method, config]) => {
-        return 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 parsePathConfig(path2, methodName, config, inherited);
       });
     });
     const routes = configurations.reduce((flat_config, config) => {
@@ -154,19 +179,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 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 parsePathConfig(path2, methodName, config, globalMiddleware);
     });
   });
   const routes = configurations.reduce((flat_config, config) => {
@@ -206,13 +236,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 = {
@@ -238,7 +271,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) {
@@ -378,61 +412,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 module = await this.importMiddlewareModule(fullPath, spec);
+    return this.extractMiddlewareFunctions(module, 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 = pathToFileURL(fullPath).href;
+      return await import(url);
+    } catch (error) {
+      throw new Error(`Unable to import middleware '${spec}' from ${fullPath}`);
+    }
+  }
+  extractMiddlewareFunctions(module, selector, spec) {
+    if (!selector) {
+      return this.extractDefaultFunction(module, spec);
+    }
+    if (selector === "*") {
+      return this.extractAllFunctions(module, spec);
+    }
+    return this.extractSpecificFunctions(module, selector, spec);
+  }
+  extractDefaultFunction(module, spec) {
+    if (!(module == null ? void 0 : module.default)) {
+      throw new Error(`Middleware '${spec}' is missing a default export`);
+    }
+    if (typeof module.default !== "function") {
+      throw new Error(`Default export for middleware '${spec}' is not a function`);
+    }
+    return [module.default];
+  }
+  extractAllFunctions(module, spec) {
+    const functions = Object.values(module).filter((value) => typeof value === "function");
+    if (functions.length === 0) {
+      throw new Error(`No functions exported by middleware '${spec}'`);
+    }
+    return functions;
+  }
+  extractSpecificFunctions(module, 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" ? module == null ? void 0 : module.default : module == null ? void 0 : module[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) {
@@ -452,13 +611,14 @@ function initialize_route_matchers(routes) {
 class ServerAdapter {
 }
 class ExpressServerAdapter extends ServerAdapter {
-  constructor(server, manager, htmlRender, api_adapter, middleware_adapter) {
+  constructor(server, manager, htmlRender, api_adapter, middleware_adapter, context_builder) {
     super();
     this.server = server;
     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);
@@ -498,7 +658,12 @@ class ExpressServerAdapter extends ServerAdapter {
     var _a, _b;
     let accepts = req.headers.accept || "";
     let server_api_call = accepts.toLowerCase().includes("application/json");
+    console.log(JSON.stringify(route, null, 2));
     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 pathParams = matcher.parser(cleanPath);
@@ -522,9 +687,7 @@ 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(`
@@ -625,9 +788,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");
@@ -662,11 +832,11 @@ async function createServer(app, 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`);
-  const COMPONENT_DIR = path.join(full_options.viteOptions.root, full_options.component_dir);
+  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;
   let componentLoader;
   let vite;
-  console.log(`Serving components from ${COMPONENT_DIR} at /components/`);
+  console.log(`Serving components from ${COMPONENT_DIR}`);
   if (full_options.assets) {
     for (const [asset_path, asset_dir] of Object.entries(full_options.assets)) {
       for (const asset of asset_dir) {
@@ -682,8 +852,9 @@ async function createServer(app, options) {
     console.log("Starting Vite in development mode...");
     const { createServer: createViteServer } = await import("vite");
     vite = await createViteServer(options.viteOptions || full_options.viteOptions);
+    console.log(`Vite server created options 
+${JSON.stringify(options, null, 2)}`);
     componentLoader = new ViteComponentLoader(COMPONENT_DIR, vite);
-    console.log("loaded");
   } else {
     console.log("Starting Vite in production mode...");
     app.use("/", express.static(path.join(options.viteOptions.root, full_options.build_dir)));
@@ -700,13 +871,18 @@ async function createServer(app, options) {
   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");