godprotocol 2.3.53 → 2.3.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "2.3.53",
+  "version": "2.3.56",
   "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,15 +247,15 @@ class Headers extends Services {
     return requirements.every((r) => checks[r]?.());
   };
 
-  handle_security = async (name, request) => {
+  handle_security = async (name, request, version = this.active_version) => {
     let config;
-    if (this.active_version === "*") {
-      let version = this.versions[this.active_version];
+    if (version === "*") {
+      let version = this.versions[version];
 
       config = version.config;
     }
 
-    let route = await this.get_route(name);
+    let route = await this.get_route(name, version);
 
     if (!route) {
       route = await this.get_route("*");

package/server/Routable/Route_table.js

@@ -75,30 +75,38 @@ class Route_table extends Headers {
   };
 
   get_version = async (version = this.active_version) => {
-    let ver = this.versions[version];
+    let resolved_version = version;
+
+    let ver = this.versions[resolved_version];
 
     if (!ver) {
-      let versions = Object.keys(this.versions);
-      let verr = versions.find((v) => v.startsWith(`${version}:`));
+      const versions = Object.keys(this.versions);
+
+      const verr = versions.find((v) => v.startsWith(`${version}:`));
 
       if (verr) {
-        let serv = await this.get_service(version);
+        const serv = await this.get_service(version);
+
         if (serv) {
-          version = `${version}:${serv.api_version}`;
-          ver = this.versions[version];
+          resolved_version = `${version}:${serv.api_version}`;
+          ver = this.versions[resolved_version];
         }
       }
     }
-    if (!ver) return;
-
-    this.active_version = version;
-
-    this.db_name = ver.config?.db_name === true ? version : ver.config?.db_name;
 
-    this.db_prefix =
-      ver.config?.db_prefix === true ? version : ver.config?.db_prefix;
+    if (!ver) return;
 
-    return ver;
+    return {
+      ...ver,
+      version: resolved_version,
+      db_name:
+        ver.config?.db_name === true ? resolved_version : ver.config?.db_name,
+
+      db_prefix:
+        ver.config?.db_prefix === true
+          ? resolved_version
+          : ver.config?.db_prefix,
+    };
   };
 
   init_version = async (version, config) => {
@@ -209,8 +217,8 @@ class Route_table extends Headers {
   // 🔎 ROUTE RESOLUTION
   // Precedence: exact -> named param -> regex -> wildcard
   // =========================
-  get_route = async (name) => {
-    const version = this.versions[this.active_version];
+  get_route = async (name, version_name = this.active_version) => {
+    const version = this.versions[version_name];
 
     if (!version) return null;
 
@@ -587,30 +595,29 @@ class Route_table extends Headers {
     return { ok: true };
   };
 
-  get_route_config = async (name) => {
-    let route = await this.get_route(name);
-
+  get_route_config = async (name, version_name = this.active_version) => {
+    const route = await this.get_route(name, version_name);
     return route?.config;
   };
 
   // =========================
   // 🚀 EXECUTION PIPELINE
   // =========================
-  execute = async (name, payload) => {
-    if (this.active_version === "*") {
-      let version = this.versions[this.active_version];
+  execute = async (name, payload, version_name = this.active_version) => {
+    if (version_name === "*") {
+      let version = this.versions[version_name];
 
       return await version.handler(payload);
     }
 
-    let route = await this.get_route(name);
+    let route = await this.get_route(name, version_name);
 
     if (!route) {
       return {
         ok: false,
         status: 404,
         message: "Route not found",
-        data: { path: `/${name}`, name },
+        data: { path: `/${name}`, name, version: version_name },
       };
     }
 
@@ -621,6 +628,7 @@ class Route_table extends Headers {
 
     if (payload.req) {
       payload.req.params = params;
+      payload.req.api_version = version_name;
     }
 
     if (config.schema) {

package/server/version_control.js

@@ -1,46 +1,30 @@
 import parseMultipart from "./parse_multipart_data.js";
 import serveStaticFile from "./serve_static_file.js";
-import { debug } from "./utils.js";
 
 const getBody = (req) => {
-  console.log("[getBody] Starting body parser");
-
   return new Promise((resolve, reject) => {
     let data = "";
 
     req.on("data", (chunk) => {
-      console.log("[getBody] Received chunk:", chunk.length);
       data += chunk;
     });
 
     req.on("end", () => {
-      console.log("[getBody] Request body received");
-      console.log("[getBody] Raw body length:", data.length);
-
       try {
         const parsed = data ? JSON.parse(data) : {};
-
-        console.log("[getBody] Parsed body:", parsed);
-
         resolve(parsed);
       } catch (err) {
-        console.error("[getBody] JSON parse error:", err);
-
         reject(new Error("Invalid JSON body"));
       }
     });
 
     req.on("error", (err) => {
-      console.error("[getBody] Request stream error:", err);
-
       reject(err);
     });
   });
 };
 
 const applyCors = (req, res) => {
-  console.log("[CORS] Applying CORS headers");
-
   res.setHeader("Access-Control-Allow-Origin", "*");
 
   res.setHeader(
@@ -50,30 +34,154 @@ const applyCors = (req, res) => {
 
   res.setHeader(
     "Access-Control-Allow-Headers",
-    "Content-Type, Authorization, x-api-version, x-api-key, x-platform, x-secret",
+    "Content-Type, Authorization, x-api-version, x-api-key, x-platform",
+    "x-secret",
   );
 
-  console.log("[CORS] CORS headers applied");
+  // IMPORTANT: do NOT enable credentials with "*"
+  // res.setHeader("Access-Control-Allow-Credentials", "true");
 };
 
 const respond = (result, res) => {
-  console.log("[RESPOND] Result:", result);
+  /*
+   * ------------------------------------------------------------------------
+   * REDIRECT
+   * ------------------------------------------------------------------------
+   */
 
   if (result?.redirect) {
     const status = result?.status || 302;
 
-    console.log("[RESPOND] Redirect:", result.redirect, "Status:", status);
-
     res.statusCode = status;
+
     res.setHeader("Location", result.redirect);
 
     res.end();
 
-    console.log("[RESPOND] Redirect response sent");
+    res.gp?.resource?.compute_response?.(res);
 
     return result;
   }
 
+  /*
+   * ------------------------------------------------------------------------
+   * STREAM
+   * ------------------------------------------------------------------------
+   *
+   * A stream response bypasses JSON serialization completely.
+   *
+   * Expected:
+   *
+   * {
+   *   ok: true,
+   *   type: "stream",
+   *   data: {
+   *     stream,
+   *     content_type,
+   *     content_length,
+   *     etag
+   *   }
+   * }
+   *
+   * ------------------------------------------------------------------------
+   */
+
+  if (result?.status === 206 && result?.data?.stream) {
+    const { stream, content_type, content_length, etag, filename } =
+      result.data;
+
+    /*
+     * Status
+     */
+
+    res.statusCode = result?.status || 206;
+
+    /*
+     * Content type
+     */
+
+    res.setHeader("Content-Type", content_type || "application/octet-stream");
+
+    /*
+     * Content length
+     */
+
+    if (content_length !== undefined && content_length !== null) {
+      res.setHeader("Content-Length", content_length);
+    }
+
+    /*
+     * ETag
+     */
+
+    if (etag) {
+      res.setHeader("ETag", etag);
+    }
+
+    /*
+     * Optional filename
+     */
+
+    if (filename) {
+      res.setHeader("Content-Disposition", `inline; filename="${filename}"`);
+    }
+
+    /*
+     * Stream errors
+     */
+
+    stream.on("error", (error) => {
+      console.error("Response stream error:", error);
+
+      if (!res.headersSent) {
+        res.statusCode = 500;
+
+        res.setHeader("Content-Type", "application/json");
+
+        return res.end(
+          JSON.stringify({
+            ok: false,
+            message: "Failed to stream file",
+          }),
+        );
+      }
+
+      /*
+       * Headers have already been sent.
+       *
+       * At this point the response cannot safely
+       * be converted into a JSON error response.
+       *
+       * Destroy the response.
+       */
+
+      res.destroy(error);
+    });
+
+    /*
+     * Complete response metrics only after
+     * the stream has finished.
+     */
+
+    res.on("finish", () => {
+      res.gp?.resource?.compute_response?.(res);
+    });
+
+    /*
+     * Pipe file into HTTP response.
+     */
+
+    stream.pipe(res);
+
+    return true;
+  }
+
+  /*
+   * ------------------------------------------------------------------------
+   * NORMAL JSON RESPONSE
+   * ------------------------------------------------------------------------
+   */
+
   const response = {
     ok: result?.ok ?? false,
   };
@@ -102,18 +210,13 @@ const respond = (result, res) => {
 
   const status = result?.status || (result?.ok ? 200 : 403);
 
-  console.log("[RESPOND] HTTP status:", status);
-  console.log("[RESPOND] Response:", response);
-
   res.statusCode = status;
 
   res.setHeader("Content-Type", "application/json");
 
   res.end(JSON.stringify(response));
 
-  console.log("[RESPOND] Response sent");
-
-  res.gp?.resource?.compute_response(res);
+  res.gp?.resource?.compute_response?.(res);
 
   return response;
 };
@@ -121,156 +224,57 @@ const respond = (result, res) => {
 const version_middleware = async (req, res, routers) => {
   let error_stage = "Version Middleware";
 
-  console.log("==================================================");
-  console.log("[MIDDLEWARE] REQUEST START");
-  console.log("==================================================");
-
-  console.log("[MIDDLEWARE] Method:", req.method);
-  console.log("[MIDDLEWARE] URL:", req.url);
-  console.log("[MIDDLEWARE] Headers:", req.headers);
-
   try {
-    // --------------------------------------------------
-    // CORS
-    // --------------------------------------------------
-
-    error_stage = "CORS";
-
-    console.log("[MIDDLEWARE] Applying CORS");
-
     applyCors(req, res);
 
-    console.log("[MIDDLEWARE] CORS applied");
-
-    // --------------------------------------------------
-    // OPTIONS
-    // --------------------------------------------------
-
     if (req.method === "OPTIONS") {
-      console.log("[MIDDLEWARE] OPTIONS request");
-
       res.statusCode = 204;
-
-      console.log("[MIDDLEWARE] Returning 204");
-
       return res.end();
     }
 
-    // --------------------------------------------------
-    // URL
-    // --------------------------------------------------
-
-    error_stage = "URL Parsing";
-
-    console.log("[MIDDLEWARE] Parsing URL");
-
     const parsed_url = new URL(req.url, `http://${req.headers.host}`);
-
     const pathname = parsed_url.pathname;
 
-    console.log("[MIDDLEWARE] Pathname:", pathname);
-
+    // ⬇️ query params captured for every method now
     const query = Object.fromEntries(parsed_url.searchParams.entries());
-
     req.query = query;
 
-    console.log("[MIDDLEWARE] Query:", query);
-
-    // --------------------------------------------------
-    // REQUEST ID
-    // --------------------------------------------------
-
     req.request_id = crypto.randomUUID();
-
-    console.log("[MIDDLEWARE] Request ID:", req.request_id);
-
-    console.log("[MIDDLEWARE] Sending incoming_request hook");
-
     routers.gp?.resource?.incoming_request(req);
-
     res.gp = routers.gp;
     res.request_id = req.request_id;
 
-    console.log("[MIDDLEWARE] Request initialized");
-
-    // --------------------------------------------------
-    // STATIC / API VERSION
-    // --------------------------------------------------
-
-    error_stage = "Version Resolution";
-
+    // STATIC ROUTE DETECTION
     let version;
 
     const versionMatch = pathname.match(/^\/api\/([^\/]+)(\/|$)/i);
-
-    console.log("[MIDDLEWARE] Version match:", versionMatch);
-
     if (req.method === "GET") {
-      console.log("[MIDDLEWARE] GET request");
-
       if (routers.static_path && pathname.startsWith(routers.static_path)) {
-        console.log("[MIDDLEWARE] Static route detected:", pathname);
-
         res.gp = routers.gp;
 
         return serveStaticFile(req, res);
       }
 
       version = "__GET__";
-
-      console.log("[MIDDLEWARE] GET version:", version);
     } else if (versionMatch) {
       version = versionMatch[1];
-
-      console.log("[MIDDLEWARE] Version extracted from URL:", version);
     } else {
       version = req.headers["x-api-version"] || "v1";
-
-      console.log("[MIDDLEWARE] Version from header/default:", version);
     }
 
-    // --------------------------------------------------
-    // PLATFORM
-    // --------------------------------------------------
-
-    if (req.headers["x-platform"]) {
-      console.log(
-        "[MIDDLEWARE] Original x-platform:",
-        req.headers["x-platform"],
-      );
-
+    if (req.headers["x-platform"])
       req.headers["x-platform"] = routers.gp.uri_default_domain(
         req.headers["x-platform"],
       );
 
-      console.log(
-        "[MIDDLEWARE] Normalized x-platform:",
-        req.headers["x-platform"],
-      );
-    }
-
-    // --------------------------------------------------
-    // VERSION ROUTER
-    // --------------------------------------------------
-
-    console.log("[MIDDLEWARE] Getting version router:", version);
-
     let versionRouter = await routers.get_version(version);
 
-    console.log("[MIDDLEWARE] Version router found:", !!versionRouter);
-
     if (!versionRouter) {
-      console.log("[MIDDLEWARE] Falling back to wildcard version");
-
       version = "*";
 
       versionRouter = await routers.get_version(version);
 
-      console.log("[MIDDLEWARE] Wildcard router found:", !!versionRouter);
-
       if (!versionRouter) {
-        console.log("[MIDDLEWARE] No valid version router");
-
         return respond(
           {
             ok: false,
@@ -282,70 +286,38 @@ const version_middleware = async (req, res, routers) => {
       }
     }
 
-    console.log("[MIDDLEWARE] Version router config:", versionRouter.config);
-
-    // --------------------------------------------------
-    // BODY
-    // --------------------------------------------------
-
-    error_stage = "Body Parser";
+    version = versionRouter.version;
 
     let body = {};
 
     if (req.method === "GET") {
-      console.log("[BODY] GET request - using query as body");
-
+      // GET keeps existing behavior: query params double as body
       body = query;
     } else {
       const contentType = req.headers["content-type"] || "";
 
-      console.log("[BODY] Content-Type:", contentType);
-
       if (contentType.includes("multipart/form-data")) {
-        console.log("[BODY] Multipart request detected");
-
         body = await parseMultipart(req, routers.gp);
-
-        console.log("[BODY] Multipart body:", body);
       } else {
-        console.log("[BODY] JSON/body parser selected");
-
+        error_stage = "Body Parser";
         body = await getBody(req);
-
-        console.log("[BODY] Parsed body:", body);
       }
     }
 
-    // --------------------------------------------------
-    // OLD ROUTER
-    // --------------------------------------------------
-
     if (versionRouter.config?.is_old) {
-      console.log("[ROUTER] Old router detected");
-
       req.body = body;
-
-      console.log("[ROUTER] Passing directly to old routes");
-
       return versionRouter.routes(req, res);
     }
 
     const router = routers;
 
-    // --------------------------------------------------
-    // ROUTE NORMALIZATION
-    // --------------------------------------------------
-
-    error_stage = "Route Resolution";
-
+    // remove query string from route
     let routePath = pathname;
 
-    console.log("[ROUTE] Original route:", routePath);
-
+    // Remove /api/<version>
     routePath = routePath.replace(/^\/api\/[^\/]+(?=\/|$)/i, "");
 
-    console.log("[ROUTE] After API version removal:", routePath);
-
+    // Ensure leading slash exists
     if (!routePath.startsWith("/")) {
       routePath = "/" + routePath;
     }
@@ -354,57 +326,24 @@ const version_middleware = async (req, res, routers) => {
 
     let name = routePath.replace(/^\//, "");
 
-    console.log("[ROUTE] Final route path:", routePath);
-    console.log("[ROUTE] Route name:", name);
-
-    // --------------------------------------------------
-    // WEBHOOK
-    // --------------------------------------------------
-
     const isWebhook = req.headers["is-webhook"];
 
-    console.log("[WEBHOOK] Is webhook:", isWebhook);
-
-    // --------------------------------------------------
     // SECURITY
-    // --------------------------------------------------
-
     error_stage = "Header";
-
-    console.log("[SECURITY] Running security handler");
-
-    const securityResult = await router.handle_security(name, req);
-
-    console.log("[SECURITY] Result:", securityResult);
+    const securityResult = await router.handle_security(name, req, version);
 
     if (securityResult !== true) {
-      console.log("[SECURITY] Request rejected");
-
       return respond(securityResult, res);
     }
 
-    console.log("[SECURITY] Request authorized");
-
-    // --------------------------------------------------
-    // DATABASE
-    // --------------------------------------------------
-
-    error_stage = "Database";
-
-    console.log("[DB] Resolving database");
-
-    const db = await router.resolve_db(req);
-
-    console.log("[DB] Database resolved:", !!db?.db);
-
-    // --------------------------------------------------
-    // BEFORE HOOK
-    // --------------------------------------------------
-
-    error_stage = "Before Hook";
-
-    console.log("[BEFORE] Calling handle_before");
+    // DB
+    const db = await router.resolve_db(req, {
+      version,
+      db_name: versionRouter.db_name,
+      db_prefix: versionRouter.db_prefix,
+    });
 
+    // WEBHOOK PRIOR
     const callback = await router.handle_before(
       {
         req,
@@ -416,57 +355,20 @@ const version_middleware = async (req, res, routers) => {
       router.gp,
     );
 
-    console.log("[BEFORE] Callback result:", callback);
-
-    if (callback?.response) {
-      console.log("[BEFORE] Callback supplied response");
-
-      return respond(callback.response, res);
-    }
-
-    if (callback?.body) {
-      console.log("[BEFORE] Replacing body");
-
-      body = callback.body;
-
-      console.log("[BEFORE] New body:", body);
-    }
-
-    if (callback?.query) {
-      console.log("[BEFORE] Replacing query");
-
-      // query must be let if this is enabled
-      // query = callback.query;
-    }
-
-    if (callback?.headers) {
-      console.log("[BEFORE] Replacing headers");
-
-      req.headers = callback.headers;
+    if (callback?.response) return respond(callback.response, res);
 
-      console.log("[BEFORE] New headers:", req.headers);
-    }
+    if (callback?.body) body = callback.body;
 
-    if (callback?.db) {
-      console.log("[BEFORE] Replacing database");
+    if (callback?.query) query = callback.query; // only if you make `query` a `let` — see note below
 
-      db.db = callback.db;
-    }
+    if (callback?.headers) req.headers = callback.headers;
 
-    if (callback?.route) {
-      console.log("[BEFORE] Replacing route:", callback.route);
+    if (callback?.db) db.db = callback.db;
+    if (callback?.route) name = callback.route;
 
-      name = callback.route;
-    }
-
-    // --------------------------------------------------
     // EXECUTE
-    // --------------------------------------------------
 
     error_stage = "Handler";
-
-    console.log("[EXECUTE] Preparing handler payload");
-
     let payload = {
       body,
       query,
@@ -480,27 +382,15 @@ const version_middleware = async (req, res, routers) => {
       params: {},
       memory: router.gp.memory,
     };
+    const result = await router.execute(name, payload, version);
 
-    console.log("[EXECUTE] Payload:", payload);
-
-    console.log("[EXECUTE] Executing route:", name);
-
-    const result = await router.execute(name, payload);
-
-    console.log("[EXECUTE] Handler result:", result);
-
-    // --------------------------------------------------
-    // AFTER HOOK
-    // --------------------------------------------------
-
+    // WEBHOOK AFTER
     if (!isWebhook && version !== "*") {
       error_stage = "Webhook";
 
-      console.log("[AFTER] Calling handle_after");
-
       await router.handle_after(
         {
-          req,
+          req: payload,
           result,
           headers: req.headers,
           version,
@@ -509,32 +399,11 @@ const version_middleware = async (req, res, routers) => {
         },
         router.gp,
       );
-
-      console.log("[AFTER] handle_after completed");
-    } else {
-      console.log("[AFTER] Skipping handle_after", {
-        isWebhook,
-        version,
-      });
     }
 
-    console.log("[MIDDLEWARE] Sending final response");
-
-    const response = respond(result, res);
-
-    console.log("[MIDDLEWARE] Final response:", response);
-
-    console.log("==================================================");
-    console.log("[MIDDLEWARE] REQUEST END");
-    console.log("==================================================");
-
-    return response;
+    return respond(result, res);
   } catch (err) {
-    console.error("==================================================");
-    console.error(`[MIDDLEWARE] ${error_stage} Error:`, err);
-    console.error("[MIDDLEWARE] Error message:", err?.message);
-    console.error("[MIDDLEWARE] Error stack:", err?.stack);
-    console.error("==================================================");
+    console.error(`${error_stage} Error:`, err);
 
     return respond(
       {