godprotocol 2.2.67 → 2.2.70

package/package.json

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

package/server/version_control.js

@@ -39,25 +39,52 @@ const applyCors = (req, res) => {
 };
 
 const respond = (result, res) => {
+  // ----------------------------
+  // REDIRECT
+  // ----------------------------
+
+  if (result?.redirect) {
+    const status = result?.status || 302;
+
+    res.statusCode = status;
+    res.setHeader("Location", result.redirect);
+
+    res.end();
+
+    return result;
+  }
+
+  // ----------------------------
+  // NORMAL JSON RESPONSE
+  // ----------------------------
+
   const response = {
     ok: result?.ok ?? false,
     message: result?.message ?? "",
     data: result?.data,
   };
 
-  if (result?.pagination) response.pagination = result.pagination;
-  if (result?.token) response.token = result.token;
+  if (result?.pagination) {
+    response.pagination = result.pagination;
+  }
+
+  if (result?.token) {
+    response.token = result.token;
+  }
 
   const status = result?.status || (result?.ok ? 200 : 403);
 
   res.statusCode = status;
+
   res.setHeader("Content-Type", "application/json");
+
   res.end(JSON.stringify(response));
 
   return response;
 };
 
 const version_middleware = async (req, res, routers) => {
+  let error_stage = "Version Middleware";
   try {
     applyCors(req, res);
 
@@ -66,67 +93,80 @@ const version_middleware = async (req, res, routers) => {
       return res.end();
     }
 
-    const version = req.headers["x-api-version"] || "v1";
+    let version;
 
-    const versionRouter = routers.get_version(version);
-    // ----------------------------
-    // BODY (STREAM PARSE)
-    // ----------------------------
-    const body = await getBody(req);
+    if (req.method === "GET") {
+      version = "__GET__";
+    } else {
+      version = req.headers["x-api-version"] || "v1";
+    }
+
+    const versionRouter = await routers.get_version(version);
 
     if (!versionRouter) {
-      res.statusCode = 400;
-      res.setHeader("Content-Type", "application/json");
-      return res.end(
-        JSON.stringify({
+      return respond(
+        {
           ok: false,
           message: "Invalid API version",
-        }),
+          status: 400,
+        },
+        res,
       );
     }
 
+    let body = {};
+
+    if (req.method === "GET") {
+      const url = new URL(req.url, `http://${req.headers.host}`);
+
+      body = Object.fromEntries(url.searchParams.entries());
+    } else {
+      error_stage = "Body Parser";
+      body = await getBody(req);
+    }
+
     if (versionRouter.config?.is_old) {
       req.body = body;
       return versionRouter.routes(req, res);
     }
 
     const router = routers;
+
+    // remove query string from route
+    const parsedUrl = new URL(req.url, `http://${req.headers.host}`);
+    req.url = parsedUrl.pathname;
     const name = req.url.replace(/^\//, "");
 
     const isWebhook = req.headers["is-webhook"];
 
-    // ----------------------------
     // SECURITY
-    // ----------------------------
+    error_stage = "Header";
     const securityResult = await router.handle_security(name, req);
 
     if (securityResult !== true) {
       return respond(securityResult, res);
     }
 
-    // ----------------------------
     // DB
-    // ----------------------------
     const db = await router.resolve_db(req);
 
-    // ----------------------------
     // WEBHOOK PRIOR
-    // ----------------------------
     if (!isWebhook) {
-      const webPrior = await router.handle_webhook_prior({ ...req, body });
+      error_stage = "Callback";
+      const webPrior = await router.handle_webhook_prior({
+        ...req,
+        body,
+      });
 
       if (!webPrior?.ok) {
         return respond(webPrior, res);
       }
 
-      if (webPrior?.ok) {
-        req.headers.webhook_prior = webPrior;
-      }
+      req.headers.webhook_prior = webPrior;
     }
 
-    // ----------------------------
     // EXECUTE
-    // ----------------------------
+    error_stage = "Handler";
     const result = await router.execute(name, {
       body,
       route: name,
@@ -134,26 +174,26 @@ const version_middleware = async (req, res, routers) => {
       db: db.db,
       gp: router.gp,
       services: router.get_service,
+      method: req.method,
     });
 
-    // ----------------------------
     // WEBHOOK AFTER
-    // ----------------------------
     if (!isWebhook) {
+      error_stage = "Webhook";
       await router.handle_webhook_after(req, result);
     }
 
     return respond(result, res);
   } catch (err) {
-    console.error("Version Middleware Error:", err);
+    console.error(`${error_stage} Error:`, err);
 
-    res.statusCode = 500;
-    res.setHeader("Content-Type", "application/json");
-    res.end(
-      JSON.stringify({
+    return respond(
+      {
         ok: false,
         message: "Internal server error",
-      }),
+        status: 500,
+      },
+      res,
     );
   }
 };