fca-riyad 37.0.0

package/src/utils/request/client.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const axios = require("axios");
+const { CookieJar } = require("tough-cookie");
+const { wrapper } = require("axios-cookiejar-support");
+
+const jar = new CookieJar();
+const client = wrapper(
+  axios.create({
+    jar,
+    withCredentials: true,
+    timeout: 60000,
+    validateStatus: (s) => s >= 200 && s < 600,
+    maxRedirects: 5,
+    maxContentLength: Infinity,
+    maxBodyLength: Infinity,
+  })
+);
+
+const delay = (ms) => new Promise((r) => setTimeout(r, ms));
+
+module.exports = {
+  jar,
+  client,
+  delay,
+};

package/src/utils/request/config.js

@@ -0,0 +1,23 @@
+"use strict";
+
+const { sanitizeHeaders } = require("./sanitize");
+const { jar, client } = require("./client");
+
+function cfg(base = {}) {
+  const { reqJar, headers, params, agent, timeout } = base;
+  return {
+    headers: sanitizeHeaders(headers),
+    params,
+    jar: reqJar || jar,
+    withCredentials: true,
+    timeout: timeout || 60000,
+    httpAgent: agent || client.defaults.httpAgent,
+    httpsAgent: agent || client.defaults.httpsAgent,
+    proxy: false,
+    validateStatus: (s) => s >= 200 && s < 600,
+  };
+}
+
+module.exports = {
+  cfg,
+};

package/src/utils/request/defaults.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const constMod = require("../constants");
+const getFrom = constMod.getFrom || constMod;
+const { get, post, postFormData } = require("./methods");
+
+function makeDefaults(html, userID, ctx) {
+  let reqCounter = 1;
+  const revision =
+    getFrom(html || "", 'revision":', ",") ||
+    getFrom(html || "", '"client_revision":', ",") ||
+    "";
+  function mergeWithDefaults(obj) {
+    const base = {
+      av: userID,
+      __user: userID,
+      __req: (reqCounter++).toString(36),
+      __rev: revision,
+      __a: 1,
+    };
+    if (ctx?.fb_dtsg) base.fb_dtsg = ctx.fb_dtsg;
+    if (ctx?.jazoest) base.jazoest = ctx.jazoest;
+    if (!obj) return base;
+    for (const k of Object.keys(obj)) if (!(k in base)) base[k] = obj[k];
+    return base;
+  }
+  return {
+    get: (url, j, qs, ctxx, customHeader = {}) =>
+      get(url, j, mergeWithDefaults(qs), ctx?.globalOptions, ctxx || ctx, customHeader),
+    post: (url, j, form, ctxx, customHeader = {}) =>
+      post(url, j, mergeWithDefaults(form), ctx?.globalOptions, ctxx || ctx, customHeader),
+    postFormData: (url, j, form, qs, ctxx) =>
+      postFormData(
+        url,
+        j,
+        mergeWithDefaults(form),
+        mergeWithDefaults(qs),
+        ctx?.globalOptions,
+        ctxx || ctx
+      ),
+  };
+}
+
+module.exports = {
+  makeDefaults,
+};

package/src/utils/request/helpers.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const formatMod = require("../format");
+const getType = formatMod.getType || formatMod;
+
+function toStringVal(v) {
+  if (v === undefined || v === null) return "";
+  if (typeof v === "bigint") return v.toString();
+  if (typeof v === "boolean") return v ? "true" : "false";
+  return String(v);
+}
+
+function isStream(v) {
+  return (
+    v &&
+    typeof v === "object" &&
+    typeof v.pipe === "function" &&
+    typeof v.on === "function"
+  );
+}
+
+function isBlobLike(v) {
+  return (
+    v &&
+    typeof v.arrayBuffer === "function" &&
+    (typeof v.type === "string" || typeof v.name === "string")
+  );
+}
+
+function isPairArrayList(arr) {
+  return (
+    Array.isArray(arr) &&
+    arr.length > 0 &&
+    arr.every(
+      (x) => Array.isArray(x) && x.length === 2 && typeof x[0] === "string"
+    )
+  );
+}
+
+module.exports = {
+  getType,
+  toStringVal,
+  isStream,
+  isBlobLike,
+  isPairArrayList,
+};

package/src/utils/request/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const { jar, client } = require("./client");
+const { cleanGet, get, post, postFormData } = require("./methods");
+const { makeDefaults } = require("./defaults");
+const { setProxy } = require("./proxy");
+
+module.exports = {
+  cleanGet,
+  get,
+  post,
+  postFormData,
+  jar,
+  setProxy,
+  makeDefaults,
+  client,
+};

package/src/utils/request/methods.js

@@ -0,0 +1,163 @@
+"use strict";
+
+const FormData = require("form-data");
+const headersMod = require("../headers");
+const getHeaders = headersMod.getHeaders || headersMod;
+const { client } = require("./client");
+const { cfg } = require("./config");
+const { requestWithRetry } = require("./retry");
+const {
+  getType,
+  toStringVal,
+  isStream,
+  isBlobLike,
+  isPairArrayList,
+} = require("./helpers");
+
+function cleanGet(url, ctx) {
+  return requestWithRetry(() => client.get(url, cfg()), 3, 1000, ctx);
+}
+
+function get(url, reqJar, qs, options, ctx, customHeader) {
+  const headers = getHeaders(url, options, ctx, customHeader);
+  return requestWithRetry(
+    () => client.get(url, cfg({ reqJar, headers, params: qs })),
+    3,
+    1000,
+    ctx
+  );
+}
+
+function post(url, reqJar, form, options, ctx, customHeader) {
+  const headers = getHeaders(url, options, ctx, customHeader);
+  const ct = String(
+    headers["Content-Type"] || headers["content-type"] || "application/x-www-form-urlencoded"
+  ).toLowerCase();
+  let data;
+  if (ct.includes("json")) {
+    data = JSON.stringify(form || {});
+    headers["Content-Type"] = "application/json";
+  } else {
+    const p = new URLSearchParams();
+    if (form && typeof form === "object") {
+      for (const k of Object.keys(form)) {
+        let v = form[k];
+        if (isPairArrayList(v)) {
+          for (const [kk, vv] of v) p.append(`${k}[${kk}]`, toStringVal(vv));
+          continue;
+        }
+        if (Array.isArray(v)) {
+          for (const x of v) {
+            if (Array.isArray(x) && x.length === 2 && typeof x[1] !== "object")
+              p.append(k, toStringVal(x[1]));
+            else p.append(k, toStringVal(x));
+          }
+          continue;
+        }
+        if (getType(v) === "Object") v = JSON.stringify(v);
+        p.append(k, toStringVal(v));
+      }
+    }
+    data = p.toString();
+    headers["Content-Type"] = "application/x-www-form-urlencoded";
+  }
+  return requestWithRetry(
+    () => client.post(url, data, cfg({ reqJar, headers })),
+    3,
+    1000,
+    ctx
+  );
+}
+
+async function postFormData(url, reqJar, form, qs, options, ctx) {
+  const fd = new FormData();
+  if (form && typeof form === "object") {
+    for (const k of Object.keys(form)) {
+      const v = form[k];
+      if (v === undefined || v === null) continue;
+      if (isPairArrayList(v)) {
+        for (const [kk, vv] of v)
+          fd.append(
+            `${k}[${kk}]`,
+            typeof vv === "object" && !Buffer.isBuffer(vv) && !isStream(vv)
+              ? JSON.stringify(vv)
+              : vv
+          );
+        continue;
+      }
+      if (Array.isArray(v)) {
+        for (const x of v) {
+          if (
+            Array.isArray(x) &&
+            x.length === 2 &&
+            x[1] &&
+            typeof x[1] === "object" &&
+            !Buffer.isBuffer(x[1]) &&
+            !isStream(x[1])
+          ) {
+            fd.append(k, x[0], x[1]);
+          } else if (
+            Array.isArray(x) &&
+            x.length === 2 &&
+            typeof x[1] !== "object"
+          ) {
+            fd.append(k, toStringVal(x[1]));
+          } else if (
+            x &&
+            typeof x === "object" &&
+            "value" in x &&
+            "options" in x
+          ) {
+            fd.append(k, x.value, x.options || {});
+          } else if (isStream(x) || Buffer.isBuffer(x) || typeof x === "string") {
+            fd.append(k, x);
+          } else if (isBlobLike(x)) {
+            const buf = Buffer.from(await x.arrayBuffer());
+            fd.append(k, buf, {
+              filename: x.name || k,
+              contentType: x.type || undefined,
+            });
+          } else {
+            fd.append(k, JSON.stringify(x));
+          }
+        }
+        continue;
+      }
+      if (v && typeof v === "object" && "value" in v && "options" in v) {
+        fd.append(k, v.value, v.options || {});
+        continue;
+      }
+      if (isStream(v) || Buffer.isBuffer(v) || typeof v === "string") {
+        fd.append(k, v);
+        continue;
+      }
+      if (isBlobLike(v)) {
+        const buf = Buffer.from(await v.arrayBuffer());
+        fd.append(k, buf, {
+          filename: v.name || k,
+          contentType: v.type || undefined,
+        });
+        continue;
+      }
+      if (typeof v === "number" || typeof v === "boolean") {
+        fd.append(k, toStringVal(v));
+        continue;
+      }
+      fd.append(k, JSON.stringify(v));
+    }
+  }
+  const headers = { ...getHeaders(url, options, ctx), ...fd.getHeaders() };
+  return requestWithRetry(
+    () => client.post(url, fd, cfg({ reqJar, headers, params: qs })),
+    3,
+    1000,
+    ctx
+  );
+}
+
+module.exports = {
+  cleanGet,
+  get,
+  post,
+  postFormData,
+};

package/src/utils/request/proxy.js

@@ -0,0 +1,21 @@
+"use strict";
+
+const { HttpsProxyAgent } = require("https-proxy-agent");
+const { client } = require("./client");
+
+function setProxy(proxyUrl) {
+  if (!proxyUrl) {
+    client.defaults.httpAgent = undefined;
+    client.defaults.httpsAgent = undefined;
+    client.defaults.proxy = false;
+    return;
+  }
+  const agent = new HttpsProxyAgent(proxyUrl);
+  client.defaults.httpAgent = agent;
+  client.defaults.httpsAgent = agent;
+  client.defaults.proxy = false;
+}
+
+module.exports = {
+  setProxy,
+};

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,
+};

package/src/utils/versionCheck.js

@@ -0,0 +1,47 @@
+"use strict";
+
+const https = require("https");
+const pkg = require("../../package.json");
+
+function getLatestVersion(cb) {
+  const req = https.get(
+    "https://registry.npmjs.org/fca-riyad/latest",
+    { headers: { "Accept": "application/json" } },
+    (res) => {
+      let data = "";
+      res.on("data", chunk => { data += chunk; });
+      res.on("end", () => {
+        try { cb(null, JSON.parse(data).version); }
+        catch { cb(new Error("parse failed")); }
+      });
+    }
+  );
+  req.on("error", cb);
+  req.setTimeout(5000, () => { req.destroy(); cb(new Error("timeout")); });
+}
+
+function compareVersion(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+  }
+  return 0;
+}
+
+function checkForUpdate(logger) {
+  const current = pkg.version;
+  getLatestVersion((err, latest) => {
+    if (err || !latest) return;
+    if (compareVersion(current, latest) < 0) {
+      if (typeof logger === "function") {
+        logger(`⚠️ fca-riyad outdated! You are using v${current}, latest is v${latest}. Run: npm install fca-riyad@latest`, "warn");
+      } else {
+        console.warn(`\x1b[33m[FCA-WARN] ⚠️ fca-riyad outdated! v${current} → v${latest} | npm install fca-riyad@latest\x1b[0m`);
+      }
+    }
+  });
+}
+
+module.exports = { checkForUpdate };

package/src/vendor/fca-unofficial/.github/workflows/nodejs.yml

@@ -0,0 +1,26 @@
+name: Node CI
+
+on: [push]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x, 14.x]
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: npm install, build, and test
+      run: |
+        npm ci
+        npm run build --if-present
+        npm run lint
+      env:
+        CI: true

package/src/vendor/fca-unofficial/.github/workflows/npmpublish.yml

@@ -0,0 +1,30 @@
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 14
+      - run: npm ci
+      - run: npm run lint
+
+  publish-npm:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 14
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.npm_token}}

package/src/vendor/fca-unofficial/.travis.yml

@@ -0,0 +1,6 @@
+language: node_js
+node_js:
+  - "6"
+
+script:
+  - npm run lint