godprotocol 2.3.46 → 2.3.50

package/package.json

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

package/server/Routable/Route_table.js

@@ -8,6 +8,28 @@ let securities = {
   none: [],
 };
 
+// Sections whose raw values arrive as strings (URLSearchParams / regex
+const STRINGY_SECTIONS = ["query", "params"];
+
+// Supported arithmetic operators (value-level)
+const ARITH_OPS = {
+  min: (a, b) => a >= b,
+  max: (a, b) => a <= b,
+  gt: (a, b) => a > b,
+  gte: (a, b) => a >= b,
+  lt: (a, b) => a < b,
+  lte: (a, b) => a <= b,
+  eq: (a, b) => a === b,
+  ne: (a, b) => a !== b,
+};
+
+// Length variants (work on string / array / object)
+const LENGTH_OPS = {
+  minLength: (a, b) => (a?.length ?? Object.keys(a || {}).length) >= b,
+  maxLength: (a, b) => (a?.length ?? Object.keys(a || {}).length) <= b,
+  length: (a, b) => (a?.length ?? Object.keys(a || {}).length) === b,
+};
+
 class Route_table extends Headers {
   constructor(gp) {
     super();
@@ -36,7 +58,6 @@ class Route_table extends Headers {
     for (const callback of this.before_callbacks) {
       const result = await callback(payload);
 
-      // allow middleware-style rejection
       if (result && result.ok === false) {
         return result;
       }
@@ -81,7 +102,13 @@ class Route_table extends Headers {
   };
 
   init_version = async (version, config) => {
-    this.versions[version] = { config, routes: {} };
+    this.versions[version] = {
+      config,
+      routes: {},
+      param_routes: [],
+      regex_routes: [],
+      wildcard: null,
+    };
 
     this.active_version = version;
   };
@@ -117,109 +144,378 @@ class Route_table extends Headers {
     }
   };
 
+  // =========================
+  // 🧭 ROUTE PATTERN COMPILATION
+  // =========================
+  compile_route_pattern = (pattern) => {
+    const keys = [];
+
+    const segments = pattern.split("/");
+
+    const regex_parts = segments.map((segment) => {
+      if (segment.startsWith(":")) {
+        keys.push(segment.slice(1));
+        return "([^/]+)";
+      }
+
+      if (segment === "*") {
+        keys.push("*");
+        return "(.*)";
+      }
+
+      return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    });
+
+    return {
+      regex: new RegExp(`^${regex_parts.join("/")}$`),
+      keys,
+    };
+  };
+
   add_route = async (name, handler, config) => {
-    this.versions[this.active_version].routes[name] = { handler, config };
+    const version = this.versions[this.active_version];
+
+    version.routes[name] = { handler, config };
+
+    if (name === "*") {
+      version.wildcard = { handler, config, route_pattern: name };
+      return;
+    }
+
+    if (name.startsWith("^")) {
+      version.regex_routes.push({
+        pattern: name,
+        regex: new RegExp(name),
+        handler,
+        config,
+      });
+      return;
+    }
+
+    if (name.includes(":") || name.includes("*")) {
+      const { regex, keys } = this.compile_route_pattern(name);
+
+      version.param_routes.push({
+        pattern: name,
+        regex,
+        keys,
+        handler,
+        config,
+      });
+    }
   };
 
+  // =========================
+  // 🔎 ROUTE RESOLUTION
+  // Precedence: exact -> named param -> regex -> wildcard
+  // =========================
   get_route = async (name) => {
     const version = this.versions[this.active_version];
 
+    if (!version) return null;
+
     if (version.routes[name]) {
-      return version.routes[name];
+      return {
+        ...version.routes[name],
+        params: {},
+        route_pattern: name,
+      };
     }
 
-    for (const [pattern, route] of Object.entries(version.routes)) {
-      if (pattern.startsWith("^")) {
-        if (new RegExp(pattern).test(name)) {
-          return route;
-        }
+    for (const route of version.param_routes) {
+      const match = route.regex.exec(name);
+
+      if (match) {
+        const params = {};
+
+        route.keys.forEach((key, i) => {
+          params[key] = decodeURIComponent(match[i + 1]);
+        });
+
+        return {
+          handler: route.handler,
+          config: route.config,
+          params,
+          route_pattern: route.pattern,
+        };
       }
     }
 
+    for (const route of version.regex_routes) {
+      if (route.regex.test(name)) {
+        return {
+          handler: route.handler,
+          config: route.config,
+          params: {},
+          route_pattern: route.pattern,
+        };
+      }
+    }
+
+    if (version.wildcard) {
+      return { ...version.wildcard, params: {} };
+    }
+
     return null;
   };
 
   getValue = (obj, path) => path.split(".").reduce((o, key) => o?.[key], obj);
 
-  check_validation = async (rule, data) => {
-    let { prop, type, required, enum: allowed } = rule;
+  // =========================
+  // 🔁 TYPE COERCION (query / params only)
+  // =========================
+  coerce_value = (value, expected) => {
+    if (value === null || value === undefined) return { ok: false };
+
+    switch (expected) {
+      case "number": {
+        if (typeof value === "number") return { ok: true, value };
+        if (typeof value !== "string" || value.trim() === "")
+          return { ok: false };
+        const n = Number(value);
+        if (Number.isNaN(n)) return { ok: false };
+        return { ok: true, value: n };
+      }
+
+      case "boolean": {
+        if (typeof value === "boolean") return { ok: true, value };
+        if (value === "true") return { ok: true, value: true };
+        if (value === "false") return { ok: true, value: false };
+        return { ok: false };
+      }
 
+      case "array": {
+        if (Array.isArray(value)) return { ok: true, value };
+        try {
+          const parsed = JSON.parse(value);
+          if (Array.isArray(parsed)) return { ok: true, value: parsed };
+        } catch (_) {}
+        if (typeof value === "string" && value.length) {
+          return { ok: true, value: value.split(",").map((v) => v.trim()) };
+        }
+        return { ok: false };
+      }
+
+      case "object": {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          return { ok: true, value };
+        }
+        try {
+          const parsed = JSON.parse(value);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return { ok: true, value: parsed };
+          }
+        } catch (_) {}
+        return { ok: false };
+      }
+
+      case "string":
+        return { ok: true, value: String(value) };
+
+      default:
+        return { ok: false };
+    }
+  };
+
+  /**
+   * Deep validation of a single field (or nested structure).
+   * Supports:
+   *  - type
+   *  - required / default_value
+   *  - enum
+   *  - pattern (RegExp or string)
+   *  - arithmetic operators (min, max, gt, gte, lt, lte, eq, ne)
+   *  - length operators (minLength, maxLength, length)
+   *  - nested schema (for object)
+   *  - items schema (for array)
+   *  - custom validator name (via this.validators)
+   */
+  check_validation = async (rule, data, path = "") => {
+    let {
+      prop,
+      section,
+      type,
+      required = false,
+      enum: allowed,
+      pattern,
+      schema, // nested object schema
+      items, // array item schema
+      validator, // custom named validator
+      default_value,
+      ...rest // arithmetic + length ops land here
+    } = rule;
+
+    const fullPath = path ? `${path}.${prop}` : prop;
     let data_value = this.getValue(data, prop);
 
-    if (data_value === undefined && rule.hasOwnProperty("default_value")) {
-      data_value = rule.default_value;
-      data[prop] = data_value;
+    // ---------- default ----------
+    if (
+      data_value === undefined &&
+      Object.prototype.hasOwnProperty.call(rule, "default_value")
+    ) {
+      data_value = default_value;
+      // write back so later stages see the default
+      const parts = prop.split(".");
+      let cur = data;
+      for (let i = 0; i < parts.length - 1; i++) {
+        if (cur[parts[i]] == null) cur[parts[i]] = {};
+        cur = cur[parts[i]];
+      }
+      cur[parts[parts.length - 1]] = data_value;
     }
 
+    // ---------- required ----------
     if (data_value === undefined || data_value === null) {
       if (required) {
         return {
           ok: false,
-          message: `Field '${prop}' is required`,
+          message: `Field '${fullPath}' is required in '${section}'`,
+          path: fullPath,
         };
       }
       return { ok: true };
     }
 
-    // type validation
-    // =========================
-    // Type validation
-    // =========================
+    // ---------- resolve type descriptor ----------
+    let expected = type;
+    if (typeof type === "object" && type !== null && !Array.isArray(type)) {
+      expected = type.value ?? type;
+    }
 
-    if (type) {
-      let descriptor = type;
+    // ---------- coercion (query / params only) ----------
+    if (
+      STRINGY_SECTIONS.includes(section) &&
+      expected &&
+      expected !== "string" &&
+      typeof data_value === "string"
+    ) {
+      const coerced = this.coerce_value(data_value, expected);
+      if (!coerced.ok) {
+        return {
+          ok: false,
+          message: `Field '${fullPath}' in '${section}' could not be parsed as type '${expected}'`,
+          path: fullPath,
+        };
+      }
+      data_value = coerced.value;
+      // write coerced value back
+      const parts = prop.split(".");
+      let cur = data;
+      for (let i = 0; i < parts.length - 1; i++) {
+        cur = cur[parts[i]];
+      }
+      cur[parts[parts.length - 1]] = data_value;
+    }
 
-      // 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];
+    // ---------- base type check ----------
+    if (expected) {
+      const actual = Array.isArray(data_value) ? "array" : typeof data_value;
+      if (actual !== expected) {
+        return {
+          ok: false,
+          message: `Field '${fullPath}' in '${section}' must be of type '${expected}', got '${actual}'`,
+          path: fullPath,
+        };
+      }
+    }
 
-        // No type rule for this property
-        if (!descriptor) {
-          descriptor = null;
-        }
+    // ---------- enum ----------
+    if (allowed && !allowed.includes(data_value)) {
+      return {
+        ok: false,
+        message: `Field '${fullPath}' in '${section}' must be one of: ${allowed.join(", ")}`,
+        path: fullPath,
+      };
+    }
+
+    // ---------- regex / pattern ----------
+    if (pattern) {
+      const re = pattern instanceof RegExp ? pattern : new RegExp(pattern);
+      if (typeof data_value !== "string" || !re.test(data_value)) {
+        return {
+          ok: false,
+          message: `Field '${fullPath}' in '${section}' does not match required pattern`,
+          path: fullPath,
+        };
       }
+    }
 
-      if (descriptor) {
-        // Allow shorthand:
-        // "string"
-        // or
-        // { value: "string", ... }
-        if (typeof descriptor === "string") {
-          descriptor = {
-            value: descriptor,
+    // ---------- arithmetic operators ----------
+    for (const [op, fn] of Object.entries(ARITH_OPS)) {
+      if (rest[op] !== undefined) {
+        if (typeof data_value !== "number") {
+          return {
+            ok: false,
+            message: `Field '${fullPath}' must be a number to apply '${op}'`,
+            path: fullPath,
           };
         }
+        if (!fn(data_value, rest[op])) {
+          return {
+            ok: false,
+            message: `Field '${fullPath}' failed '${op}' constraint (expected ${op} ${rest[op]}, got ${data_value})`,
+            path: fullPath,
+          };
+        }
+      }
+    }
 
-        const expected = descriptor.value;
-
-        let actual;
-
-        let actual = Array.isArray(data_value) ? "array" : typeof data_value;
-
-        if (actual !== expected) {
+    // ---------- length operators ----------
+    for (const [op, fn] of Object.entries(LENGTH_OPS)) {
+      if (rest[op] !== undefined) {
+        if (!fn(data_value, rest[op])) {
           return {
             ok: false,
-            message: `Field '${prop}' must be of type '${expected}', got '${actual}'`,
+            message: `Field '${fullPath}' failed '${op}' constraint (expected ${op} ${rest[op]})`,
+            path: fullPath,
           };
         }
       }
     }
 
-    // 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(", ")}`,
-      };
+    // ---------- nested object schema ----------
+    if (expected === "object" && schema) {
+      for (const [nestedProp, nestedRule] of Object.entries(schema)) {
+        const result = await this.check_validation(
+          { prop: nestedProp, section, ...nestedRule },
+          data_value,
+          fullPath,
+        );
+        if (!result.ok) return result;
+      }
+    }
+
+    // ---------- array items schema ----------
+    if (expected === "array" && items) {
+      if (!Array.isArray(data_value)) {
+        return {
+          ok: false,
+          message: `Field '${fullPath}' must be an array`,
+          path: fullPath,
+        };
+      }
+      for (let i = 0; i < data_value.length; i++) {
+        const result = await this.check_validation(
+          { prop: String(i), section, ...items },
+          { [String(i)]: data_value[i] },
+          `${fullPath}[${i}]`,
+        );
+        if (!result.ok) return result;
+      }
+    }
+
+    // ---------- custom validator ----------
+    if (validator && this.validators[validator]) {
+      const result = await this.validators[validator](data_value, rule, data);
+      if (result && result.ok === false) {
+        return {
+          ok: false,
+          message:
+            result.message ||
+            `Custom validator '${validator}' failed for '${fullPath}'`,
+          path: fullPath,
+        };
+      }
     }
 
     return { ok: true };
@@ -233,47 +529,45 @@ class Route_table extends Headers {
       for (const prop in rules) {
         const rule = rules[prop];
 
+        // ---------- $logic (or / and) ----------
         if (prop === "$logic") {
-          // OR logic
+          // OR groups: at least one of the listed properties must satisfy the constraints
           if (rule.or) {
             for (const orRule of rule.or) {
               let passed = false;
+              const failedProps = [];
 
               for (const property of orRule.properties) {
                 const result = await this.check_validation(
-                  { prop: property, ...orRule },
+                  { prop: property, section, ...orRule },
                   target,
                 );
-
                 if (result.ok) {
                   passed = true;
                   break;
                 }
+                failedProps.push(property);
               }
 
               if (orRule.required && !passed) {
                 return {
                   ok: false,
-                  message: `At least one of the following fields is required: ${orRule.properties.join(
-                    ", ",
-                  )}`,
+                  message: `At least one of the following fields is required in '${section}': ${orRule.properties.join(", ")}`,
+                  path: `$logic.or`,
                 };
               }
             }
           }
 
-          // AND logic
+          // AND groups: every listed property must satisfy the constraints
           if (rule.and) {
             for (const andRule of rule.and) {
               for (const property of andRule.properties) {
                 const result = await this.check_validation(
-                  { prop: property, ...andRule },
+                  { prop: property, section, ...andRule },
                   target,
                 );
-
-                if (!result.ok) {
-                  return result;
-                }
+                if (!result.ok) return result;
               }
             }
           }
@@ -281,11 +575,12 @@ class Route_table extends Headers {
           continue;
         }
 
-        const result = await this.check_validation({ prop, ...rule }, target);
-
-        if (!result.ok) {
-          return result;
-        }
+        // ---------- normal field ----------
+        const result = await this.check_validation(
+          { prop, section, ...rule },
+          target,
+        );
+        if (!result.ok) return result;
       }
     }
 
@@ -295,7 +590,7 @@ class Route_table extends Headers {
   get_route_config = async (name) => {
     let route = await this.get_route(name);
 
-    return route.config;
+    return route?.config;
   };
 
   // =========================
@@ -311,20 +606,23 @@ class Route_table extends Headers {
     let route = await this.get_route(name);
 
     if (!route) {
-      route = await this.get_route("*");
-      if (!route) {
-        return {
-          ok: false,
-          status: 404,
-          message: "Route not found",
-          data: { path: `/${name}`, name },
-        };
-      }
+      return {
+        ok: false,
+        status: 404,
+        message: "Route not found",
+        data: { path: `/${name}`, name },
+      };
     }
 
-    let { handler, config } = route;
+    const { handler, config, params = {}, route_pattern } = route;
+
+    payload.params = params;
+    payload.route_pattern = route_pattern;
+
+    if (payload.req) {
+      payload.req.params = params;
+    }
 
-    // 📜 schema
     if (config.schema) {
       let resp = await this.validate(config.schema, payload);
 
@@ -334,14 +632,13 @@ class Route_table extends Headers {
             endpoint: name,
             args: payload.body,
             response: resp,
-            conversation: payload.headers.meta.conversation_id,
+            conversation: payload.headers?.meta?.conversation_id,
           });
         }
         return resp;
       }
     }
 
-    // ⚙️ middleware
     for (let middleware of config.middlewares || []) {
       let result = await middleware(payload);
       if (!result?.ok) {
@@ -350,22 +647,19 @@ class Route_table extends Headers {
             endpoint: name,
             args: payload.body,
             response: result,
-            // conversation: payload.headers.meta.conversation_id,
           });
         }
         return result;
       }
     }
 
-    // 🎯 handler
     let response = await handler(payload);
-    if (response.agent) {
+    if (response?.agent) {
       await this.call_agency(
         {
           endpoint: name,
           args: payload.body,
           response,
-          // conversation: payload.headers.meta.conversation_id,
         },
         response.agent,
       );

package/server/version_control.js

@@ -64,10 +64,14 @@ const respond = (result, res) => {
 
   const response = {
     ok: result?.ok ?? false,
-    message: result?.message ?? "",
-    data: result?.data,
   };
 
+  if (result?.message) {
+    response.message = result.message;
+  }
+
+  response.data = result?.data;
+
   if (result?.pagination) {
     response.pagination = result.pagination;
   }
@@ -111,6 +115,10 @@ const version_middleware = async (req, res, routers) => {
     const parsed_url = new URL(req.url, `http://${req.headers.host}`);
     const pathname = parsed_url.pathname;
 
+    // ⬇️ query params captured for every method now
+    const query = Object.fromEntries(parsed_url.searchParams.entries());
+    req.query = query;
+
     req.request_id = crypto.randomUUID();
     routers.gp?.resource?.incoming_request(req);
     res.gp = routers.gp;
@@ -119,7 +127,7 @@ const version_middleware = async (req, res, routers) => {
     // STATIC ROUTE DETECTION
     let version;
 
-    const versionMatch = pathname.match(/^\/api\/(v\d+)(\/|$)/i);
+    const versionMatch = pathname.match(/^\/api\/([^\/]+)(\/|$)/i);
     if (req.method === "GET") {
       if (routers.static_path && pathname.startsWith(routers.static_path)) {
         res.gp = routers.gp;
@@ -159,9 +167,8 @@ const version_middleware = async (req, res, routers) => {
     let body = {};
 
     if (req.method === "GET") {
-      const url = new URL(req.url, `http://${req.headers.host}`);
-
-      body = Object.fromEntries(url.searchParams.entries());
+      // GET keeps existing behavior: query params double as body
+      body = query;
     } else {
       const contentType = req.headers["content-type"] || "";
 
@@ -181,12 +188,10 @@ const version_middleware = async (req, res, routers) => {
     const router = routers;
 
     // remove query string from route
-    const parsedUrl = new URL(req.url, `http://${req.headers.host}`);
-
-    let routePath = parsedUrl.pathname;
+    let routePath = pathname;
 
-    // Remove /api/v1, /api/v2, /api/v3, etc.
-    routePath = routePath.replace(/^\/api\/v\d+(?=\/|$)/i, "");
+    // Remove /api/<version>
+    routePath = routePath.replace(/^\/api\/[^\/]+(?=\/|$)/i, "");
 
     // Ensure leading slash exists
     if (!routePath.startsWith("/")) {
@@ -195,7 +200,7 @@ const version_middleware = async (req, res, routers) => {
 
     req.url = routePath;
 
-    const name = routePath.replace(/^\//, "");
+    let name = routePath.replace(/^\//, "");
 
     const isWebhook = req.headers["is-webhook"];
 
@@ -215,6 +220,7 @@ const version_middleware = async (req, res, routers) => {
       {
         req,
         body,
+        query,
         route: name,
         db: db.db,
       },
@@ -225,6 +231,8 @@ const version_middleware = async (req, res, routers) => {
 
     if (callback?.body) body = callback.body;
 
+    if (callback?.query) query = callback.query; // only if you make `query` a `let` — see note below
+
     if (callback?.headers) req.headers = callback.headers;
 
     if (callback?.db) db.db = callback.db;
@@ -234,12 +242,15 @@ const version_middleware = async (req, res, routers) => {
     error_stage = "Handler";
     let payload = {
       body,
+      query,
       route: name,
       headers: req.headers,
+      req,
       db: db.db,
       gp: router.gp,
       services: router.get_service,
       method: req.method,
+      params: {},
       memory: router.gp.memory,
     };
     const result = await router.execute(name, payload);