godprotocol 2.2.94 → 2.2.95

package/Godprotocol.js

@@ -1,3 +1,4 @@
+import Resource from "./server/Resource.js";
 import Route_table from "./server/Routable/Route_table.js";
 import version_middleware from "./server/version_control.js";
 
@@ -5,12 +6,22 @@ class GodProtocol {
   constructor(config) {
     this.db_config = config.db_config;
 
+    this.resource = new Resource(this);
+
     this.static_path = config.static_path;
     this.api_key = config.api_key;
     this.platform_uri = this.uri_default_domain(config.platform_uri);
     this.route_table = new Route_table(this);
+
+    this.memory = new Map();
+
+    this.on_start();
   }
 
+  on_start = async (fn) => {
+    await fn(this);
+  };
+
   uri_default_domain = (uri) => {
     if (!uri.includes(".")) {
       uri = `${uri}.savvyaisolution.com`;

package/package.json

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

package/server/Cache.js

@@ -0,0 +1,44 @@
+class Cache {
+  constructor(gp) {
+    this.gp = gp;
+    this.local = {};
+  }
+
+  set = async (key, value, opts = {}) => {
+    key = `${this.gp.platform_uri}:${key}`;
+
+    this.local[key] = value;
+
+    let Cache = await this.gp.route_table.get_service("cache");
+    if (!Cache) return;
+
+    await Cache.call("set", {
+      key,
+      value,
+      options: opts,
+    });
+  };
+
+  get = async (key, fill) => {
+    key = `${this.gp.platform_uri}:${key}`;
+
+    let value = this.local[key];
+    if (value) return value;
+
+    let Cache = await this.gp.route_table.get_service("cache");
+    if (!Cache) return;
+
+    value = await Cache.call("get", {
+      key,
+      fill,
+    });
+
+    if (value.ok) {
+      this.local[key] = value.data;
+
+      return value.data;
+    }
+  };
+}
+
+export default Cache;

package/server/Resource.js

@@ -0,0 +1,147 @@
+import Cache from "./Cache.js";
+
+class Resource {
+  constructor(gp) {
+    this.gp = gp;
+
+    this.cache = new Cache(this.gp);
+  }
+
+  hydrate_runtime = async () => {
+    this.runtime = await this.cache.get("runtime", {
+      active_requests: 0,
+
+      requests: new Map(),
+
+      handlers: {},
+    });
+
+    return this.runtime;
+  };
+
+  persist_runtime = async () => {
+    await this.cache.set("runtime", this.runtime, { ttl: 86400 });
+  };
+
+  incoming_request = async (req) => {
+    if (!(await this.hydrate_runtime())) return;
+
+    if (this.runtime.active_requests % 100 === 0) {
+      this.cleanup_handlers();
+    }
+
+    const route = `${req.method}:${req.url}`;
+
+    this.runtime.active_requests++;
+
+    this.runtime.requests.set(req.request_id, {
+      route,
+      started: performance.now(),
+    });
+
+    if (!this.runtime.handlers[route]) {
+      this.runtime.handlers[route] = {
+        active: 0,
+        completed: 0,
+
+        average_duration: 0,
+
+        max_duration: 0,
+        min_duration: Infinity,
+
+        total_duration: 0,
+
+        last_seen: Date.now(),
+      };
+    }
+
+    this.runtime.handlers[route].active++;
+
+    await this.persist_runtime();
+  };
+
+  compute_response = async (res) => {
+    if (!(await this.hydrate_runtime())) return;
+
+    const request = this.runtime.requests.get(res.request_id);
+
+    if (!request) return;
+
+    const handler = this.runtime.handlers[request.route];
+
+    if (!handler) {
+      this.runtime.requests.delete(res.request_id);
+      return;
+    }
+
+    const duration = performance.now() - request.started;
+
+    handler.completed++;
+
+    // Exponential Moving Average
+    if (handler.average_duration === 0) {
+      handler.average_duration = duration;
+    } else {
+      handler.average_duration =
+        handler.average_duration * 0.9 + duration * 0.1;
+    }
+
+    handler.total_duration += duration;
+
+    handler.max_duration = Math.max(handler.max_duration, duration);
+
+    handler.min_duration = Math.min(handler.min_duration, duration);
+
+    handler.last_seen = Date.now();
+
+    handler.active = Math.max(0, handler.active - 1);
+
+    this.runtime.active_requests = Math.max(
+      0,
+      this.runtime.active_requests - 1,
+    );
+
+    this.runtime.requests.delete(res.request_id);
+
+    await this.persist_runtime();
+  };
+
+  cleanup_handlers = () => {
+    const now = Date.now();
+
+    const MAX_IDLE = 24 * 60 * 60 * 1000; // 24 hours
+
+    for (const [route, handler] of Object.entries(this.runtime.handlers)) {
+      if (handler.active > 0) continue;
+
+      // Keep handlers we've gathered meaningful statistics for.
+      if (handler.completed >= 100) continue;
+
+      if (now - handler.last_seen > MAX_IDLE) {
+        delete this.runtime.handlers[route];
+      }
+    }
+  };
+
+  get estimated_work() {
+    let total = 0;
+
+    for (const handler of Object.values(this.runtime.handlers)) {
+      total += handler.active * handler.average_duration;
+    }
+
+    return Math.round(total);
+  }
+
+  get server_load() {
+    return {
+      active_requests: this.runtime.active_requests,
+
+      estimated_work_ms: this.estimated_work,
+
+      handlers: this.runtime.handlers,
+    };
+  }
+}
+
+export default Resource;

package/server/Routable/Header.js

@@ -119,12 +119,13 @@ class Headers extends Services {
       headers["authorization"] = `Bearer ${authorization}`;
     }
 
-    let res = await fetch(`${gp_services.profile}/validate`, {
+    let gp_profile = gp_services().profile;
+    let res = await fetch(`${gp_profile.url}/validate`, {
       method: "post",
       headers: {
         "Content-Type": "application/json",
         Accept: "application/json",
-        "x-api-version": "v3",
+        "x-api-version": gp_profile.api_version,
         ...headers,
       },
       body: JSON.stringify({}),
@@ -180,21 +181,23 @@ class Headers extends Services {
       hst = hst.replace("10.0.2.2", "localhost");
     }
 
+    let gp_profile = gp_services().profile;
+
     let third_party =
-      xplatform !== this.platform_uri && !gp_services.profile.endsWith(hst);
+      xplatform !== this.platform_uri && !gp_profile.url.endsWith(hst);
 
-    if (gp_services.profile.endsWith(hst)) {
+    if (gp_profile.url.endsWith(hst)) {
       headers["x-platform"] = xplatform;
     }
 
     let res = await fetch(
-      `${gp_services.profile}/${third_party ? "third_party_me" : "me"}`,
+      `${gp_profile.url}/${third_party ? "third_party_me" : "me"}`,
       {
         method: "post",
         headers: {
           "Content-Type": "application/json",
           Accept: "application/json",
-          "x-api-version": "v3",
+          "x-api-version": gp_profile.api_version,
           ...headers,
         },
         body: JSON.stringify(third_party ? { from: xplatform } : {}),
@@ -225,6 +228,8 @@ class Headers extends Services {
   };
 
   handle_security = async (name, request) => {
+    if (this.active_version === "*") return true;
+
     let route = await this.get_route(name);
 
     if (!route) {
@@ -250,11 +255,14 @@ class Headers extends Services {
 
     let val;
     if (route.config.security?.includes("auth_token")) {
-      val = await this.validate_third_party(
-        xplatform || this.platform_uri,
-        authorisation,
-        request,
-      );
+      if (authorisation?.startsWith("p")) {
+        val = await this.validate_api_key(authorisation);
+      } else
+        val = await this.validate_third_party(
+          xplatform || this.platform_uri,
+          authorisation,
+          request,
+        );
     } else if (route.config.security?.includes("api_key")) {
       val = await this.validate_api_key(api_key, authorisation);
     }

package/server/Routable/Route_table.js

@@ -42,6 +42,13 @@ class Route_table extends Headers {
   };
 
   load_routes = async (routes) => {
+    if (this.active_version === "*") {
+      this.versions[this.active_version] = {
+        handler: routes,
+      };
+      return;
+    }
+
     for (let name in routes) {
       let { handler, ...config } = routes[name];
 
@@ -181,6 +188,12 @@ class Route_table extends Headers {
   // 🚀 EXECUTION PIPELINE
   // =========================
   execute = async (name, payload) => {
+    if (this.active_version === "*") {
+      let version = this.versions[this.active_version];
+
+      return await version.handler(payload);
+    }
+
     let route = await this.get_route(name);
 
     if (!route) {

package/server/Routable/Services.js

@@ -1,13 +1,31 @@
 import { DB } from "./Header.js";
 
-let DEV = process.env.DEV;
-let gp_services = {
-  profile: DEV
-    ? "http://localhost:4000"
-    : "https://profile-api.savvyaisolution.com",
-  settings: DEV
-    ? "http://localhost:4005"
-    : "https://settings-api.savvyaisolution.com",
+let gp_services = () => {
+  let DEV = process.env.DEV;
+
+  return {
+    profile: {
+      url: DEV
+        ? "http://localhost:4000"
+        : "https://profile-api.savvyaisolution.com",
+      api_version: "v3",
+      uri: "profiles.savvyaisolution.com",
+    },
+    settings: {
+      url: DEV
+        ? "http://localhost:4005"
+        : "https://settings-api.savvyaisolution.com",
+      api_version: "v1",
+      uri: "settings.savvyaisolution.com",
+    },
+    godprotocol: {
+      url: DEV
+        ? "http://localhost:4001"
+        : "https://godprotocol-api.savvyaisolution.com",
+      api_version: "v1",
+      uri: "godprotocol.savvyaisolution.com",
+    },
+  };
 };
 
 export { gp_services };
@@ -15,11 +33,14 @@ export { gp_services };
 class Services {
   constructor() {
     this.services = new Object();
+
+    this.load_services(gp_services);
   }
 
   load_services = async (services) => {
     if (typeof services === "function") services = await services();
-    this.services = services;
+
+    this.services = { ...this.services, ...services };
   };
 
   get_token = async (service, id) => {
@@ -37,12 +58,13 @@ class Services {
     try {
       // debug(this.api_key, gp_services.profile);
 
-      let ftch = await fetch(`${gp_services.profile}/get_token`, {
+      let gp_profile = gp_services().profile;
+      let ftch = await fetch(`${gp_profile.url}/get_token`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
           Accept: "application/json",
-          "x-api-version": "v3",
+          "x-api-version": gp_profile.api_version,
           "x-api-key": this.api_key,
         },
         body: JSON.stringify({ platform_uri: service.uri, ...id }),
@@ -85,7 +107,7 @@ class Services {
           "x-api-version": servic.api_version || "v1",
         };
         let token;
-        if (header) {
+        if (header?.token || header?.profile) {
           if (header.token) {
             token = header.token;
           } else if (header.profile) {
@@ -98,10 +120,20 @@ class Services {
 
           if (token) headers["Authorization"] = `Bearer ${token}`;
           headers["x-platform"] = this.platform_uri;
-        } else {
-          headers["x-api-key"] = servic.api_key || this.gp.api_key;
+        } else if (servic.api_key) {
+          headers["x-api-key"] = servic.api_key;
         }
 
+        if (
+          !headers["x-api-key"] &&
+          !headers["Authorization"] &&
+          !servic.opened
+        ) {
+          return {
+            ok: false,
+            meesage: "Service unauthorized",
+          };
+        }
         try {
           let response = await fetch(`${servic.url}/${path}`, {
             method: "POST",

package/server/serve_static_file.js

@@ -40,6 +40,8 @@ const serveStaticFile = (req, res) => {
     res.setHeader("Content-Type", mimeTypes[ext] || "application/octet-stream");
 
     stream.pipe(res);
+
+    res.gp.compute_response(res);
     return true;
   } catch (err) {
     console.error("Static file error:", err);

package/server/version_control.js

@@ -1,5 +1,5 @@
-import parseMultipart from "godprotocol/server/parse_multipart_data.js";
-import serveStaticFile from "godprotocol/server/serve_static_file.js";
+import parseMultipart from "./parse_multipart_data.js";
+import serveStaticFile from "./serve_static_file.js";
 
 const getBody = (req) => {
   return new Promise((resolve, reject) => {
@@ -83,6 +83,8 @@ const respond = (result, res) => {
 
   res.end(JSON.stringify(response));
 
+  res.gp.compute_response(res);
+
   return response;
 };
 
@@ -100,6 +102,11 @@ const version_middleware = async (req, res, routers) => {
     const parsed_url = new URL(req.url, `http://${req.headers.host}`);
     const pathname = parsed_url.pathname;
 
+    req.request_id = crypto.randomUUID();
+    routers.gp.incoming_request(req);
+    res.gp = routers.gp;
+    res.request_id = req.request_id;
+
     // STATIC ROUTE DETECTION
     if (routers.static_path && pathname.startsWith(routers.static_path)) {
       return serveStaticFile(req, res);
@@ -121,17 +128,21 @@ const version_middleware = async (req, res, routers) => {
         req.headers["x-platform"],
       );
 
-    const versionRouter = await routers.get_version(version);
+    let versionRouter = await routers.get_version(version);
 
     if (!versionRouter) {
-      return respond(
-        {
-          ok: false,
-          message: "Invalid API version",
-          status: 400,
-        },
-        res,
-      );
+      version = "*";
+      versionRouter = await routers.get_version(version);
+
+      if (!versionRouter)
+        return respond(
+          {
+            ok: false,
+            message: "Invalid API version",
+            status: 400,
+          },
+          res,
+        );
     }
 
     let body = {};
@@ -189,7 +200,7 @@ const version_middleware = async (req, res, routers) => {
     const db = await router.resolve_db(req);
 
     // WEBHOOK PRIOR
-    if (!isWebhook) {
+    if (!isWebhook && version !== "*") {
       error_stage = "Callback";
       const webPrior = await router.handle_webhook_prior({
         ...req,
@@ -213,10 +224,11 @@ const version_middleware = async (req, res, routers) => {
       gp: router.gp,
       services: router.get_service,
       method: req.method,
+      memory: router.gp.memory,
     });
 
     // WEBHOOK AFTER
-    if (!isWebhook) {
+    if (!isWebhook && version !== "*") {
       error_stage = "Webhook";
       await router.handle_webhook_after(req, result);
     }