godprotocol 2.3.50 → 2.3.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "2.3.50",
+  "version": "2.3.52",
   "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,30 +1,46 @@
 import parseMultipart from "./parse_multipart_data.js";
 import serveStaticFile from "./serve_static_file.js";
+import { debug } from "./utils";
 
 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(
@@ -34,34 +50,30 @@ 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",
   );
 
-  // IMPORTANT: do NOT enable credentials with "*"
-  // res.setHeader("Access-Control-Allow-Credentials", "true");
+  console.log("[CORS] CORS headers applied");
 };
 
 const respond = (result, res) => {
-  // ----------------------------
-  // REDIRECT
-  // ----------------------------
+  console.log("[RESPOND] Result:", result);
 
   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,
   };
@@ -90,12 +102,17 @@ 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;
@@ -104,56 +121,156 @@ 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;
 
-    // ⬇️ query params captured for every method now
+    console.log("[MIDDLEWARE] Pathname:", pathname);
+
     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;
 
-    // STATIC ROUTE DETECTION
+    console.log("[MIDDLEWARE] Request initialized");
+
+    // --------------------------------------------------
+    // STATIC / API VERSION
+    // --------------------------------------------------
+
+    error_stage = "Version Resolution";
+
     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);
     }
 
-    if (req.headers["x-platform"])
+    // --------------------------------------------------
+    // PLATFORM
+    // --------------------------------------------------
+
+    if (req.headers["x-platform"]) {
+      console.log(
+        "[MIDDLEWARE] Original x-platform:",
+        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);
 
-      if (!versionRouter)
+      console.log("[MIDDLEWARE] Wildcard router found:", !!versionRouter);
+
+      if (!versionRouter) {
+        console.log("[MIDDLEWARE] No valid version router");
+
         return respond(
           {
             ok: false,
@@ -162,38 +279,73 @@ 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") {
-      // GET keeps existing behavior: query params double as body
+      console.log("[BODY] GET request - using query 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 {
-        error_stage = "Body Parser";
+        console.log("[BODY] JSON/body parser selected");
+
         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;
 
-    // remove query string from route
+    // --------------------------------------------------
+    // ROUTE NORMALIZATION
+    // --------------------------------------------------
+
+    error_stage = "Route Resolution";
+
     let routePath = pathname;
 
-    // Remove /api/<version>
+    console.log("[ROUTE] Original route:", routePath);
+
     routePath = routePath.replace(/^\/api\/[^\/]+(?=\/|$)/i, "");
 
-    // Ensure leading slash exists
+    console.log("[ROUTE] After API version removal:", routePath);
+
     if (!routePath.startsWith("/")) {
       routePath = "/" + routePath;
     }
@@ -202,20 +354,57 @@ 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);
     }
 
-    // DB
+    console.log("[SECURITY] Request authorized");
+
+    // --------------------------------------------------
+    // DATABASE
+    // --------------------------------------------------
+
+    error_stage = "Database";
+
+    console.log("[DB] Resolving database");
+
     const db = await router.resolve_db(req);
 
-    // WEBHOOK PRIOR
+    console.log("[DB] Database resolved:", !!db?.db);
+
+    // --------------------------------------------------
+    // BEFORE HOOK
+    // --------------------------------------------------
+
+    error_stage = "Before Hook";
+
+    console.log("[BEFORE] Calling handle_before");
+
     const callback = await router.handle_before(
       {
         req,
@@ -227,19 +416,57 @@ const version_middleware = async (req, res, routers) => {
       router.gp,
     );
 
-    if (callback?.response) return respond(callback.response, res);
+    console.log("[BEFORE] Callback result:", callback);
 
-    if (callback?.body) body = callback.body;
+    if (callback?.response) {
+      console.log("[BEFORE] Callback supplied response");
 
-    if (callback?.query) query = callback.query; // only if you make `query` a `let` — see note below
+      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) req.headers = callback.headers;
+    if (callback?.headers) {
+      console.log("[BEFORE] Replacing headers");
 
-    if (callback?.db) db.db = callback.db;
-    if (callback?.route) name = callback.route;
+      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?.route) {
+      console.log("[BEFORE] Replacing route:", callback.route);
+
+      name = callback.route;
+    }
 
+    // --------------------------------------------------
     // EXECUTE
+    // --------------------------------------------------
+
     error_stage = "Handler";
+
+    console.log("[EXECUTE] Preparing handler payload");
+
     let payload = {
       body,
       query,
@@ -253,27 +480,61 @@ 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);
 
-    // WEBHOOK AFTER
+    console.log("[EXECUTE] Handler result:", result);
+
+    // --------------------------------------------------
+    // AFTER HOOK
+    // --------------------------------------------------
+
     if (!isWebhook && version !== "*") {
       error_stage = "Webhook";
 
+      console.log("[AFTER] Calling handle_after");
+
       await router.handle_after(
         {
           req,
           result,
+          headers: req.headers,
           version,
-          route: name,
+          route: payload.route_pattern || name,
           db: db.db,
         },
         router.gp,
       );
+
+      console.log("[AFTER] handle_after completed");
+    } else {
+      console.log("[AFTER] Skipping handle_after", {
+        isWebhook,
+        version,
+      });
     }
 
-    return respond(result, res);
+    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;
   } catch (err) {
-    console.error(`${error_stage} Error:`, 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("==================================================");
 
     return respond(
       {