godprotocol 2.3.15 → 2.3.17

package/package.json

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

@@ -284,7 +284,7 @@ class Headers extends Services {
 
     let val;
     if (config.security?.includes("auth_token")) {
-      if (authorisation?.startsWith("p")) {
+      if (authorisation?.startsWith("p") || authorisation?.startsWith("o")) {
         val = await this.validate_api_key(authorisation);
       } else
         val = await this.validate_third_party(

package/server/Routable/Route_table.js

@@ -21,12 +21,17 @@ class Route_table extends Headers {
     this.validators = {};
   }
 
-  get_version = (version) => {
+  get_version = (version = this.active_version) => {
     let ver = this.versions[version];
     if (!ver) return;
 
     this.active_version = version;
 
+    this.db_name = ver.config?.db_name === true ? version : ver.config?.db_name;
+
+    this.db_prefix =
+      ver.config?.db_prefix === true ? version : ver.config?.db_prefix;
+
     return ver;
   };
 
@@ -74,10 +79,12 @@ class Route_table extends Headers {
     return route;
   };
 
+  getValue = (obj, path) => path.split(".").reduce((o, key) => o?.[key], obj);
+
   check_validation = async (rule, data) => {
-    let { prop, type, required } = rule;
+    let { prop, type, required, enum: allowed } = rule;
 
-    let data_value = data[prop];
+    let data_value = this.getValue(data, prop);
 
     if (data_value === undefined && rule.hasOwnProperty("default_value")) {
       data_value = rule.default_value;
@@ -90,92 +97,139 @@ class Route_table extends Headers {
           ok: false,
           message: `Field '${prop}' is required`,
         };
-      } else {
-        return { ok: true };
       }
+      return { ok: true };
     }
 
+    // type validation
+    // =========================
+    // Type validation
+    // =========================
+
     if (type) {
-      if (type.startsWith("/")) {
-      } else {
-        let type_of;
-        if (type === "array") {
-          type_of = Array.isArray(data_value) ? "array" : typeof data_value;
-        } else type_of = typeof data_value;
-
-        if (type_of !== type)
+      let descriptor = type;
+
+      // Logical schemas may provide a map:
+      // type: {
+      //   intervals: { value: "array", min: 1 },
+      //   throttle: { value: "number", min: 1000 }
+      // }
+      if (typeof type === "object" && !Array.isArray(type)) {
+        descriptor = type[prop];
+
+        // No type rule for this property
+        if (!descriptor) {
+          descriptor = null;
+        }
+      }
+
+      if (descriptor) {
+        // Allow shorthand:
+        // "string"
+        // or
+        // { value: "string", ... }
+        if (typeof descriptor === "string") {
+          descriptor = {
+            value: descriptor,
+          };
+        }
+
+        const expected = descriptor.value;
+
+        let actual;
+
+        if (expected === "array") {
+          actual = Array.isArray(data_value) ? "array" : typeof data_value;
+        } else {
+          actual = typeof data_value;
+        }
+
+        if (actual !== expected) {
           return {
             ok: false,
-            message: `Field '${prop}' must be of type '${type}' got '${type_of}'`,
+            message: `Field '${prop}' must be of type '${expected}', got '${actual}'`,
           };
+        }
       }
     }
 
+    // enum validation
+    if (
+      data_value !== undefined &&
+      data_value !== null &&
+      allowed &&
+      !allowed.includes(data_value)
+    ) {
+      return {
+        ok: false,
+        message: `Field '${prop}' must be one of: ${allowed.join(", ")}`,
+      };
+    }
+
     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,
-              );
+    for (const section of Object.keys(schema)) {
+      const rules = schema[section];
+      const target = data[section] || {};
+
+      for (const prop in rules) {
+        const rule = rules[prop];
+
+        if (prop === "$logic") {
+          // OR logic
+          if (rule.or) {
+            for (const orRule of rule.or) {
+              let passed = false;
+
+              for (const property of orRule.properties) {
+                const result = await this.check_validation(
+                  { prop: property, ...orRule },
+                  target,
+                );
+
+                if (result.ok) {
+                  passed = true;
+                  break;
+                }
+              }
 
-              if (and_rule.required && !and_rule_check?.ok) {
+              if (orRule.required && !passed) {
                 return {
                   ok: false,
-                  message: `Field '${prop}' is required`,
+                  message: `At least one of the following fields is required: ${orRule.properties.join(
+                    ", ",
+                  )}`,
                 };
               }
             }
           }
+
+          // AND logic
+          if (rule.and) {
+            for (const andRule of rule.and) {
+              for (const property of andRule.properties) {
+                const result = await this.check_validation(
+                  { prop: property, ...andRule },
+                  target,
+                );
+
+                if (!result.ok) {
+                  return result;
+                }
+              }
+            }
+          }
+
+          continue;
         }
-      }
 
-      let validation_result = await this.check_validation(
-        { prop, ...rule },
-        data_body,
-      );
+        const result = await this.check_validation({ prop, ...rule }, target);
 
-      if (!validation_result.ok) {
-        return validation_result;
+        if (!result.ok) {
+          return result;
+        }
       }
     }
 

package/server/Routable/Services.js

@@ -34,6 +34,7 @@ class Services {
   constructor() {
     this.services = new Object();
 
+    this.dbs = new Object();
     this.load_services(gp_services);
   }
 
@@ -46,18 +47,14 @@ class Services {
   get_token = async (service, id) => {
     let token;
 
-    // debug(service, id, "gettok");
     let db = await this.platform_db();
     token = await db.read_cache(
       { platform_uri: service.uri, id: id.profile },
       "token",
     );
 
-    // debug(token, "in-cache");
     if (token) return token.token;
     try {
-      // debug(this.api_key, gp_services.profile);
-
       let gp_profile = gp_services().profile;
       let ftch = await fetch(`${gp_profile.url}/get_token`, {
         method: "POST",
@@ -70,9 +67,7 @@ class Services {
         body: JSON.stringify({ platform_uri: service.uri, ...id }),
       });
 
-      // debug("whats it like??");
       token = await ftch.json();
-      // debug(token, "HOOWWW");
 
       if (token?.ok) {
         await db.save_cache(
@@ -100,6 +95,7 @@ class Services {
     if (!servic) return;
 
     return {
+      uri: servic.uri,
       call: async (path, body, header) => {
         let headers = {
           "Content-Type": "application/json",
@@ -107,7 +103,9 @@ class Services {
           "x-api-version": servic.api_version || "v1",
         };
         let token;
-        if (header?.token || header?.profile) {
+        if (servic.profile_key) {
+          headers["Authorization"] = `${servic.profile_key}`;
+        } else if (header?.token || header?.profile) {
           if (header.token) {
             token = header.token;
           } else if (header.profile) {
@@ -156,11 +154,21 @@ class Services {
   };
 
   platform_db = async () => {
-    if (this.db) return this.db;
+    let prefix = this.db_prefix,
+      name = this.db_name || this.db_config.name;
+
+    if (prefix) {
+      name = `${prefix}:${name}`;
+    }
 
-    this.db = new DB(this.db_config, this);
+    let db = this.dbs[name];
+    if (!db) {
+      db = new DB({ ...this.db_config, name }, this);
+
+      this.dbs[name] = db;
+    }
 
-    return this.db;
+    return db;
   };
 
   handle_webhook_prior = async (req) => {

package/server/version_control.js

@@ -35,6 +35,7 @@ const applyCors = (req, res) => {
   res.setHeader(
     "Access-Control-Allow-Headers",
     "Content-Type, Authorization, x-api-version, x-api-key, x-platform",
+    "x-secret",
   );
 
   // IMPORTANT: do NOT enable credentials with "*"
@@ -75,6 +76,10 @@ const respond = (result, res) => {
     response.token = result.token;
   }
 
+  if (result?.next) {
+    response.next = result.next;
+  }
+
   const status = result?.status || (result?.ok ? 200 : 403);
 
   res.statusCode = status;