godprotocol 2.3.65 → 2.3.70

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.65",
+  "version": "2.3.70",
   "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,9 +72,14 @@ class Services {
 
     if (!servic) return;
 
+    if (opts.interface) {
+      return servic.interface || null;
+    }
+
     return {
       api_version: servic.api_version,
       uri: servic.uri,
+      interface: servic.interface,
       call: async (path, body, header) => {
         let headers = {
           "Content-Type": "application/json",
@@ -117,37 +122,58 @@ class Services {
           return {
             ok: false,
             status_code: "service_unauthorised",
-            meesage: "Service unauthorised",
+            message: "Service unauthorised",
           };
         }
 
+        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(
-            `${servic.local ? this.gp.server.domain : servic.url}/${path}`,
-            {
-              method: "POST",
-              headers,
-              body: JSON.stringify(body || {}),
-            },
-          );
+          let response = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body || {}),
+          });
 
           let reply = await response.json();
 
           if (typeof reply?.ok !== "boolean") {
-            return {
+            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) {
-          return {
+          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;
         }
       },
     };
@@ -155,6 +181,7 @@ class Services {
 
   version_db = async (ver) => {
     let version = await this.get_version(ver);
+
     if (!version) {
       let vers = Object.keys(this.versions);
 
@@ -170,7 +197,7 @@ class Services {
       return;
     }
 
-    let db = await this.platform_db();
+    let db = await this.platform_db(version?.db_name);
 
     return db;
   };
@@ -197,50 +224,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/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,11 +483,12 @@ 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,
         version,
+        matched_route_name: name,
         route: payload.route_pattern || name,
         db: db.db,
       });
@@ -498,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(),