godprotocol 2.3.53 → 2.3.55

package/package.json

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

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,34 @@ 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");
-
     return result;
   }
 
+  // ----------------------------
+  // NORMAL JSON RESPONSE
+  // ----------------------------
+
   const response = {
     ok: result?.ok ?? false,
   };
@@ -102,17 +90,12 @@ 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);
 
   return response;
@@ -121,156 +104,56 @@ 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");
-
+      if (!versionRouter)
         return respond(
           {
             ok: false,
@@ -279,73 +162,38 @@ const version_middleware = async (req, res, routers) => {
           },
           res,
         );
-      }
     }
 
-    console.log("[MIDDLEWARE] Version router config:", versionRouter.config);
-
-    // --------------------------------------------------
-    // BODY
-    // --------------------------------------------------
-
-    error_stage = "Body Parser";
-
     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 +202,20 @@ 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);
-
     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");
-
+    // DB
     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");
-
+    // WEBHOOK PRIOR
     const callback = await router.handle_before(
       {
         req,
@@ -416,57 +227,20 @@ const version_middleware = async (req, res, routers) => {
       router.gp,
     );
 
-    console.log("[BEFORE] Callback result:", callback);
+    if (callback?.response) return respond(callback.response, res);
 
-    if (callback?.response) {
-      console.log("[BEFORE] Callback supplied response");
+    if (callback?.body) body = callback.body;
 
-      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;
-
-      console.log("[BEFORE] New headers:", req.headers);
-    }
-
-    if (callback?.db) {
-      console.log("[BEFORE] Replacing database");
-
-      db.db = callback.db;
-    }
+    if (callback?.query) query = callback.query; // only if you make `query` a `let` — see note below
 
-    if (callback?.route) {
-      console.log("[BEFORE] Replacing route:", callback.route);
+    if (callback?.headers) req.headers = callback.headers;
 
-      name = callback.route;
-    }
+    if (callback?.db) db.db = callback.db;
+    if (callback?.route) name = callback.route;
 
-    // --------------------------------------------------
     // EXECUTE
-    // --------------------------------------------------
 
     error_stage = "Handler";
-
-    console.log("[EXECUTE] Preparing handler payload");
-
     let payload = {
       body,
       query,
@@ -480,27 +254,15 @@ const version_middleware = async (req, res, routers) => {
       params: {},
       memory: router.gp.memory,
     };
-
-    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 +271,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(
       {