godprotocol 2.3.39 → 2.3.41

package/Godprotocol.js

@@ -141,6 +141,16 @@ class GodProtocol {
   on_request = async (req, res) => {
     await version_middleware(req, res, this.route_table);
   };
+
+  callback({ before, after } = {}) {
+    if (before) {
+      this.route_table.before(before);
+    }
+
+    if (after) {
+      this.route_table.after(after);
+    }
+  }
 }
 
 export default GodProtocol;

package/package.json

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

@@ -18,9 +18,41 @@ class Route_table extends Headers {
     this.api_key = gp.api_key;
     this.platform_uri = gp.platform_uri;
     this.versions = {};
+
+    this.before_callbacks = new Array();
+    this.after_callbacks = new Array();
     this.validators = {};
   }
 
+  before(fn) {
+    this.before_callbacks.push(fn);
+  }
+
+  after(fn) {
+    this.after_callbacks.push(fn);
+  }
+
+  handle_before = async (payload) => {
+    for (const callback of this.before_callbacks) {
+      const result = await callback(payload);
+
+      // allow middleware-style rejection
+      if (result && result.ok === false) {
+        return result;
+      }
+    }
+
+    return { ok: true };
+  };
+
+  handle_after = async (payload, response) => {
+    for (const callback of this.after_callbacks) {
+      await callback(payload, response);
+    }
+
+    return { ok: true };
+  };
+
   get_version = async (version = this.active_version) => {
     let ver = this.versions[version];
 
@@ -90,11 +122,23 @@ class Route_table extends Headers {
   };
 
   get_route = async (name) => {
-    let version = this.versions[this.active_version];
+    console.log(name, "helo");
+    const version = this.versions[this.active_version];
 
-    let route = version.routes[name];
+    if (version.routes[name]) {
+      return version.routes[name];
+    }
+
+    for (const [pattern, route] of Object.entries(version.routes)) {
+      console.log(pattern);
+      if (pattern.startsWith("^")) {
+        if (new RegExp(pattern).test(name)) {
+          return route;
+        }
+      }
+    }
 
-    return route;
+    return null;
   };
 
   getValue = (obj, path) => path.split(".").reduce((o, key) => o?.[key], obj);
@@ -311,7 +355,7 @@ class Route_table extends Headers {
           await this.call_agency({
             endpoint: name,
             args: payload.body,
-            response: resp,
+            response: result,
             // conversation: payload.headers.meta.conversation_id,
           });
         }

package/server/version_control.js

@@ -211,19 +211,24 @@ const version_middleware = async (req, res, routers) => {
     const db = await router.resolve_db(req);
 
     // WEBHOOK PRIOR
-    if (!isWebhook && version !== "*") {
-      error_stage = "Callback";
-      const webPrior = await router.handle_webhook_prior({
-        ...req,
+    const callback = await router.handle_before(
+      {
+        req,
         body,
-      });
+        route: name,
+        db: db.db,
+      },
+      router.gp,
+    );
 
-      if (!webPrior?.ok) {
-        return respond(webPrior, res);
-      }
+    if (callback?.response) return respond(callback.response, res);
 
-      req.headers.webhook_prior = webPrior;
-    }
+    if (callback?.body) body = callback.body;
+
+    if (callback?.headers) req.headers = callback.headers;
+
+    if (callback?.db) db.db = callback.db;
+    if (callback?.route) name = callback.route;
 
     // EXECUTE
     error_stage = "Handler";
@@ -242,7 +247,17 @@ const version_middleware = async (req, res, routers) => {
     // WEBHOOK AFTER
     if (!isWebhook && version !== "*") {
       error_stage = "Webhook";
-      await router.handle_webhook_after(req, result);
+
+      await router.handle_after(
+        {
+          req,
+          result,
+          version,
+          route: name,
+          db: db.db,
+        },
+        router.gp,
+      );
     }
 
     return respond(result, res);