godprotocol 2.3.64 → 2.3.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "2.3.64",
+  "version": "2.3.66",
   "description": "A distributed computing environment for Web 4.0 — integrating AI, decentralisation, and virtual computation.",
   "main": "Index.js",
   "type": "module",

package/server/Routable/Header.js

@@ -247,21 +247,26 @@ class Headers extends Services {
     return requirements.every((r) => checks[r]?.());
   };
 
-  handle_security = async (name, request, version) => {
-    let config;
-    if (version === "*") {
-      let starVersion = this.versions[version];
-
-      config = starVersion.config;
-    }
-
-    let route = await this.get_route(name, version);
-    if (!route) {
-      route = await this.get_route("*", version);
-    }
+  /**
+   * NOTE: `route` must already be resolved (via Route_table.get_route)
+   * by the caller. This method no longer resolves routing itself —
+   * that responsibility now lives entirely in Route_table.get_route,
+   * called once per request by version_middleware BEFORE the body is
+   * read. This keeps security a pure "given this route's requirements,
+   * is this request authorized" check, with no routing side effects.
+   *
+   * `route` will be `null`/`undefined` for the special "*" catch-all
+   * version, since that version has no route table to resolve against
+   * (see Route_table.execute's version_name === "*" branch). In that
+   * case no security requirement can be read, so this returns `true`
+   * (no enforcement) — identical in effect to the previous behavior,
+   * where that code path was unreachable/inert for the "*" version.
+   */
+  handle_security = async (route, request, version) => {
     if (!route?.config?.security?.length) return true;
 
-    config = route.config;
+    const config = route.config;
+
     if (!this.check_security(config.security, request)) {
       // debug("Unauthorized access attempt to route:", name);
       return {

package/server/Routable/Route_table.js

@@ -263,6 +263,12 @@ class Route_table extends Headers {
     }
 
     for (const route of version.regex_routes) {
+      // route.regex may have been constructed with a "g"/"y" flag, which
+      // makes .test() stateful (it advances lastIndex on match). Reset
+      // it before every use so route matching stays deterministic
+      // regardless of how the route's regex was authored.
+      route.regex.lastIndex = 0;
+
       if (route.regex.test(name)) {
         return {
           handler: route.handler,
@@ -616,14 +622,28 @@ class Route_table extends Headers {
   // =========================
   // 🚀 EXECUTION PIPELINE
   // =========================
-  execute = async (name, payload, version_name = this.active_version) => {
+  // `route`, when provided, is a route object already resolved by
+  // Route_table.get_route (e.g. by version_middleware, which now
+  // resolves the route once up front, before the request body is
+  // even read). If omitted, execute() falls back to resolving it
+  // itself, exactly as before — so any existing caller that invokes
+  // execute(name, payload, version) without a route keeps working
+  // unchanged.
+  execute = async (
+    name,
+    payload,
+    version_name = this.active_version,
+    route = null,
+  ) => {
     if (version_name === "*") {
       let version = this.versions[version_name];
 
       return await version.handler(payload);
     }
 
-    let route = await this.get_route(name, version_name);
+    if (!route) {
+      route = await this.get_route(name, version_name);
+    }
 
     if (!route) {
       return {

package/server/Routable/Services.js

@@ -155,6 +155,7 @@ class Services {
 
   version_db = async (ver) => {
     let version = await this.get_version(ver);
+
     if (!version) {
       let vers = Object.keys(this.versions);
 
@@ -170,7 +171,7 @@ class Services {
       return;
     }
 
-    let db = await this.platform_db();
+    let db = await this.platform_db(version?.db_name);
 
     return db;
   };

package/server/version_control.js

@@ -261,6 +261,7 @@ const version_middleware = async (req, res, routers) => {
   let body = {};
   let name;
   let router;
+  let route; // resolved route object (new — see ROUTE RESOLUTION stage below)
   let securityResult;
   let callback;
   let payload;
@@ -327,20 +328,28 @@ const version_middleware = async (req, res, routers) => {
 
     version = versionRouter.version;
 
-    if (req.method === "GET") {
-      body = query;
-    } else {
+    // Body is parsed lazily, on demand — see ROUTE RESOLUTION / SECURITY
+    // below for why this moved out of being unconditional up front.
+    const parseBody = async () => {
+      if (req.method === "GET") return query;
+
       const contentType = req.headers["content-type"] || "";
 
       if (contentType.includes("multipart/form-data")) {
-        body = await parseMultipart(req, routers.gp);
-      } else {
-        error_stage = "Body Parser";
-        body = await getBody(req);
+        return await parseMultipart(req, routers.gp);
       }
-    }
 
+      return await getBody(req);
+    };
+
+    // Legacy ("is_old") versions don't go through the route table or the
+    // new security pipeline at all — they hand the raw req/res straight
+    // to their own handler, same as before. They still need the body
+    // read up front since there's no route-based gate to check first.
     if (versionRouter.config?.is_old) {
+      error_stage = "Body Parser";
+      body = await parseBody();
+
       req.body = body;
       return versionRouter.routes(req, res);
     }
@@ -364,14 +373,66 @@ const version_middleware = async (req, res, routers) => {
 
     const isWebhook = req.headers["is-webhook"];
 
+    // -----------------------------------------------------------------
+    // ROUTE RESOLUTION
+    // -----------------------------------------------------------------
+    //
+    // Resolve the route BEFORE touching the request body. This is what
+    // actually fixes the multipart-before-routing-check problem: a
+    // request to a route that doesn't exist (or that fails auth) now
+    // never has its body read/parsed at all — for multipart uploads in
+    // particular, that means never buffering/streaming a file for a
+    // request that was always going to be rejected.
+    //
+    // The "*" catch-all version has no per-route table (its handler is
+    // registered directly against the version, not through add_route),
+    // so route resolution is skipped for it and `route` stays undefined
+    // — execute() already special-cases version_name === "*" and calls
+    // the version's handler directly, exactly as before.
+    //
+    error_stage = "Route";
+
+    if (version !== "*") {
+      route = await router.get_route(name, version);
+
+      if (!route) {
+        return respond(
+          {
+            ok: false,
+            status: 404,
+            message: "Route not found",
+            data: { path: `/${name}`, name, version },
+          },
+          res,
+        );
+      }
+    }
+
+    // -----------------------------------------------------------------
     // SECURITY
+    // -----------------------------------------------------------------
+    //
+    // Runs against the already-resolved route's config — no routing
+    // side effects here anymore (see Header.js handle_security).
+    //
     error_stage = "Header";
-    securityResult = await router.handle_security(name, req, version); // was: const securityResult =
+    securityResult = await router.handle_security(route, req, version); // was: name-based lookup inside handle_security
 
     if (securityResult !== true) {
       return respond(securityResult, res);
     }
 
+    // -----------------------------------------------------------------
+    // BODY
+    // -----------------------------------------------------------------
+    //
+    // Only now — after we know the route exists and the request is
+    // authorized — do we read the body. This is the stage that used to
+    // run unconditionally before route/security checks.
+    //
+    error_stage = "Body Parser";
+    body = await parseBody();
+
     // DB
     const db = await router.resolve_db(req, {
       version,
@@ -416,7 +477,7 @@ const version_middleware = async (req, res, routers) => {
       params: {},
       memory: router.gp.memory,
     };
-    result = await router.execute(name, payload, version);
+    result = await router.execute(name, payload, version, route); // pass the already-resolved route through — no second lookup
 
     // WEBHOOK AFTER
     if (!isWebhook && version !== "*") {
@@ -427,6 +488,7 @@ const version_middleware = async (req, res, routers) => {
         result,
         headers: req.headers,
         version,
+        matched_route_name: name,
         route: payload.route_pattern || name,
         db: db.db,
       });