godprotocol 2.3.55 → 2.3.57

package/package.json

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

@@ -247,15 +247,15 @@ class Headers extends Services {
     return requirements.every((r) => checks[r]?.());
   };
 
-  handle_security = async (name, request) => {
+  handle_security = async (name, request, version = this.active_version) => {
     let config;
-    if (this.active_version === "*") {
-      let version = this.versions[this.active_version];
+    if (version === "*") {
+      let version = this.versions[version];
 
       config = version.config;
     }
 
-    let route = await this.get_route(name);
+    let route = await this.get_route(name, version);
 
     if (!route) {
       route = await this.get_route("*");

package/server/Routable/Route_table.js

@@ -75,30 +75,38 @@ class Route_table extends Headers {
   };
 
   get_version = async (version = this.active_version) => {
-    let ver = this.versions[version];
+    let resolved_version = version;
+
+    let ver = this.versions[resolved_version];
 
     if (!ver) {
-      let versions = Object.keys(this.versions);
-      let verr = versions.find((v) => v.startsWith(`${version}:`));
+      const versions = Object.keys(this.versions);
+
+      const verr = versions.find((v) => v.startsWith(`${version}:`));
 
       if (verr) {
-        let serv = await this.get_service(version);
+        const serv = await this.get_service(version);
+
         if (serv) {
-          version = `${version}:${serv.api_version}`;
-          ver = this.versions[version];
+          resolved_version = `${version}:${serv.api_version}`;
+          ver = this.versions[resolved_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;
+    if (!ver) return;
 
-    return ver;
+    return {
+      ...ver,
+      version: resolved_version,
+      db_name:
+        ver.config?.db_name === true ? resolved_version : ver.config?.db_name,
+
+      db_prefix:
+        ver.config?.db_prefix === true
+          ? resolved_version
+          : ver.config?.db_prefix,
+    };
   };
 
   init_version = async (version, config) => {
@@ -209,8 +217,8 @@ class Route_table extends Headers {
   // 🔎 ROUTE RESOLUTION
   // Precedence: exact -> named param -> regex -> wildcard
   // =========================
-  get_route = async (name) => {
-    const version = this.versions[this.active_version];
+  get_route = async (name, version_name = this.active_version) => {
+    const version = this.versions[version_name];
 
     if (!version) return null;
 
@@ -587,30 +595,29 @@ class Route_table extends Headers {
     return { ok: true };
   };
 
-  get_route_config = async (name) => {
-    let route = await this.get_route(name);
-
+  get_route_config = async (name, version_name = this.active_version) => {
+    const route = await this.get_route(name, version_name);
     return route?.config;
   };
 
   // =========================
   // 🚀 EXECUTION PIPELINE
   // =========================
-  execute = async (name, payload) => {
-    if (this.active_version === "*") {
-      let version = this.versions[this.active_version];
+  execute = async (name, payload, version_name = this.active_version) => {
+    if (version_name === "*") {
+      let version = this.versions[version_name];
 
       return await version.handler(payload);
     }
 
-    let route = await this.get_route(name);
+    let route = await this.get_route(name, version_name);
 
     if (!route) {
       return {
         ok: false,
         status: 404,
         message: "Route not found",
-        data: { path: `/${name}`, name },
+        data: { path: `/${name}`, name, version: version_name },
       };
     }
 
@@ -621,6 +628,7 @@ class Route_table extends Headers {
 
     if (payload.req) {
       payload.req.params = params;
+      payload.req.api_version = version_name;
     }
 
     if (config.schema) {

package/server/Routable/Services.js

@@ -248,8 +248,8 @@ class Services {
     }
   };
 
-  resolve_db = async (req) => {
-    let db = await this.platform_db();
+  resolve_db = async (req, opts = {}) => {
+    let db = await this.platform_db(opts?.db_name);
 
     return {
       ok: true,

package/server/version_control.js

@@ -43,24 +43,144 @@ const applyCors = (req, res) => {
 };
 
 const respond = (result, res) => {
-  // ----------------------------
-  // REDIRECT
-  // ----------------------------
+  /*
+   * ------------------------------------------------------------------------
+   * REDIRECT
+   * ------------------------------------------------------------------------
+   */
 
   if (result?.redirect) {
     const status = result?.status || 302;
 
     res.statusCode = status;
+
     res.setHeader("Location", result.redirect);
 
     res.end();
 
+    res.gp?.resource?.compute_response?.(res);
+
     return result;
   }
 
-  // ----------------------------
-  // NORMAL JSON RESPONSE
-  // ----------------------------
+  /*
+   * ------------------------------------------------------------------------
+   * STREAM
+   * ------------------------------------------------------------------------
+   *
+   * A stream response bypasses JSON serialization completely.
+   *
+   * Expected:
+   *
+   * {
+   *   ok: true,
+   *   type: "stream",
+   *   data: {
+   *     stream,
+   *     content_type,
+   *     content_length,
+   *     etag
+   *   }
+   * }
+   *
+   * ------------------------------------------------------------------------
+   */
+
+  if (result?.status === 206 && result?.data?.stream) {
+    const { stream, content_type, content_length, etag, filename } =
+      result.data;
+
+    /*
+     * Status
+     */
+
+    res.statusCode = result?.status || 206;
+
+    /*
+     * Content type
+     */
+
+    res.setHeader("Content-Type", content_type || "application/octet-stream");
+
+    /*
+     * Content length
+     */
+
+    if (content_length !== undefined && content_length !== null) {
+      res.setHeader("Content-Length", content_length);
+    }
+
+    /*
+     * ETag
+     */
+
+    if (etag) {
+      res.setHeader("ETag", etag);
+    }
+
+    /*
+     * Optional filename
+     */
+
+    if (filename) {
+      res.setHeader("Content-Disposition", `inline; filename="${filename}"`);
+    }
+
+    /*
+     * Stream errors
+     */
+
+    stream.on("error", (error) => {
+      console.error("Response stream error:", error);
+
+      if (!res.headersSent) {
+        res.statusCode = 500;
+
+        res.setHeader("Content-Type", "application/json");
+
+        return res.end(
+          JSON.stringify({
+            ok: false,
+            message: "Failed to stream file",
+          }),
+        );
+      }
+
+      /*
+       * Headers have already been sent.
+       *
+       * At this point the response cannot safely
+       * be converted into a JSON error response.
+       *
+       * Destroy the response.
+       */
+
+      res.destroy(error);
+    });
+
+    /*
+     * Complete response metrics only after
+     * the stream has finished.
+     */
+
+    res.on("finish", () => {
+      res.gp?.resource?.compute_response?.(res);
+    });
+
+    /*
+     * Pipe file into HTTP response.
+     */
+
+    stream.pipe(res);
+
+    return true;
+  }
+
+  /*
+   * ------------------------------------------------------------------------
+   * NORMAL JSON RESPONSE
+   * ------------------------------------------------------------------------
+   */
 
   const response = {
     ok: result?.ok ?? false,
@@ -96,7 +216,7 @@ const respond = (result, res) => {
 
   res.end(JSON.stringify(response));
 
-  res.gp?.resource?.compute_response(res);
+  res.gp?.resource?.compute_response?.(res);
 
   return response;
 };
@@ -151,9 +271,10 @@ const version_middleware = async (req, res, routers) => {
 
     if (!versionRouter) {
       version = "*";
+
       versionRouter = await routers.get_version(version);
 
-      if (!versionRouter)
+      if (!versionRouter) {
         return respond(
           {
             ok: false,
@@ -162,8 +283,11 @@ const version_middleware = async (req, res, routers) => {
           },
           res,
         );
+      }
     }
 
+    version = versionRouter.version;
+
     let body = {};
 
     if (req.method === "GET") {
@@ -206,14 +330,18 @@ const version_middleware = async (req, res, routers) => {
 
     // SECURITY
     error_stage = "Header";
-    const securityResult = await router.handle_security(name, req);
+    const securityResult = await router.handle_security(name, req, version);
 
     if (securityResult !== true) {
       return respond(securityResult, res);
     }
 
     // DB
-    const db = await router.resolve_db(req);
+    const db = await router.resolve_db(req, {
+      version,
+      db_name: versionRouter.db_name,
+      db_prefix: versionRouter.db_prefix,
+    });
 
     // WEBHOOK PRIOR
     const callback = await router.handle_before(
@@ -254,7 +382,7 @@ const version_middleware = async (req, res, routers) => {
       params: {},
       memory: router.gp.memory,
     };
-    const result = await router.execute(name, payload);
+    const result = await router.execute(name, payload, version);
 
     // WEBHOOK AFTER
     if (!isWebhook && version !== "*") {