godprotocol 2.2.58 → 2.2.59

package/package.json

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

@@ -1,91 +1,133 @@
-const respond = async (result, res) => {
-  let response = {
-    ok: result?.ok,
-    message: result.message,
-    data: result.data,
+const getBody = (req) => {
+  return new Promise((resolve, reject) => {
+    let data = "";
+
+    req.on("data", (chunk) => {
+      data += chunk;
+    });
+
+    req.on("end", () => {
+      try {
+        const parsed = data ? JSON.parse(data) : {};
+        resolve(parsed);
+      } catch (err) {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+
+    req.on("error", (err) => {
+      reject(err);
+    });
+  });
+};
+
+const respond = (result, res) => {
+  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 (!res) return response;
+  if (result?.pagination) response.pagination = result.pagination;
+  if (result?.token) response.token = result.token;
 
-  res.status(result?.status || (result?.ok ? 200 : 403)).json(response);
+  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) => {
   try {
     const version = req.headers["x-api-version"] || "v1";
 
-    let router = routers.get_version(version);
-
-    if (router.config?.is_old) return router.routes(req, res);
-
-    if (!router) {
-      return res.status(400).json({
-        error: "Invalid API version",
-        version,
-      });
+    const versionRouter = routers.get_version(version);
+    // ----------------------------
+    // BODY (STREAM PARSE)
+    // ----------------------------
+    const body = await getBody(req);
+
+    if (!versionRouter) {
+      res.statusCode = 400;
+      return res.end(
+        JSON.stringify({
+          ok: false,
+          error: "Invalid API version",
+          version,
+        }),
+      );
     }
 
-    router = routers;
+    if (versionRouter.config?.is_old) {
+      req.body = body;
+      return versionRouter.routes(req, res);
+    }
 
-    let name = req.path.slice(1),
-      result;
+    const router = routers;
+    const name = req.url.replace(/^\//, "");
 
-    try {
-      result = await router.handle_security(name, req);
-      // console.log("Security check result:", result);
+    const isWebhook = req.headers["is-webhook"];
 
-      if (result !== true) {
-        return await respond(result, res);
-      }
-    } catch (err) {
-      console.error(err);
+    // ----------------------------
+    // SECURITY
+    // ----------------------------
+    const securityResult = await router.handle_security(name, req);
 
-      throw new Error("Security check failed");
+    if (securityResult !== true) {
+      return respond(securityResult, res);
     }
 
-    let db = await router.resolve_db(req);
-    let is_webhook = req.headers["is-webhook"];
+    // ----------------------------
+    // DB
+    // ----------------------------
+    const db = await router.resolve_db(req);
 
-    // console.log(req.headers);
-    if (!is_webhook) {
-      let web_prior = await router.handle_webhook_prior(req);
+    // ----------------------------
+    // WEBHOOK PRIOR
+    // ----------------------------
+    if (!isWebhook) {
+      const webPrior = await router.handle_webhook_prior(req);
 
-      if (web_prior === false) {
-      } else if (!web_prior?.ok) {
-        return await respond(web_prior, res);
-      } else {
-        req.headers.webhook_prior = web_prior;
+      if (webPrior && webPrior.ok === false) {
+        return respond(webPrior, res);
       }
-    }
-
-    try {
-      result = await router.execute(name, {
-        body: req.body,
-        headers: req.headers,
-        db: db.db,
-        gp: router.gp,
-        services: router.get_service,
-      });
 
-      !is_webhook && (await router.handle_webhook_after(req, result));
-
-      return await respond(result, res);
-    } catch (err) {
-      console.error(err);
+      if (webPrior?.ok) {
+        req.headers.webhook_prior = webPrior;
+      }
+    }
 
-      throw new Error("Route execution failed");
+    // ----------------------------
+    // EXECUTE
+    // ----------------------------
+    const result = await router.execute(name, {
+      body,
+      headers: req.headers,
+      db: db.db,
+      gp: router.gp,
+      services: router.get_service,
+    });
+
+    // ----------------------------
+    // WEBHOOK AFTER
+    // ----------------------------
+    if (!isWebhook) {
+      await router.handle_webhook_after(req, result);
     }
+
+    return respond(result, res);
   } catch (err) {
     console.error("Version Middleware Error:", err);
 
-    return (
-      res &&
-      res.status(500).json({
+    res.statusCode = 500;
+    res.end(
+      JSON.stringify({
         ok: false,
         message: "Internal server error",
-      })
+      }),
     );
   }
 };