godprotocol 2.3.66 → 2.3.71

package/Godprotocol.js

@@ -142,18 +142,31 @@ class GodProtocol {
     await version_middleware(req, res, this.route_table);
   };
 
-  callback({ before, after, error } = {}) {
-    if (before) {
-      this.route_table.before(before);
-    }
-
-    if (after) {
-      this.route_table.after(after);
-    }
-
-    if (error) {
-      this.route_table.error(error);
-    }
+  callback({
+    before,
+    after,
+    error,
+    on_service,
+    service_error,
+    after_service,
+  } = {}) {
+    const register = (callbacks, method) => {
+      if (Array.isArray(callbacks)) return callbacks.map(method);
+      if (callbacks) return method(callbacks);
+    };
+
+    register(before, (callback) => this.route_table.callbacks.before(callback));
+    register(after, (callback) => this.route_table.callbacks.after(callback));
+    register(service_error, (callback) =>
+      this.route_table.callbacks.service_error(callback),
+    );
+    register(error, (callback) => this.route_table.callbacks.error(callback));
+    register(on_service, (callback) =>
+      this.route_table.callbacks.on_service(callback),
+    );
+    register(after_service, (callback) =>
+      this.route_table.callbacks.after_service(callback),
+    );
   }
 }
 

package/package.json

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

@@ -0,0 +1,94 @@
+class Callbacks {
+  constructor(gp) {
+    this.gp = gp;
+
+    this.before_callbacks = new Array();
+    this.after_callbacks = new Array();
+    this.error_callbacks = new Array();
+    this.on_service_callbacks = new Array();
+    this.after_service_callbacks = new Array();
+    this.service_error_callbacks = new Array();
+  }
+
+  before(fn) {
+    this.before_callbacks.push(fn);
+  }
+
+  on_service(fn) {
+    this.on_service_callbacks.push(fn);
+  }
+
+  after_service(fn) {
+    this.after_service_callbacks.push(fn);
+  }
+
+  service_error(fn) {
+    this.service_error_callbacks.push(fn);
+  }
+
+  after(fn) {
+    this.after_callbacks.push(fn);
+  }
+
+  error(fn) {
+    this.error_callbacks.push(fn);
+  }
+
+  handle_before = async (payload) => {
+    for (const callback of this.before_callbacks) {
+      const result = await callback(payload, this.gp);
+
+      if (result && result.ok === false) {
+        return result;
+      }
+    }
+
+    return { ok: true };
+  };
+
+  handle_after = async (payload) => {
+    for (const callback of this.after_callbacks) {
+      await callback(payload, this.gp);
+    }
+
+    return { ok: true };
+  };
+
+  handle_error_callback = async (payload) => {
+    for (const callback of this.error_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);
+
+      if (result && result.ok === false) {
+        return result;
+      }
+    }
+
+    return { ok: true };
+  };
+
+  handle_after_service_callback = async (payload) => {
+    for (const callback of this.after_service_callbacks) {
+      await callback(payload, this.gp);
+    }
+
+    return { ok: true };
+  };
+
+  handle_error_service_callback = async (payload) => {
+    for (const callback of this.service_error_callbacks) {
+      await callback(payload, this.gp);
+    }
+
+    return { ok: true };
+  };
+}
+
+export default Callbacks;

package/server/Routable/Route_table.js

@@ -1,3 +1,4 @@
+import Callbacks from "./Callbacks.js";
 import Headers from "./Header.js";
 
 let securities = {
@@ -41,52 +42,11 @@ class Route_table extends Headers {
     this.platform_uri = gp.platform_uri;
     this.versions = {};
 
-    this.before_callbacks = new Array();
-    this.after_callbacks = new Array();
-    this.error_callbacks = new Array();
     this.validators = {};
-  }
-
-  before(fn) {
-    this.before_callbacks.push(fn);
-  }
 
-  after(fn) {
-    this.after_callbacks.push(fn);
+    this.callbacks = new Callbacks(this.gp);
   }
 
-  error(fn) {
-    this.error_callbacks.push(fn);
-  }
-
-  handle_before = async (payload) => {
-    for (const callback of this.before_callbacks) {
-      const result = await callback(payload, this.gp);
-
-      if (result && result.ok === false) {
-        return result;
-      }
-    }
-
-    return { ok: true };
-  };
-
-  handle_after = async (payload) => {
-    for (const callback of this.after_callbacks) {
-      await callback(payload, this.gp);
-    }
-
-    return { ok: true };
-  };
-
-  handle_error_callback = async (payload) => {
-    for (const callback of this.error_callbacks) {
-      await callback(payload, this.gp);
-    }
-
-    return { ok: true };
-  };
-
   get_version = async (version = this.active_version) => {
     let resolved_version = version;
 

package/server/Routable/Services.js

@@ -72,84 +72,122 @@ class Services {
 
     if (!servic) return;
 
-    return {
-      api_version: servic.api_version,
-      uri: servic.uri,
-      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",
-        };
+    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",
+      };
+
+      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?.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 (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 (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 (typeof token !== "string") {
-            if (token?.ok === false) return token;
-          }
+      let url = `${servic.local ? this.gp.server.domain : servic.url}/${path}`;
 
-          if (token) headers["Authorization"] = `Bearer ${token}`;
-          headers["x-platform"] = this.platform_uri;
-        }
+      let request_payload = {
+        service: servic,
+        url,
+        path,
+        headers,
+        body,
+      };
+      await this.callbacks.handle_on_service_callback(request_payload);
 
-        if (header?.xplatform) headers["x-platform"] = header.xplatform;
+      try {
+        let response = await fetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body || {}),
+        });
 
-        if (
-          !headers["x-api-key"] &&
-          !headers["Authorization"] &&
-          !servic.opened
-        ) {
-          return {
-            ok: false,
-            status_code: "service_unauthorised",
-            meesage: "Service unauthorised",
-          };
-        }
+        let reply = await response.json();
 
-        try {
-          let response = await fetch(
-            `${servic.local ? this.gp.server.domain : servic.url}/${path}`,
-            {
-              method: "POST",
-              headers,
-              body: JSON.stringify(body || {}),
-            },
-          );
-
-          let reply = await response.json();
-
-          if (typeof reply?.ok !== "boolean") {
-            return {
-              ok: false,
-              message: `Response calling ${service} service at path ${path}`,
-              data: reply,
-            };
-          }
-          return reply;
-        } catch (e) {
-          return {
+        if (typeof reply?.ok !== "boolean") {
+          reply = {
             ok: false,
-            message:
-              e.message || `Error calling ${service} service at path ${path}`,
-            status: 500,
+            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,
+        });
+
+        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,
     };
   };
 
@@ -198,50 +236,6 @@ class Services {
     return db;
   };
 
-  handle_webhook_prior = async (req) => {
-    let fn = this.gp.webhook_prior;
-
-    if (typeof fn === "function") {
-      let res = await fn(req);
-      return res && Object.keys(res).hasOwnProperty("ok") ? res : { ok: false };
-    }
-    return {
-      ok: true,
-    };
-  };
-
-  handle_webhook_after = async (req, result) => {
-    let { headers, body, route } = req;
-    let { xplatform, third_party, platform } = headers;
-
-    if (xplatform && xplatform.uri !== platform.uri) {
-      let webhook = third_party?.webhook || xplatform.webhook;
-
-      if (webhook?.enabled) {
-        if (webhook?.routes?.length && !webhook?.routes?.includes(route))
-          return;
-
-        await fetch(webhook?.url, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Accept: "application/json",
-            "x-api-version": webhook?.api_version || "v1",
-          },
-          body: JSON.stringify({
-            me: xplatform,
-            profile,
-            platform,
-            body,
-            result,
-            route,
-          }),
-        });
-      }
-    } else {
-    }
-  };
-
   resolve_db = async (req, opts = {}) => {
     let db = await this.platform_db(opts?.db_name);
 

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

@@ -441,7 +441,7 @@ const version_middleware = async (req, res, routers) => {
     });
 
     // WEBHOOK PRIOR
-    callback = await router.handle_before({
+    callback = await router?.callbacks.handle_before({
       req,
       body,
       query,
@@ -483,7 +483,7 @@ const version_middleware = async (req, res, routers) => {
     if (!isWebhook && version !== "*") {
       error_stage = "Webhook";
 
-      await router.handle_after({
+      await router.callbacks.handle_after({
         req: payload,
         result,
         headers: req.headers,
@@ -499,7 +499,7 @@ const version_middleware = async (req, res, routers) => {
     console.error(`${error_stage} Error:`, err);
 
     try {
-      await routers?.handle_error_callback?.({
+      await routers?.callbacks?.handle_error_callback?.({
         request_id: req?.request_id,
         stage: error_stage,
         timestamp: new Date().toISOString(),