godprotocol 2.2.50 → 2.2.55

package/Godprotocol.js

@@ -5,12 +5,16 @@ class GodProtocol {
   constructor(config) {
     this.db_config = config.db_config;
 
-    console.log(config, "uhh");
+    // debug(config, "uhh");
     this.api_key = config.api_key;
     this.platform_uri = config.platform_uri;
     this.route_table = new Route_table(this);
   }
 
+  platform_db = async () => {
+    return await this.route_table.platform_db();
+  };
+
   load_services = async (services) => {
     await this.route_table.load_services(services);
   };
@@ -27,6 +31,14 @@ class GodProtocol {
     await this.route_table.load_routes(routes);
   };
 
+  call = async (route, { headers, body }) => {
+    return await version_middleware(
+      { path: route, headers, body },
+      null,
+      this.route_table,
+    );
+  };
+
   on_request = async (req, res) => {
     await version_middleware(req, res, this.route_table);
   };

package/package.json

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

@@ -146,7 +146,7 @@ class Headers extends Services {
       type: "third_party",
       xplatform,
       authorization: authorization || null,
-      platform: process.env.PLATFORM_URI,
+      platform: this.platform_uri,
     };
 
     // 🔹 1. Try cache
@@ -165,24 +165,28 @@ class Headers extends Services {
 
     // 🔹 2. Call remote
     const headers = {
-      "x-api-version": "v2",
-      "x-api-key": process.env.API_KEY,
+      "x-api-version": "v3",
+      "x-platform": this.platform_uri,
+      "x-api-key": this.api_key,
     };
 
     if (authorization) {
       headers["authorization"] = `Bearer ${authorization}`;
     }
 
-    let res = await fetch(`${gp_services.profile}/validate_third_party`, {
-      method: "post",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "x-api-version": "v2",
-        ...headers,
+    let res = await fetch(
+      `${gp_services.profile}/${xplatform === this.platform_uri ? "me" : "third_party_me"}`,
+      {
+        method: "post",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "x-api-version": "v3",
+          ...headers,
+        },
+        body: JSON.stringify({ from: xplatform }),
       },
-      body: JSON.stringify({ platform_uri: xplatform }),
-    });
+    );
     res = await res.json();
 
     // 🔹 3. Save cache
@@ -210,10 +214,11 @@ class Headers extends Services {
   handle_security = async (name, request) => {
     let route = await this.get_route(name);
 
+    console.log(route?.config?.security, "SECURITY FOR ROUTE");
     if (!route?.config?.security?.length) return true;
 
     if (!this.check_security(route.config.security, request)) {
-      console.log("Unauthorized access attempt to route:", name);
+      // debug("Unauthorized access attempt to route:", name);
       return {
         ok: false,
         status: 401,
@@ -230,12 +235,10 @@ class Headers extends Services {
     if (xplatform) {
       val = await this.validate_third_party(xplatform, authorisation);
     } else {
-      console.log(api_key, authorisation);
       val = await this.validate_api_key(api_key, authorisation);
-      console.log(val, "Uhh");
     }
 
-    console.log(val);
+    // debug(val);
     if (!val?.ok) {
       return val;
     } else {
@@ -248,8 +251,9 @@ class Headers extends Services {
         };
       }
       request.headers.profile = val.profile;
-      request.headers.xplatform = val.xplatform;
       request.headers.platform = val.platform;
+      if (val.xplatform) request.headers.xplatform = val.xplatform;
+      if (val.third_party) request.headers.third_party = val.third_party;
     }
 
     return true;

package/server/Routable/Route_table.js

@@ -186,7 +186,7 @@ class Route_table extends Headers {
     if (config.schema) {
       let resp = await this.validate(config.schema, payload);
 
-      console.log("Validation result for route", name, ":", resp);
+      // debug("Validation result for route", name, ":", resp);
 
       if (!resp.ok) return resp;
     }

package/server/Routable/Services.js

@@ -24,17 +24,17 @@ class Services {
   get_token = async (service, id) => {
     let token;
 
-    console.log(service, id, "gettok");
+    // debug(service, id, "gettok");
     let db = await this.platform_db();
     token = await db.read_cache(
-      { platform_uri: service.uri, id: id.profile || id.platform },
+      { platform_uri: service.uri, id: id.profile },
       "token",
     );
 
-    console.log(token, "in-cache");
+    // debug(token, "in-cache");
     if (token) return token.token;
     try {
-      console.log(this.api_key, gp_services.profile);
+      // debug(this.api_key, gp_services.profile);
 
       let ftch = await fetch(`${gp_services.profile}/get_token`, {
         method: "POST",
@@ -47,13 +47,13 @@ class Services {
         body: JSON.stringify({ platform_uri: service.uri, ...id }),
       });
 
-      console.log("whats it like??");
+      // debug("whats it like??");
       token = await ftch.json();
-      console.log(token, "HOOWWW");
+      // debug(token, "HOOWWW");
 
       if (token?.ok) {
         await db.save_cache(
-          { id: id.profile || id.platform, platform_uri: service.uri },
+          { id: id.profile, platform_uri: service.uri },
           { token: token.token },
           "token",
         );
@@ -93,7 +93,7 @@ class Services {
             }
           }
         }
-        if (!token) headers["Authorization"] = `Bearer ${token}`;
+        if (token) headers["Authorization"] = `Bearer ${token}`;
         headers["x-platform"] = this.platform_uri;
 
         try {
@@ -121,200 +121,18 @@ class Services {
 
   handle_webhook_prior = async (req) => {
     let { platform } = req.headers;
-
-    let conf = await this.get_setting(
-      platform,
-      {
-        category: "webhooks",
-        key: ["general", this.platform_uri],
-      },
-      {
-        type: "webhooks",
-        key: platform.uri,
-        platform: this.platform_uri,
-      },
-    );
-
-    if (conf.ok === false) return null;
-
-    let response = await fetch(conf?.data?.url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "x-platform": req.headers["x-platform"],
-        "is-webhook": true,
-        authorization: req.headers["authorization"],
-        "x-api-version": conf?.data?.api_version || "v1",
-      },
-      body: JSON.stringify({
-        body: req.body,
-        from_platform: this.platform_uri,
-        endpoint: req.path,
-        server: this.gp.server,
-      }),
-    });
-
-    let res = await response.json();
-
-    return res;
-  };
-
-  handle_webhook_after = async (req, result) => {
-    let { platform } = req.headers;
-
-    let conf = await this.get_setting(
-      platform,
-      {
-        category: "webhooks",
-        key: ["general", this.platform_uri],
-      },
-      {
-        type: "webhooks",
-        key: platform.uri,
-        platform: this.platform_uri,
-      },
-    );
-
-    if (conf.ok === false) return null;
-
-    let response = await fetch(conf?.data?.url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "x-platform": req.headers["x-platform"],
-        "is-webhook": true,
-        authorization: req.headers["authorization"],
-        "x-api-version": conf?.data?.api_version || "v1",
-      },
-      body: JSON.stringify({
-        response: result,
-        body: req.body,
-        from_platform: this.platform_uri,
-        endpoint: req.path,
-        server: this.gp.server,
-      }),
-    });
-
-    let res = await response.json();
-
-    return res;
+    if (!platform) return false;
   };
 
-  get_setting = async (platform, setting, query) => {
-    const baseDB = await this.platform_db();
-
-    // 🔹 1. Try cache
-    const cached = await baseDB.read_cache(query, "config");
-
-    let config;
-
-    if (cached?.payload) {
-      try {
-        config = JSON.parse(cached.payload);
-      } catch {
-        config = null; // corrupted cache → ignore
-      }
-    }
-
-    if (config) return config;
-
-    const tokenRes = await this.get_token(
-      { uri: "settings.savvyaisolution.com" },
-      { platform: platform._id },
-    );
-
-    if (!tokenRes.token) {
-      return {
-        ok: false,
-        message: "Failed to retrieve platform token",
-        status: 403,
-      };
-    }
-
-    let ftch = await fetch(`${gp_services.settings}/get_settings`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${tokenRes.token}`,
-        "x-platform": this.platform_uri,
-        "x-api-version": "v1",
-        Accept: "application/json",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(setting),
-    });
-    let Res = await ftch.json();
-
-    if (!Res.ok) {
-      return {
-        ok: false,
-        message: "Failed to retrieve setting",
-        status: 500,
-      };
-    }
-
-    config =
-      Res.data?.[setting.category]?.[`${this.platform_uri}`] ||
-      Res.data?.[setting.category]?.["general"];
-
-    if (!config) {
-      return {
-        ok: false,
-        message: "setting not found",
-        status: 404,
-      };
-    }
-
-    // 🔹 3. Save cache
-    await baseDB.save_cache(query, config, "config");
-
-    return config;
-  };
+  handle_webhook_after = async (req, result) => {};
 
   resolve_db = async (req) => {
-    const { platform } = req.headers;
-
-    console.log(req.headers["x-api-key"], process.env.API_KEY);
-    // 🔹 Internal system call → use base DB
-    if (req.headers["x-api-key"] === process.env.API_KEY) {
-      const db = await this.platform_db();
-      req.db = db;
-      return { ok: true, db };
-    }
-
-    if (!platform?.uri || !platform?._id) {
-      return {
-        ok: false,
-        message: "Platform context missing",
-        status: 400,
-      };
-    }
+    let db = await this.platform_db();
 
-    const query = {
-      type: "db_config",
-      key: platform.uri,
-      platform: this.platform_uri,
+    return {
+      ok: true,
+      db,
     };
-
-    // 🔹 2. Fetch remote if no valid cache
-
-    let config = await this.get_setting(
-      platform,
-      {
-        category: "db",
-        key: ["general", this.platform_uri],
-      },
-      query,
-    );
-
-    if (config?.ok === false) return config;
-    // 🔹 4. Instantiate scoped DB
-    const db = new DB(config, this);
-
-    req.db = db;
-
-    return { ok: true, db };
   };
 }
 

package/server/version_control.js

@@ -7,6 +7,8 @@ const respond = async (result, res) => {
   if (result.pagination) response.pagination = result.pagination;
   if (result.token) response.token = result.token;
 
+  if (!res) return response;
+
   res.status(result?.status || (result?.ok ? 200 : 403)).json(response);
 };
 
@@ -32,6 +34,7 @@ const version_middleware = async (req, res, routers) => {
 
     try {
       result = await router.handle_security(name, req);
+      // console.log("Security check result:", result);
 
       if (result !== true) {
         return await respond(result, res);
@@ -45,9 +48,12 @@ const version_middleware = async (req, res, routers) => {
     let db = await router.resolve_db(req);
     let is_webhook = req.headers["is-webhook"];
 
+    // console.log(req.headers);
     if (!is_webhook) {
       let web_prior = await router.handle_webhook_prior(req);
-      if (!web_prior?.ok) {
+
+      if (web_prior === false) {
+      } else if (!web_prior?.ok) {
         return await respond(web_prior, res);
       } else {
         req.headers.webhook_prior = web_prior;
@@ -58,13 +64,14 @@ const version_middleware = async (req, res, routers) => {
       result = await router.execute(name, {
         body: req.body,
         headers: req.headers,
-        db,
+        db: db.db,
+        gp: router.gp,
         services: router.get_service,
       });
 
       !is_webhook && (await router.handle_webhook_after(req, result));
 
-      await respond(result, res);
+      return await respond(result, res);
     } catch (err) {
       console.error(err);
 
@@ -73,10 +80,13 @@ const version_middleware = async (req, res, routers) => {
   } catch (err) {
     console.error("Version Middleware Error:", err);
 
-    return res.status(500).json({
-      ok: false,
-      message: "Internal server error",
-    });
+    return (
+      res &&
+      res.status(500).json({
+        ok: false,
+        message: "Internal server error",
+      })
+    );
   }
 };