godprotocol 2.2.57 → 2.2.59

package/package.json

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

package/server/Routable/Route_table.js

@@ -80,7 +80,11 @@ class Route_table extends Headers {
     if (type) {
       if (type.startsWith("/")) {
       } else {
-        let type_of = typeof data_value;
+        let type_of;
+        if (type === "array") {
+          type_of = Array.isArray(data_value) ? "array" : typeof data_value;
+        } else type_of = typeof data_value;
+
         if (type_of !== type)
           return {
             ok: false,
@@ -161,9 +165,9 @@ class Route_table extends Headers {
   };
 
   get_route_config = async (name) => {
-    let rot = await this.get_route(name);
+    let route = await this.get_route(name);
 
-    return rot.config;
+    return route.config;
   };
 
   // =========================
@@ -189,17 +193,56 @@ class Route_table extends Headers {
 
       // debug("Validation result for route", name, ":", resp);
 
-      if (!resp.ok) return resp;
+      if (!resp.ok) {
+        if (this.platform_agent) {
+          await this.call_agency({
+            endpoint: name,
+            args: payload.body,
+            response: resp,
+            conversation: payload.headers.meta.conversation_id,
+          });
+        }
+        return resp;
+      }
     }
 
     // ⚙️ middleware
     for (let middleware of config.middlewares || []) {
       let result = await middleware(payload);
-      if (!result?.ok) return result;
+      if (!result?.ok) {
+        if (this.platform_agent) {
+          await this.call_agency({
+            endpoint: name,
+            args: payload.body,
+            response: resp,
+            conversation: payload.headers.meta.conversation_id,
+          });
+        }
+        return result;
+      }
     }
 
     // 🎯 handler
-    return await handler(payload);
+    let response = await handler(payload);
+    if (response.agent) {
+      await this.call_agency(
+        {
+          endpoint: name,
+          args: payload.body,
+          response,
+          conversation: payload.headers.meta.conversation_id,
+        },
+        response.agent,
+      );
+    }
+
+    return response;
+  };
+
+  call_agency = async (payload, profile = this.platform_agent) => {
+    await (
+      await this.get_service("agency")
+    ).call("response", payload, { profile });
   };
 }
 

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",
-      })
+      }),
     );
   }
 };