Gateway improvements (#445)

* feat: add timeout for resolving file response

* fix: enhance error handling in HTTP response to send appropriate status and body

* refactor: optimize API creation by caching instances for MAINNET and TAURUS networks

* fix: improve error handling in HTTP response by sending response bytes instead of body

* refactor: enhance network file retrieval by implementing firstNonNull utility for improved promise resolution

* fix: improve error handling in internalRedirect calls to ensure proper response on failure

* feat: add download timeout configuration to enhance request handling

Author: clostao

gateway/src/config.ts

@@ -10,4 +10,5 @@ export const ApiPatternByNetwork: Partial<Record<NetworkId, string>> = {
 export const config = {
   port: env("GATEWAY_PORT"),
   autoDriveApiKey: env("AUTO_DRIVE_API_KEY"),
+  downloadTimeout: Number(env("DOWNLOAD_TIMEOUT", "30000")),
 };

gateway/src/http.ts

@@ -1,5 +1,6 @@
 import { Response, Request } from "express";
 import { Readable } from "stream";
+import { config } from "./config";
 
 export const internalRedirect = async (
   req: Request,
@@ -14,8 +15,14 @@ export const internalRedirect = async (
 
   const response = await fetch(_url, {
     headers,
+    signal: AbortSignal.timeout(config.downloadTimeout),
   });
 
+  if (!response.ok) {
+    res.status(response.status).send(await response.bytes());
+    return;
+  }
+
   const whitelistedHeaders = ["content-type"];
   for (const [key, value] of response.headers.entries()) {
     if (whitelistedHeaders.includes(key.toLowerCase())) {

gateway/src/index.ts

@@ -19,7 +19,10 @@ app.get("/file/:cid", async (req, res) => {
 
   res.setHeader("X-Network", result.network);
 
-  internalRedirect(req, res, result.url);
+  internalRedirect(req, res, result.url).catch((error) => {
+    console.error(error);
+    res.status(500).send("Internal server error");
+  });
 });
 
 app.get("/folder/:cid", async (req, res) => {
@@ -36,7 +39,10 @@ app.get("/folder/:cid", async (req, res) => {
 
   res.setHeader("X-Network", result.network);
 
-  internalRedirect(req, res, result.url);
+  internalRedirect(req, res, result.url).catch((error) => {
+    console.error(error);
+    res.status(500).send("Internal server error");
+  });
 });
 
 app.get("/", (req, res) => {

gateway/src/networkComposer.ts

@@ -1,36 +1,45 @@
 import { NetworkId } from "@autonomys/auto-utils";
 import { createAutoDriveApi } from "@autonomys/auto-drive";
-import { removeFalsy, toPromise } from "./utils";
+import { firstNonNull } from "./utils";
 import { ApiPatternByNetwork, config } from "./config";
 
 export const getFileNetwork = async (cid: string) => {
   const networks = [NetworkId.MAINNET, NetworkId.TAURUS] as const;
 
-  const results = removeFalsy(
-    await toPromise(
-      networks.map(async (network) => {
-        const api = createAutoDriveApi({
-          network: network,
-          apiKey: config.autoDriveApiKey,
-        });
+  // Create reusable API instances to avoid memory leaks
+  const apiInstances = {
+    [NetworkId.MAINNET]: createAutoDriveApi({
+      network: NetworkId.MAINNET,
+      apiKey: config.autoDriveApiKey,
+    }),
+    [NetworkId.TAURUS]: createAutoDriveApi({
+      network: NetworkId.TAURUS,
+      apiKey: config.autoDriveApiKey,
+    }),
+  };
 
-        const object = await api.searchByNameOrCID(cid);
-        const fileExists = object.length > 0;
-        const url = ApiPatternByNetwork[network]?.replace("{cid}", cid);
+  const promises = networks.map(async (network) => {
+    try {
+      const api = apiInstances[network];
+      const object = await api.searchByNameOrCID(cid);
+      const fileExists = object.length > 0;
+      const url = ApiPatternByNetwork[network]?.replace("{cid}", cid);
 
-        if (fileExists && url) {
-          const file = object[0];
-          return {
-            type: file.type,
-            url,
-            network,
-          };
-        }
+      if (fileExists && url) {
+        const file = object[0];
+        return {
+          type: file.type,
+          url,
+          network,
+        };
+      }
 
-        return null;
-      })
-    )
-  );
+      return null;
+    } catch (error) {
+      console.error(`Error searching network ${network}:`, error);
+      return null;
+    }
+  });
 
-  return results.at(0);
+  return await firstNonNull(promises);
 };

gateway/src/utils.ts

@@ -26,3 +26,45 @@ export const getHeaders = (req: express.Request): HeadersInit => {
   }
   return headers;
 };
+
+/**
+ * Resolves an array of promises and returns the first non-null value.
+ * Does not wait for all promises to resolve - returns as soon as the first non-null value is found.
+ * @param promises Array of promises that resolve to potentially null values
+ * @returns Promise that resolves to the first non-null value, or null if all resolve to null
+ */
+export const firstNonNull = async <T>(
+  promises: Promise<T | null>[]
+): Promise<T | null> => {
+  if (promises.length === 0) {
+    return null;
+  }
+
+  return new Promise((resolve) => {
+    let resolved = false;
+    let pendingCount = promises.length;
+
+    const checkComplete = () => {
+      if (pendingCount === 0 && !resolved) {
+        resolve(null);
+      }
+    };
+
+    promises.forEach((promise) => {
+      promise
+        .then((result) => {
+          pendingCount--;
+          if (!resolved && result !== null && result !== undefined) {
+            resolved = true;
+            resolve(result);
+          } else {
+            checkComplete();
+          }
+        })
+        .catch(() => {
+          pendingCount--;
+          checkComplete();
+        });
+    });
+  });
+};