godprotocol 1.2.54 → 2.2.1

package/Godprotocol.js

@@ -0,0 +1,33 @@
+import Route_table from "./server/Routable/Route_table";
+import version_middleware from "./server/version_control";
+
+class GodProtocol {
+  constructor(config) {
+    this.db_config = config.db_config;
+
+    this.api_key = config.api_key;
+    this.platform_uri = config.platform_uri;
+    this.route_table = new Route_table(this);
+  }
+
+  load_services = async (services) => {
+    await this.route_table.load_services(services);
+  };
+
+  add_router = async (version, routes, opts) => {
+    if (opts.is_old) {
+      await this.route_table.init_version("v1", { is_old: true });
+      this.route_table.versions[version].routes = routes;
+    }
+
+    await this.route_table.init_version(version);
+
+    await this.route_table.load_routes(routes);
+  };
+
+  on_request = async (req, res) => {
+    await version_middleware(req, res, this.route_table);
+  };
+}
+
+export default GodProtocol;

package/Index.js

@@ -1,7 +1,12 @@
-import Trinity from "./Objects/Trinity.js";
-import Oracle from "./Objects/Oracle.js";
+import GodProtocol from "./Godprotocol";
 
-let trinity = new Trinity(process.env.Trinity || "GodProtocol");
+let gp = new GodProtocol({
+  platform_uri: "profile.savvyaisolution.com",
+  api_key: process.env.API_KEY,
+  db_config: {},
+});
 
-export default trinity;
-export { Oracle };
+gp.add_router("v2", {});
+
+app.use((req, res) => gp.on_request(req, res));
+export default GodProtocol;

package/package.json

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

@@ -0,0 +1,240 @@
+import { Mongo } from "@godprotocol/repositories";
+import { post_request } from "../../utils/services.js";
+import Services from "./Services.js";
+
+class DB {
+  constructor(config, router) {
+    this.router = router;
+    this.db = new Mongo({
+      db_url: config.db_url,
+      db_name: router?.gp?.platform_uri.replace(/\./g, "-"),
+    });
+
+    this.folders = {};
+  }
+
+  read_cache = async (query, category) => {
+    let coll = this.db.collection(`$CACHE-${category}`);
+    const doc = await coll.findOne(query);
+    if (!doc) return null;
+
+    if (doc.expiry && new Date(doc.expiry) < new Date()) {
+      await coll.deleteOne({ _id: doc._id });
+      return null;
+    }
+
+    return { ...doc };
+  };
+
+  save_cache = async (
+    query,
+    payload,
+    category,
+    ttlMs = 7 * 24 * 60 * 60 * 1000,
+  ) => {
+    let coll = this.db.collection(`$CACHE-${category}`);
+    const now = new Date();
+
+    const toSet = {
+      payload: JSON.stringify(payload),
+    };
+
+    // 🔥 set expiry if TTL provided
+    if (ttlMs) {
+      toSet.expiry = new Date(now.getTime() + ttlMs);
+    }
+
+    // OR use payload expiry if present
+    else if (payload?.expiry) {
+      toSet.expiry = new Date(payload.expiry);
+    }
+
+    const res = await coll.updateOne(
+      query,
+      {
+        $set: toSet,
+        $setOnInsert: {
+          _id: crypto.randomUUID(),
+          created: now,
+        },
+      },
+      { upsert: true },
+    );
+
+    return res;
+  };
+
+  folder = async (name) => {
+    let folder = this.folders[name];
+
+    if (folder) return folder;
+
+    folder = this.db.collection(name);
+    this.folders[name] = folder;
+
+    return folder;
+  };
+}
+
+class Headers extends Services {
+  constructor() {
+    super();
+  }
+
+  validate_api_key = async (api_key, authorization) => {
+    const db = await this.platform_db();
+
+    const query = {
+      type: "api_key",
+      api_key,
+      authorization: authorization || null,
+      platform: process.env.PLATFORM_URI,
+    };
+
+    // 🔹 1. Try cache
+    const cached = await db.read_cache(query, "auth");
+
+    if (cached?.payload) {
+      try {
+        return {
+          ok: true,
+          data: JSON.parse(cached.payload),
+        };
+      } catch {
+        // corrupted cache → ignore
+      }
+    }
+
+    // 🔹 2. Call remote
+    const headers = {
+      "x-api-version": "v2",
+      "x-api-key": api_key,
+    };
+
+    if (authorization) {
+      headers["authorization"] = `Bearer ${authorization}`;
+    }
+
+    const res = await post_request(`$PROFILE/validate`, {}, headers);
+
+    // 🔹 3. Save cache if valid
+    if (res.ok && res.data) {
+      await db.save_cache(query, res.data, "auth");
+    }
+
+    return res;
+  };
+
+  validate_third_party = async (xplatform, authorization) => {
+    const db = await this.platform_db();
+
+    const query = {
+      type: "third_party",
+      xplatform,
+      authorization: authorization || null,
+      platform: process.env.PLATFORM_URI,
+    };
+
+    // 🔹 1. Try cache
+    const cached = await db.read_cache(query, "auth");
+
+    if (cached?.payload) {
+      try {
+        return {
+          ok: true,
+          data: JSON.parse(cached.payload),
+        };
+      } catch {
+        // corrupted cache → ignore
+      }
+    }
+
+    // 🔹 2. Call remote
+    const headers = {
+      "x-api-version": "v2",
+      "x-api-key": process.env.API_KEY,
+    };
+
+    if (authorization) {
+      headers["authorization"] = `Bearer ${authorization}`;
+    }
+
+    const res = await post_request(
+      `$PROFILE/validate_third_party`,
+      { platform_uri: xplatform },
+      headers,
+    );
+
+    // 🔹 3. Save cache
+    if (res.ok && res.data) {
+      await db.save_cache(query, res.data, "auth");
+    }
+
+    return res;
+  };
+
+  check_security = (requirements, payload) => {
+    if (!requirements?.length) return true;
+
+    let headers = payload.headers || {};
+
+    let checks = {
+      api_key: () => !!headers["x-api-key"],
+      bearer_token: () => !!headers["authorization"],
+      xplatform: () => !!headers["x-platform"],
+    };
+
+    return requirements.every((r) => checks[r]?.());
+  };
+
+  handle_security = async (name, request) => {
+    let route = await this.get_route(name);
+
+    if (!route.config.security?.length) return true;
+
+    if (!this.check_security(route.config.security, request)) {
+      console.log("Unauthorized access attempt to route:", name);
+      return {
+        ok: false,
+        status: 401,
+        message: "Unauthorized",
+      };
+    }
+
+    let xplatform = request.headers["x-platform"],
+      api_key = request.headers["x-api-key"],
+      authorisation = request.headers["authorization"];
+    if (authorisation) authorisation = authorisation.replace("Bearer ", "");
+
+    let val;
+    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);
+    if (!val?.ok) {
+      return val;
+    } else {
+      val = val.data;
+      if (!val) {
+        return {
+          ok: false,
+          message: "malformed header validation",
+          status: 403,
+        };
+      }
+      request.headers.profile = val.profile;
+      request.headers.xplatform = val.xplatform;
+      request.headers.platform = val.platform;
+    }
+
+    return true;
+  };
+}
+
+export default Headers;
+export { DB };

package/server/Routable/Route_table.js

@@ -0,0 +1,198 @@
+import Headers from "./Header.js";
+
+let securities = {
+  both: ["api_key", "bearer_token"],
+  first: ["api_key"],
+  second: ["bearer_token"],
+  all: ["api_key", "bearer_token", "xplatform"],
+  none: [],
+};
+
+class Route_table extends Headers {
+  constructor(gp) {
+    super();
+
+    this.gp = gp;
+    this.db_config = gp.db_config;
+    this.versions = {};
+    this.validators = {};
+  }
+
+  get_version = (version) => {
+    let ver = this.versions[version];
+    if (!ver) return;
+
+    this.active_version = version;
+
+    return ver;
+  };
+
+  init_version = async (version, config) => {
+    this.versions[version] = { config, routes: {} };
+
+    this.active_version = version;
+  };
+
+  // 🔌 extensibility
+  register_validator = (name, fn) => {
+    this.validators[name] = fn;
+  };
+
+  load_routes = async (routes) => {
+    for (let name in routes) {
+      let { handler, ...config } = routes[name];
+
+      config.security = securities[config.security || "none"];
+
+      await this.add_route(name, handler, config);
+    }
+  };
+
+  add_route = async (name, handler, config) => {
+    this.versions[this.active_version].routes[name] = { handler, config };
+  };
+
+  get_route = async (name) => this.versions[this.active_version].routes[name];
+
+  check_validation = async (rule, data) => {
+    let { prop, type, required, default: is_default } = rule;
+
+    let data_value = data[prop];
+
+    data_value =
+      data_value == null || data_value == undefined ? is_default : data_value;
+
+    if (required && (data_value == null || data_value == is_default))
+      return { ok: false, message: `Field '${prop}' is required` };
+
+    if (data_value == null) {
+      return { ok: true };
+    }
+
+    if (type) {
+      if (type.startsWith("/")) {
+      } else {
+        let type_of = typeof data_value;
+        if (type_of !== type)
+          return {
+            ok: false,
+            message: `Field '${prop}' must be of type '${type}' got '${type_of}'`,
+          };
+      }
+    }
+
+    return { ok: true };
+  };
+
+  validate = async (schema, data) => {
+    let { body: schema_body } = schema;
+    let { body: data_body } = data;
+
+    for (let prop in schema_body) {
+      let rule = schema_body[prop];
+
+      if (prop === "$logic") {
+        let or_logic = rule.or;
+        if (or_logic) {
+          for (let o = 0; o < or_logic.length; o++) {
+            let or_rule = or_logic[o],
+              or_rule_check;
+
+            for (let proper of or_rule.properties) {
+              or_rule_check = await this.check_validation(
+                { prop: proper, ...or_rule },
+                data_body,
+              );
+
+              if (or_rule_check?.ok) break;
+            }
+            if (or_rule.required && !or_rule_check?.ok) {
+              return {
+                ok: false,
+                message: `At least one of the following fields is required: ${or_rule.properties.join(
+                  ", ",
+                )}`,
+              };
+            }
+          }
+        }
+
+        let and_logic = rule.and;
+        if (and_logic) {
+          for (let a = 0; a < and_logic.length; a++) {
+            let and_rule = and_logic[a];
+
+            for (let prop of and_rule.properties) {
+              let and_rule_check = await this.check_validation(
+                { prop, ...and_rule },
+                data_body,
+              );
+
+              if (and_rule.required && !and_rule_check?.ok) {
+                return {
+                  ok: false,
+                  message: `Field '${prop}' is required`,
+                };
+              }
+            }
+          }
+        }
+      }
+
+      let validation_result = await this.check_validation(
+        { prop, ...rule },
+        data_body,
+      );
+
+      if (!validation_result.ok) {
+        return validation_result;
+      }
+    }
+
+    return { ok: true };
+  };
+
+  get_route_config = async (name) => {
+    let rot = await this.get_route(name);
+
+    return rot.config;
+  };
+
+  // =========================
+  // 🚀 EXECUTION PIPELINE
+  // =========================
+  execute = async (name, payload) => {
+    let route = await this.get_route(name);
+
+    if (!route) {
+      return {
+        ok: false,
+        status: 404,
+        message: "Route not found",
+        data: { path: `/${name}`, name },
+      };
+    }
+
+    let { handler, config } = route;
+
+    // 📜 schema
+    if (config.schema) {
+      let resp = await this.validate(config.schema, payload);
+
+      console.log("Validation result for route", name, ":", resp);
+
+      if (!resp.ok) return resp;
+    }
+
+    // ⚙️ middleware
+    for (let middleware of config.middlewares || []) {
+      let result = await middleware(payload);
+      if (!result?.ok) return result;
+    }
+
+    // 🎯 handler
+    return await handler(payload);
+  };
+}
+
+export default Route_table;

package/server/Routable/Services.js

@@ -0,0 +1,193 @@
+import { post_request } from "../../utils/services.js";
+import { DB } from "./Header.js";
+
+let gp_services = {
+  profile: "https://profile-api.savvyaisolution.com",
+  settings: "https://settings-api.savvyaisolution.com",
+};
+
+class Services {
+  constructor() {
+    this.services = new Object();
+  }
+
+  load_services = async (services) => {
+    this.services = services;
+  };
+
+  get_token = async (service, id) => {
+    let token;
+
+    let db = await this.platform_db();
+    token = await db.read_cache(
+      { platform_uri: service.uri, id: id.profile || id.platform },
+      "token",
+    );
+
+    if (token) return token;
+
+    let ftch = await fetch(`${gp_services.profile}/get_token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "x-api-version": "v2",
+        "x-api-key": this.api_key,
+      },
+      body: JSON.stringify({ platform_uri: service.uri, ...id }),
+    });
+
+    token = await ftch.json();
+
+    if (token?.ok) {
+      await db.save_cache(
+        { id: id.profile || id.platform, platform_uri: service.uri },
+        token.data,
+        "token",
+      );
+      return token.data;
+    }
+
+    return null;
+  };
+
+  get_service = async (service) => {
+    let servic = this.services[service];
+    if (!servic) return;
+
+    return {
+      call: async (path, body, header) => {
+        let headers = {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          "x-api-version": servic.api_version || "v1",
+        };
+        let token;
+        if (header) {
+          if (header.token) {
+            token = header.token;
+          } else if (header.profile) {
+            token = await this.get_token(servic, header);
+          }
+        }
+        headers["Authorization"] = `Bearer ${token}`;
+        headers["x-platform"] = this.platform_uri;
+
+        let response = await fetch(`${servic.url}/${path}`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(body || {}),
+        });
+
+        return await response.json();
+      },
+    };
+  };
+
+  platform_db = async () => {
+    return new DB(this.db_config, this);
+  };
+
+  resolve_db = async (req) => {
+    const { platform } = req.headers;
+
+    // 🔹 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 db;
+    }
+
+    if (!platform?.uri || !platform?._id) {
+      return {
+        ok: false,
+        message: "Platform context missing",
+        status: 400,
+      };
+    }
+
+    const baseDB = await this.platform_db();
+
+    const query = {
+      type: "db_config",
+      key: platform.uri,
+      platform: this.platform_uri,
+    };
+
+    // 🔹 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
+      }
+    }
+
+    // 🔹 2. Fetch remote if no valid cache
+    if (!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({
+          category: "db",
+          key: [this.platform_uri, "general"],
+        }),
+      });
+      let dbRes = await ftch.json();
+
+      if (!dbRes.ok) {
+        return {
+          ok: false,
+          message: "Failed to retrieve database configuration",
+          status: 500,
+        };
+      }
+
+      config =
+        dbRes.data?.db?.[`${this.platform_uri}`] || dbRes.data?.db?.["general"];
+
+      if (!config) {
+        return {
+          ok: false,
+          message: "Database configuration not found",
+          status: 404,
+        };
+      }
+
+      // 🔹 3. Save cache
+      await baseDB.save_cache(query, config, "config");
+    }
+
+    // 🔹 4. Instantiate scoped DB
+    const db = new DB(config, this);
+
+    req.db = db;
+
+    return db;
+  };
+}
+
+export default Services;