godprotocol 2.2.58 → 2.2.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "2.2.58",
+  "version": "2.2.60",
   "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

@@ -98,11 +98,11 @@ class Headers extends Services {
     // 🔹 1. Try cache
     const cached = await db.read_cache(query, "auth");
 
-    if (cached?.payload) {
+    if (cached) {
       try {
         return {
           ok: true,
-          data: JSON.parse(cached.payload),
+          data: cached,
         };
       } catch {
         // corrupted cache → ignore
@@ -111,7 +111,7 @@ class Headers extends Services {
 
     // 🔹 2. Call remote
     const headers = {
-      "x-api-version": "v2",
+      "x-api-version": "v3",
       "x-api-key": api_key,
     };
 
@@ -124,7 +124,7 @@ class Headers extends Services {
       headers: {
         "Content-Type": "application/json",
         Accept: "application/json",
-        "x-api-version": "v2",
+        "x-api-version": "v3",
         ...headers,
       },
       body: JSON.stringify({}),
@@ -152,11 +152,11 @@ class Headers extends Services {
     // 🔹 1. Try cache
     const cached = await db.read_cache(query, "auth");
 
-    if (cached?.payload) {
+    if (cached) {
       try {
         return {
           ok: true,
-          data: JSON.parse(cached.payload),
+          data: cached,
         };
       } catch {
         // corrupted cache → ignore
@@ -222,7 +222,9 @@ class Headers extends Services {
       return {
         ok: false,
         status: 401,
-        message: "Unauthorized",
+        message:
+          "Unauthorized: Missing required authentication headers of type(s): " +
+          route.config.security.join(", "),
       };
     }
 
@@ -232,10 +234,13 @@ class Headers extends Services {
     if (authorisation) authorisation = authorisation.replace("Bearer ", "");
 
     let val;
-    if (xplatform) {
-      val = await this.validate_third_party(xplatform, authorisation);
-    } else {
+    if (api_key) {
       val = await this.validate_api_key(api_key, authorisation);
+    } else if (authorisation) {
+      val = await this.validate_third_party(
+        xplatform || this.platform_uri,
+        authorisation,
+      );
     }
 
     // debug(val);
@@ -246,7 +251,8 @@ class Headers extends Services {
       if (!val) {
         return {
           ok: false,
-          message: "malformed header validation",
+          message:
+            "Unauthorized: Invalid credentials provided in authentication headers",
           status: 403,
         };
       }

package/server/Routable/Route_table.js

@@ -63,18 +63,24 @@ class Route_table extends Headers {
   };
 
   check_validation = async (rule, data) => {
-    let { prop, type, required, default: is_default } = rule;
+    let { prop, type, required } = rule;
 
     let data_value = data[prop];
 
-    data_value =
-      data_value == null || data_value == undefined ? is_default : data_value;
-
-    if (required && (data_value == null || data_value == is_default))
-      return { ok: false, message: `Field '${prop}' is required` };
+    if (data_value === undefined && rule.hasOwnProperty("default_value")) {
+      data_value = rule.default_value;
+      data[prop] = data_value;
+    }
 
-    if (data_value == null) {
-      return { ok: true };
+    if (data_value === undefined || data_value === null) {
+      if (required) {
+        return {
+          ok: false,
+          message: `Field '${prop}' is required`,
+        };
+      } else {
+        return { ok: true };
+      }
     }
 
     if (type) {

package/server/Routable/Services.js

@@ -41,7 +41,7 @@ class Services {
         headers: {
           "Content-Type": "application/json",
           Accept: "application/json",
-          "x-api-version": "v2",
+          "x-api-version": "v3",
           "x-api-key": this.api_key,
         },
         body: JSON.stringify({ platform_uri: service.uri, ...id }),
@@ -63,7 +63,9 @@ class Services {
       return {
         ok: false,
         status: 500,
-        message: e.message,
+        message:
+          e.message ||
+          `Error fetching ${service.uri} service token for profile`,
       };
     }
 
@@ -107,7 +109,8 @@ class Services {
         } catch (e) {
           return {
             ok: false,
-            message: e.message,
+            message:
+              e.message || `Error calling ${service} service at path ${path}`,
             status: 500,
           };
         }

package/server/version_control.js

@@ -1,91 +1,133 @@
-const respond = async (result, res) => {
-  let response = {
-    ok: result?.ok,
-    message: result.message,
-    data: result.data,
+const getBody = (req) => {
+  return new Promise((resolve, reject) => {
+    let data = "";
+
+    req.on("data", (chunk) => {
+      data += chunk;
+    });
+
+    req.on("end", () => {
+      try {
+        const parsed = data ? JSON.parse(data) : {};
+        resolve(parsed);
+      } catch (err) {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+
+    req.on("error", (err) => {
+      reject(err);
+    });
+  });
+};
+
+const respond = (result, res) => {
+  const response = {
+    ok: result?.ok ?? false,
+    message: result?.message ?? "",
+    data: result?.data,
   };
-  if (result.pagination) response.pagination = result.pagination;
-  if (result.token) response.token = result.token;
 
-  if (!res) return response;
+  if (result?.pagination) response.pagination = result.pagination;
+  if (result?.token) response.token = result.token;
 
-  res.status(result?.status || (result?.ok ? 200 : 403)).json(response);
+  const status = result?.status || (result?.ok ? 200 : 403);
+
+  res.statusCode = status;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(response));
+
+  return response;
 };
 
 const version_middleware = async (req, res, routers) => {
   try {
     const version = req.headers["x-api-version"] || "v1";
 
-    let router = routers.get_version(version);
-
-    if (router.config?.is_old) return router.routes(req, res);
-
-    if (!router) {
-      return res.status(400).json({
-        error: "Invalid API version",
-        version,
-      });
+    const versionRouter = routers.get_version(version);
+    // ----------------------------
+    // BODY (STREAM PARSE)
+    // ----------------------------
+    const body = await getBody(req);
+
+    if (!versionRouter) {
+      res.statusCode = 400;
+      return res.end(
+        JSON.stringify({
+          ok: false,
+          error: "Invalid API version",
+          version,
+        }),
+      );
     }
 
-    router = routers;
+    if (versionRouter.config?.is_old) {
+      req.body = body;
+      return versionRouter.routes(req, res);
+    }
 
-    let name = req.path.slice(1),
-      result;
+    const router = routers;
+    const name = req.url.replace(/^\//, "");
 
-    try {
-      result = await router.handle_security(name, req);
-      // console.log("Security check result:", result);
+    const isWebhook = req.headers["is-webhook"];
 
-      if (result !== true) {
-        return await respond(result, res);
-      }
-    } catch (err) {
-      console.error(err);
+    // ----------------------------
+    // SECURITY
+    // ----------------------------
+    const securityResult = await router.handle_security(name, req);
 
-      throw new Error("Security check failed");
+    if (securityResult !== true) {
+      return respond(securityResult, res);
     }
 
-    let db = await router.resolve_db(req);
-    let is_webhook = req.headers["is-webhook"];
+    // ----------------------------
+    // DB
+    // ----------------------------
+    const db = await router.resolve_db(req);
 
-    // console.log(req.headers);
-    if (!is_webhook) {
-      let web_prior = await router.handle_webhook_prior(req);
+    // ----------------------------
+    // WEBHOOK PRIOR
+    // ----------------------------
+    if (!isWebhook) {
+      const webPrior = await router.handle_webhook_prior(req);
 
-      if (web_prior === false) {
-      } else if (!web_prior?.ok) {
-        return await respond(web_prior, res);
-      } else {
-        req.headers.webhook_prior = web_prior;
+      if (webPrior && webPrior.ok === false) {
+        return respond(webPrior, res);
       }
-    }
-
-    try {
-      result = await router.execute(name, {
-        body: req.body,
-        headers: req.headers,
-        db: db.db,
-        gp: router.gp,
-        services: router.get_service,
-      });
 
-      !is_webhook && (await router.handle_webhook_after(req, result));
-
-      return await respond(result, res);
-    } catch (err) {
-      console.error(err);
+      if (webPrior?.ok) {
+        req.headers.webhook_prior = webPrior;
+      }
+    }
 
-      throw new Error("Route execution failed");
+    // ----------------------------
+    // EXECUTE
+    // ----------------------------
+    const result = await router.execute(name, {
+      body,
+      headers: req.headers,
+      db: db.db,
+      gp: router.gp,
+      services: router.get_service,
+    });
+
+    // ----------------------------
+    // WEBHOOK AFTER
+    // ----------------------------
+    if (!isWebhook) {
+      await router.handle_webhook_after(req, result);
     }
+
+    return respond(result, res);
   } catch (err) {
     console.error("Version Middleware Error:", err);
 
-    return (
-      res &&
-      res.status(500).json({
+    res.statusCode = 500;
+    res.end(
+      JSON.stringify({
         ok: false,
         message: "Internal server error",
-      })
+      }),
     );
   }
 };