godprotocol 2.3.70 → 2.3.72

package/package.json

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

package/server/Routable/Callbacks.js

@@ -8,12 +8,22 @@ class Callbacks {
     this.on_service_callbacks = new Array();
     this.after_service_callbacks = new Array();
     this.service_error_callbacks = new Array();
+    this.headers_rejected_callbacks = new Array();
+    this.headers_resolved_callbacks = new Array();
   }
 
   before(fn) {
     this.before_callbacks.push(fn);
   }
 
+  headers_resolved(fn) {
+    this.headers_resolved_callbacks.push(fn);
+  }
+
+  headers_rejected(fn) {
+    this.headers_rejected_callbacks.push(fn);
+  }
+
   on_service(fn) {
     this.on_service_callbacks.push(fn);
   }
@@ -62,6 +72,22 @@ class Callbacks {
     return { ok: true };
   };
 
+  handle_headers_rejected_callback = async (payload) => {
+    for (const callback of this.headers_rejected_callbacks) {
+      await callback(payload, this.gp);
+    }
+
+    return { ok: true };
+  };
+
+  handler_headers_resolved_callback = async (payload) => {
+    for (const callback of this.headers_resolved_callbacks) {
+      await callback(payload, this.gp);
+    }
+
+    return { ok: true };
+  };
+
   handle_on_service_callback = async (payload) => {
     for (const callback of this.on_service_callbacks) {
       const result = await callback(payload, this.gp);

package/server/Routable/Services.js

@@ -72,110 +72,122 @@ class Services {
 
     if (!servic) return;
 
-    if (opts.interface) {
-      return servic.interface || null;
-    }
+    let call = async (path, body, header) => {
+      let headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "x-api-version":
+          servic.local && !header?.api_version?.startsWith(`${servic.local}:`)
+            ? `${servic.local}:${header?.api_version || servic.api_version}`
+            : header?.api_version || servic.api_version || "v1",
+      };
 
-    return {
-      api_version: servic.api_version,
-      uri: servic.uri,
-      interface: servic.interface,
-      call: async (path, body, header) => {
-        let headers = {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-          "x-api-version":
-            servic.local && !header?.api_version?.startsWith(`${servic.local}:`)
-              ? `${servic.local}:${header?.api_version || servic.api_version}`
-              : header?.api_version || servic.api_version || "v1",
-        };
+      if (header?.api_key) {
+        headers["x-api-key"] = header.api_key;
+      } else if (servic.api_key) {
+        headers["x-api-key"] = servic.api_key;
+      }
+
+      if (header?.token) {
+        headers["Authorization"] = `Bearer ${header.token}`;
+        headers["x-platform"] = this.platform_uri;
+      } else if (servic.profile_key) {
+        headers["Authorization"] = `${servic.profile_key}`;
+      } else if (header?.profile) {
+        let token = await this.get_token(servic, header);
 
-        if (header?.api_key) {
-          headers["x-api-key"] = header.api_key;
-        } else if (servic.api_key) {
-          headers["x-api-key"] = servic.api_key;
+        if (typeof token !== "string") {
+          if (token?.ok === false) return token;
         }
 
-        if (header?.token) {
-          headers["Authorization"] = `Bearer ${header.token}`;
-          headers["x-platform"] = this.platform_uri;
-        } else if (servic.profile_key) {
-          headers["Authorization"] = `${servic.profile_key}`;
-        } else if (header?.profile) {
-          let token = await this.get_token(servic, header);
+        if (token) headers["Authorization"] = `Bearer ${token}`;
+        headers["x-platform"] = this.platform_uri;
+      }
 
-          if (typeof token !== "string") {
-            if (token?.ok === false) return token;
-          }
+      if (header?.xplatform) headers["x-platform"] = header.xplatform;
+
+      if (
+        !headers["x-api-key"] &&
+        !headers["Authorization"] &&
+        !servic.opened
+      ) {
+        return {
+          ok: false,
+          status_code: "service_unauthorised",
+          message: "Service unauthorised",
+        };
+      }
 
-          if (token) headers["Authorization"] = `Bearer ${token}`;
-          headers["x-platform"] = this.platform_uri;
-        }
+      let url = `${servic.local ? this.gp.server.domain : servic.url}/${path}`;
+
+      let request_payload = {
+        service: servic,
+        url,
+        path,
+        headers,
+        body,
+      };
+      await this.callbacks.handle_on_service_callback(request_payload);
+
+      try {
+        let response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body || {}),
+        });
 
-        if (header?.xplatform) headers["x-platform"] = header.xplatform;
+        let reply = await response.json();
 
-        if (
-          !headers["x-api-key"] &&
-          !headers["Authorization"] &&
-          !servic.opened
-        ) {
-          return {
+        if (typeof reply?.ok !== "boolean") {
+          reply = {
             ok: false,
-            status_code: "service_unauthorised",
-            message: "Service unauthorised",
+            message: `Response calling ${service} service at path ${path}`,
+            data: reply,
           };
         }
 
-        let url = `${servic.local ? this.gp.server.domain : servic.url}/${path}`;
-
-        let request_payload = {
-          service: servic,
-          url,
-          path,
-          headers,
-          body,
+        await this.callbacks.handle_after_service_callback({
+          request_payload,
+          response: reply,
+        });
+
+        return reply;
+      } catch (e) {
+        let pload = {
+          ok: false,
+          message:
+            e.message || `Error calling ${service} service at path ${path}`,
+          status: 500,
         };
-        await this.callbacks.handle_on_service_callback(request_payload);
-
-        try {
-          let response = await fetch(url, {
-            method: "POST",
-            headers,
-            body: JSON.stringify(body || {}),
-          });
-
-          let reply = await response.json();
-
-          if (typeof reply?.ok !== "boolean") {
-            reply = {
-              ok: false,
-              message: `Response calling ${service} service at path ${path}`,
-              data: reply,
-            };
-          }
-
-          await this.callbacks.handle_after_service_callback({
-            request_payload,
-            response: reply,
-          });
-
-          return reply;
-        } catch (e) {
-          let pload = {
-            ok: false,
-            message:
-              e.message || `Error calling ${service} service at path ${path}`,
-            status: 500,
-          };
-          await this.callbacks.handle_error_service_callback({
-            request_payload,
-            reply: pload,
-            error_object: e,
-          });
+        await this.callbacks.handle_error_service_callback({
+          request_payload,
+          reply: pload,
+          error_object: e,
+        });
 
-          return pload;
-        }
-      },
+        return pload;
+      }
+    };
+
+    let interface_;
+    if (servic.interface) {
+      interface_ = new servic.interface({
+        gp: this.gp,
+        call,
+        uri: servic.uri,
+        api_version: servic.api_version,
+      });
+    }
+
+    if (opts.interface) {
+      return interface_ || null;
+    }
+
+    return {
+      api_version: servic.api_version,
+      uri: servic.uri,
+      interface: interface_,
+      call,
     };
   };
 

package/server/utils.js

@@ -1,4 +1,9 @@
-import crypto, { createHash, randomBytes, createCipheriv } from "crypto";
+import crypto, {
+  createHash,
+  randomBytes,
+  createCipheriv,
+  createDecipheriv,
+} from "crypto";
 
 const deriveKey = (secret) =>
   createHash("sha256").update(String(secret)).digest();

package/server/version_control.js

@@ -418,9 +418,29 @@ const version_middleware = async (req, res, routers) => {
     error_stage = "Header";
     securityResult = await router.handle_security(route, req, version); // was: name-based lookup inside handle_security
 
+    const headersCallbackPayload = {
+      headers: req.headers,
+      query,
+      route: name,
+      route_config: route,
+      version,
+      method: req.method,
+    };
+
     if (securityResult !== true) {
+      await route.handle_headers_rejected_callback({
+        ...headersCallbackPayload,
+        security: securityResult,
+        authorized: false,
+      });
+
       return respond(securityResult, res);
     }
+    await route.handle_headers_resolved_callback({
+      ...headersCallbackPayload,
+      security: securityResult,
+      authorized: true,
+    });
 
     // -----------------------------------------------------------------
     // BODY