@dongdev/fca-unofficial 3.0.30 → 3.0.31

package/src/utils/request/retry.js

@@ -0,0 +1,77 @@
+"use strict";
+
+const { delay } = require("./client");
+
+async function requestWithRetry(fn, retries = 3, baseDelay = 1000, ctx) {
+  let lastError;
+  const emit = (event, payload) => {
+    try {
+      if (ctx && ctx._emitter && typeof ctx._emitter.emit === "function") {
+        ctx._emitter.emit(event, payload);
+      }
+    } catch {}
+  };
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      lastError = e;
+
+      if (
+        e?.code === "ERR_INVALID_CHAR" ||
+        (e?.message && e.message.includes("Invalid character in header"))
+      ) {
+        const err = new Error(
+          "Invalid header content detected. Request aborted to prevent crash."
+        );
+        err.error = "Invalid header content";
+        err.originalError = e;
+        err.code = "ERR_INVALID_CHAR";
+        return Promise.reject(err);
+      }
+
+      const status = e?.response?.status || e?.statusCode || 0;
+      const url = e?.config?.url || "";
+      const method = String(e?.config?.method || "").toUpperCase();
+      if (status === 429) {
+        emit("rateLimit", { status, url, method });
+      }
+      if (status >= 400 && status < 500 && status !== 429) {
+        return e.response || Promise.reject(e);
+      }
+      if (i === retries - 1) {
+        return e.response || Promise.reject(e);
+      }
+      const netCode = e?.code || "";
+      const msg = e && e.message ? e.message : String(e || "");
+      if (
+        !status &&
+        (netCode === "UND_ERR_CONNECT_TIMEOUT" ||
+          netCode === "ETIMEDOUT" ||
+          netCode === "ECONNRESET" ||
+          netCode === "ECONNREFUSED" ||
+          netCode === "ENOTFOUND" ||
+          /timeout|connect timeout|network error|fetch failed/i.test(msg))
+      ) {
+        emit("networkError", {
+          code: netCode,
+          message: msg,
+          url,
+          method,
+        });
+      }
+
+      const backoffDelay = Math.min(
+        baseDelay * Math.pow(2, i) + Math.floor(Math.random() * 200),
+        30000
+      );
+      await delay(backoffDelay);
+    }
+  }
+  const finalError = lastError || new Error("Request failed after retries");
+  return Promise.reject(finalError);
+}
+
+module.exports = {
+  requestWithRetry,
+};

package/src/utils/request/sanitize.js

@@ -0,0 +1,49 @@
+"use strict";
+
+function sanitizeHeaderValue(value) {
+  if (value === null || value === undefined) return "";
+  const str = String(value);
+  return str.replace(/[\x00-\x08\x0B-\x0C\x0E-\x1F\x7F\r\n]/g, "").trim();
+}
+
+function sanitizeHeaderName(name) {
+  if (!name || typeof name !== "string") return "";
+  return name.replace(/[^\x21-\x7E]/g, "").trim();
+}
+
+function sanitizeHeaders(headers) {
+  if (!headers || typeof headers !== "object") return {};
+  const sanitized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    const sanitizedKey = sanitizeHeaderName(key);
+    if (!sanitizedKey) continue;
+
+    if (Array.isArray(value)) continue;
+    if (value !== null && typeof value === "object") continue;
+    if (typeof value === "function") continue;
+
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (Array.isArray(parsed)) continue;
+        } catch {
+          // continue with normal sanitization
+        }
+      }
+    }
+
+    const sanitizedValue = sanitizeHeaderValue(value);
+    if (sanitizedValue !== "") {
+      sanitized[sanitizedKey] = sanitizedValue;
+    }
+  }
+  return sanitized;
+}
+
+module.exports = {
+  sanitizeHeaderValue,
+  sanitizeHeaderName,
+  sanitizeHeaders,
+};