godprotocol 2.3.58 → 2.3.60

package/Godprotocol.js

@@ -142,7 +142,7 @@ class GodProtocol {
     await version_middleware(req, res, this.route_table);
   };
 
-  callback({ before, after } = {}) {
+  callback({ before, after, error } = {}) {
     if (before) {
       this.route_table.before(before);
     }
@@ -150,6 +150,10 @@ class GodProtocol {
     if (after) {
       this.route_table.after(after);
     }
+
+    if (error) {
+      this.route_table.error(error);
+    }
   }
 }
 

package/package.json

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

package/server/Routable/Header.js

@@ -247,20 +247,17 @@ class Headers extends Services {
     return requirements.every((r) => checks[r]?.());
   };
 
-  handle_security = async (name, request, version = this.active_version) => {
-    this.active_version = version;
-
+  handle_security = async (name, request, version) => {
     let config;
     if (version === "*") {
-      let version = this.versions[version];
+      let starVersion = this.versions[version];
 
-      config = version.config;
+      config = starVersion.config;
     }
 
     let route = await this.get_route(name, version);
-
     if (!route) {
-      route = await this.get_route("*");
+      route = await this.get_route("*", version);
     }
     if (!route?.config?.security?.length) return true;
 

package/server/Routable/Route_table.js

@@ -43,6 +43,7 @@ class Route_table extends Headers {
 
     this.before_callbacks = new Array();
     this.after_callbacks = new Array();
+    this.error_callbacks = new Array();
     this.validators = {};
   }
 
@@ -54,6 +55,10 @@ class Route_table extends Headers {
     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);
@@ -74,6 +79,14 @@ class Route_table extends Headers {
     return { ok: true };
   };
 
+  handle_error_callback = async (payload) => {
+    for (const callback of this.error_callbacks) {
+      await callback(payload);
+    }
+
+    return { ok: true };
+  };
+
   get_version = async (version = this.active_version) => {
     let resolved_version = version;
 
@@ -636,12 +649,16 @@ class Route_table extends Headers {
 
       if (!resp.ok) {
         if (this.platform_agent) {
-          await this.call_agency({
-            endpoint: name,
-            args: payload.body,
-            response: resp,
-            conversation: payload.headers?.meta?.conversation_id,
-          });
+          await this.call_agency(
+            {
+              endpoint: name,
+              args: payload.body,
+              response: resp,
+              conversation: payload.headers?.meta?.conversation_id,
+            },
+            undefined,
+            version_name,
+          );
         }
         return resp;
       }
@@ -651,11 +668,15 @@ class Route_table extends Headers {
       let result = await middleware(payload);
       if (!result?.ok) {
         if (this.platform_agent) {
-          await this.call_agency({
-            endpoint: name,
-            args: payload.body,
-            response: result,
-          });
+          await this.call_agency(
+            {
+              endpoint: name,
+              args: payload.body,
+              response: result,
+            },
+            undefined,
+            version_name,
+          );
         }
         return result;
       }
@@ -670,6 +691,7 @@ class Route_table extends Headers {
           response,
         },
         response.agent,
+        version_name,
       );
     }
 

package/server/Routable/Services.js

@@ -66,7 +66,7 @@ class Services {
   };
 
   get_service = async (service, opts = {}) => {
-    let ver = opts?.version || this.active_version;
+    let ver = opts?.version;
     let servic =
       this.version_services[ver]?.[service] || this.services[service];
 
@@ -122,8 +122,6 @@ class Services {
         }
 
         try {
-          let prev_version = this.active_version;
-
           let response = await fetch(
             `${servic.local ? this.gp.server.domain : servic.url}/${path}`,
             {
@@ -135,8 +133,6 @@ class Services {
 
           let reply = await response.json();
 
-          this.get_version(prev_version);
-
           if (typeof reply?.ok !== "boolean") {
             return {
               ok: false,
@@ -158,7 +154,6 @@ class Services {
   };
 
   version_db = async (ver) => {
-    let curr_ver = this.active_version;
     let version = await this.get_version(ver);
     if (!version) {
       let vers = Object.keys(this.versions);
@@ -167,7 +162,7 @@ class Services {
         let vrr = vers[v];
 
         if (vrr.startsWith(`${ver}:`)) {
-          version = this.get_version(vrr);
+          version = await this.get_version(vrr);
         }
       }
     }
@@ -177,8 +172,6 @@ class Services {
 
     let db = await this.platform_db();
 
-    this.get_version(curr_ver);
-
     return db;
   };
 

package/server/version_control.js

@@ -377,7 +377,8 @@ const version_middleware = async (req, res, routers) => {
       req,
       db: db.db,
       gp: router.gp,
-      services: router.get_service,
+      services: async (service, opts = {}) =>
+        await router.get_service(service, { version, ...opts }),
       method: req.method,
       params: {},
       memory: router.gp.memory,
@@ -405,6 +406,72 @@ const version_middleware = async (req, res, routers) => {
   } catch (err) {
     console.error(`${error_stage} Error:`, err);
 
+    try {
+      await router.handle_error_callback({
+        request_id: req?.request_id,
+
+        stage: error_stage,
+
+        timestamp: new Date().toISOString(),
+
+        error: {
+          name: err?.name,
+          message: err?.message,
+          stack: err?.stack,
+          cause: String(err?.cause || ""),
+        },
+
+        request: {
+          method: req?.method,
+          url: req?.url,
+          query,
+          body,
+          headers: req?.headers,
+          ip: req?.headers?.["x-forwarded-for"] || req?.socket?.remoteAddress,
+        },
+
+        routing: {
+          version,
+          route: name,
+          route_pattern: payload?.route_pattern,
+        },
+
+        database: {
+          db_name: versionRouter?.db_name,
+          db_prefix: versionRouter?.db_prefix,
+        },
+
+        security: {
+          passed: securityResult === true,
+        },
+
+        before_hook: {
+          response: callback?.response,
+          body_modified: !!callback?.body,
+          query_modified: !!callback?.query,
+          headers_modified: !!callback?.headers,
+          route_modified: !!callback?.route,
+          db_modified: !!callback?.db,
+        },
+
+        execution: {
+          method: payload?.method,
+          route: payload?.route,
+          params: payload?.params,
+        },
+
+        result: result
+          ? {
+              ok: result?.ok,
+              status: result?.status,
+              message: result?.message,
+            }
+          : null,
+      });
+    } catch (callbackError) {
+      console.error("handle_error_callback failed:", callbackError);
+    }
+
     return respond(
       {
         ok: false,