@rrrublev/wb-private-api 0.8.5

package/src/SessionBuilder.js

@@ -0,0 +1,283 @@
+const fs = require("fs");
+const path = require("path");
+const { fetch, Agent } = require("undici");
+const { stringify } = require("qs");
+const Constants = require("./Constants");
+
+const TOKEN_FILE = path.resolve(__dirname, "../.wbaas_token");
+
+const noopLogger = {
+  debug() {},
+  info() {},
+  warn() {},
+  error() {},
+};
+
+function createHttpError(status, url, method) {
+  const err = new Error(`Request failed with status code ${status}`);
+  err.response = { status };
+  err.config = { url, method };
+  return err;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Домены из исходников WB (urls.json), для которых подтверждён proxy-путь /__internal/<subdomain>/
+const PROXY_DOMAINS = new Set([
+  "catalog", "search", "card", "suggests",
+  "recom", "meta", "banners", "user-geo-data",
+  "u-catalog", "u-search", "u-card", "u-suggests",
+  "u-recom", "search-tags", "u-search-tags",
+]);
+
+function toProxyUrl(url) {
+  return url.replace(
+    /^https:\/\/([\w-]+)\.wb\.ru\//,
+    (match, subdomain) =>
+      PROXY_DOMAINS.has(subdomain)
+        ? `https://www.wildberries.ru/__internal/${subdomain}/`
+        : match
+  );
+}
+
+class Session {
+  constructor(config) {
+    this._config = config;
+    this._logger = config.logger || noopLogger;
+    this._agent = new Agent({
+      keepAliveTimeout: 30000,
+      keepAliveMaxTimeout: 30000,
+      connections: config.maxSockets,
+    });
+    this.defaults = {
+      headers: { common: {} },
+    };
+  }
+
+  _hasToken() {
+    return !!this.defaults.headers.common["Cookie"];
+  }
+
+  /** @returns {Promise<{status: number, data: any}>} */
+  async get(url, options = {}) {
+    const { params = {}, headers = {}, retryOptions, responseType = "auto" } = options;
+
+    const resolved = this._hasToken() ? toProxyUrl(url) : url;
+    const queryString = Object.keys(params).length
+      ? "?" + stringify(params, { arrayFormat: "comma", encode: false })
+      : "";
+    const fullUrl = resolved + queryString;
+
+    const mergedHeaders = {
+      ...this._config.headers,
+      ...this.defaults.headers.common,
+      ...headers,
+    };
+
+    const retries = retryOptions?.retries ?? this._config.retries;
+    const retryCondition =
+      retryOptions?.retryCondition ??
+      ((ctx) => ctx.status === 429 || ctx.status >= 500 || Boolean(ctx.error));
+
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      if (attempt > 0) {
+        const delay = Math.min(Math.pow(2, attempt) * 1000 + Math.random() * 1000, 10000);
+        this._logger.debug("Retry attempt", { attempt, url });
+        await sleep(delay);
+      }
+
+      const startTime = Date.now();
+      let response;
+      try {
+        response = await fetch(fullUrl, {
+          method: "GET",
+          headers: mergedHeaders,
+          dispatcher: this._agent,
+          signal: AbortSignal.timeout(this._config.timeout),
+        });
+      } catch (error) {
+        lastError = error;
+        const shouldRetry =
+          attempt < retries &&
+          retryCondition({ status: null, error, attempt, url, method: "get" });
+        if (!shouldRetry) {
+          error.config = { url, method: "get" };
+          throw error;
+        }
+        continue;
+      }
+
+      const duration = Date.now() - startTime;
+      if (duration > 5000) {
+        this._logger.warn("Slow request detected", { url, duration });
+      }
+
+      if (response.status >= 200 && response.status < 300) {
+        let data;
+        if (responseType === "text") {
+          data = await response.text();
+        } else if (responseType === "json") {
+          data = await response.json();
+        } else {
+          const contentType = response.headers.get("content-type") || "";
+          if (contentType.includes("application/json")) {
+            data = await response.json();
+          } else {
+            const text = await response.text();
+            const trimmed = text.trimStart();
+            if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+              try { data = JSON.parse(text); } catch { data = text; }
+            } else {
+              data = text;
+            }
+          }
+        }
+        return { status: response.status, data };
+      }
+
+      const shouldRetry =
+        attempt < retries &&
+        retryCondition({ status: response.status, error: null, attempt, url, method: "get" });
+
+      if (shouldRetry) {
+        lastError = createHttpError(response.status, url, "get");
+        continue;
+      }
+
+      const err = createHttpError(response.status, url, "get");
+      this._logger.error("Request failed", { url, status: response.status });
+      throw err;
+    }
+
+    if (lastError) {
+      lastError.config = { url, method: "get" };
+      throw lastError;
+    }
+  }
+
+  /** @returns {Promise<{status: number, data: any}>} */
+  async post(url, body, options = {}) {
+    const { headers = {}, retryOptions } = options;
+
+    const mergedHeaders = {
+      ...this._config.headers,
+      ...this.defaults.headers.common,
+      "Content-Type": "application/json",
+      ...headers,
+    };
+
+    const retries = retryOptions?.retries ?? this._config.retries;
+    const retryCondition =
+      retryOptions?.retryCondition ??
+      ((ctx) => ctx.status === 429 || ctx.status >= 500 || Boolean(ctx.error));
+
+    let lastError;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      if (attempt > 0) {
+        const delay = Math.min(Math.pow(2, attempt) * 1000 + Math.random() * 1000, 10000);
+        this._logger.debug("Retry attempt", { attempt, url });
+        await sleep(delay);
+      }
+
+      let response;
+      try {
+        response = await fetch(url, {
+          method: "POST",
+          headers: mergedHeaders,
+          body: JSON.stringify(body),
+          dispatcher: this._agent,
+          signal: AbortSignal.timeout(this._config.timeout),
+        });
+      } catch (error) {
+        lastError = error;
+        const shouldRetry =
+          attempt < retries &&
+          retryCondition({ status: null, error, attempt, url, method: "post" });
+        if (!shouldRetry) {
+          error.config = { url, method: "post" };
+          throw error;
+        }
+        continue;
+      }
+
+      if (response.status >= 200 && response.status < 300) {
+        let data;
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+          data = await response.json();
+        } else {
+          const text = await response.text();
+          const trimmed = text.trimStart();
+          if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+            try { data = JSON.parse(text); } catch { data = text; }
+          } else {
+            data = text;
+          }
+        }
+        return { status: response.status, data };
+      }
+
+      const shouldRetry =
+        attempt < retries &&
+        retryCondition({ status: response.status, error: null, attempt, url, method: "post" });
+
+      if (shouldRetry) {
+        lastError = createHttpError(response.status, url, "post");
+        continue;
+      }
+
+      const err = createHttpError(response.status, url, "post");
+      this._logger.error("Request failed", { url, status: response.status });
+      throw err;
+    }
+
+    if (lastError) {
+      lastError.config = { url, method: "post" };
+      throw lastError;
+    }
+  }
+}
+
+class SessionBuilder {
+  static create(options = {}) {
+    const config = {
+      timeout: options.timeout || 30000,
+      retries: options.retries ?? 3,
+      maxSockets: options.maxSockets || 10,
+      logger: options.logger || noopLogger,
+      headers: {
+        "User-Agent": options.userAgent || Constants.USERAGENT,
+        "Accept-Encoding": "gzip, deflate, br",
+        "Accept": "application/json, text/plain, */*",
+        "Accept-Language": "en-US,en;q=0.9,ru;q=0.8",
+        "Origin": "https://www.wildberries.ru",
+        "Referer": "https://www.wildberries.ru/",
+        "Cache-Control": "no-cache",
+      },
+    };
+    return new Session(config);
+  }
+
+  static readToken() {
+    try {
+      const data = JSON.parse(fs.readFileSync(TOKEN_FILE, "utf8"));
+      if (data.token && data.expires_at > Date.now()) return data.token;
+    } catch {}
+    return null;
+  }
+
+  /**
+   * Устанавливает антибот-токен в заголовок Cookie сессии.
+   * Только для запросов к wildberries.ru/__internal/*.
+   * @param {Session} session
+   * @param {string} token — значение cookie x_wbaas_token
+   */
+  static setAntibotToken(session, token) {
+    session.defaults.headers.common["Cookie"] = `x_wbaas_token=${token}`;
+  }
+}
+
+module.exports = SessionBuilder;

package/src/Utils.js

@@ -0,0 +1,154 @@
+/* eslint-disable no-nested-ternary */
+const format = require("string-format");
+const Constants = require("./Constants");
+
+// vol = Math.floor(nm_id / 100000); basket number = index + 1 (zero-padded).
+// Source: WB JS volHostV2() in product_dist JS (staticbasket_route_map).
+const BASKETS = [
+  [0, 143],          // basket-01
+  [144, 287],        // basket-02
+  [288, 431],        // basket-03
+  [432, 719],        // basket-04
+  [720, 1007],       // basket-05
+  [1008, 1061],      // basket-06
+  [1062, 1115],      // basket-07
+  [1116, 1169],      // basket-08
+  [1170, 1313],      // basket-09
+  [1314, 1601],      // basket-10
+  [1602, 1655],      // basket-11
+  [1656, 1919],      // basket-12
+  [1920, 2045],      // basket-13
+  [2046, 2189],      // basket-14
+  [2190, 2405],      // basket-15
+  [2406, 2621],      // basket-16
+  [2622, 2837],      // basket-17
+  [2838, 3053],      // basket-18
+  [3054, 3269],      // basket-19
+  [3270, 3485],      // basket-20
+  [3486, 3701],      // basket-21
+  [3702, 3917],      // basket-22
+  [3918, 4133],      // basket-23
+  [4134, 4349],      // basket-24
+  [4350, 4565],      // basket-25
+  [4566, 4877],      // basket-26
+  [4878, 5189],      // basket-27
+  [5190, 5501],      // basket-28
+  [5502, 5813],      // basket-29
+  [5814, 6125],      // basket-30
+  [6126, 6437],      // basket-31
+  [6438, 6749],      // basket-32
+  [6750, 7061],      // basket-33
+  [7062, 7373],      // basket-34
+  [7374, 7685],      // basket-35
+  [7686, 7997],      // basket-36
+  [7998, 8309],      // basket-37
+  [8310, 8741],      // basket-38
+  [8742, 9173],      // basket-39
+  [9174, 9605],      // basket-40
+  [9606, 10373],     // basket-41
+  [10374, 11141],    // basket-42
+  [11142, 11909],    // basket-43
+  [11910, Infinity], // basket-44
+];
+
+// vol = nm_id % 144; basket number = index + 1 (zero-padded).
+// Source: WB JS videonme_route_map switch statement in volVideoHost().
+const VIDEO_BASKETS = [
+  [0,   11],  // basket-01
+  [12,  23],  // basket-02
+  [24,  35],  // basket-03
+  [36,  47],  // basket-04
+  [48,  59],  // basket-05
+  [60,  71],  // basket-06
+  [72,  83],  // basket-07
+  [84,  95],  // basket-08
+  [96,  107], // basket-09
+  [108, 119], // basket-10
+  [120, 131], // basket-11
+  [132, 143], // basket-12
+];
+
+const getBasketNumber = (productId) => {
+  const vol = Math.floor(productId / 100000);
+  const index = BASKETS.findIndex(([from, to]) => vol >= from && vol <= to);
+  return String(index + 1).padStart(2, "0");
+};
+
+const getVideoBasket = (vol) => {
+  const index = VIDEO_BASKETS.findIndex(([from, to]) => vol >= from && vol <= to);
+  return String(index >= 0 ? index + 1 : VIDEO_BASKETS.length + 1).padStart(2, "0");
+};
+
+const imageURL = (productId, imageType = "SMALL", order = 1) => {
+  const vol = Math.floor(productId / 100000);
+  const part = Math.floor(productId / 1000);
+  const basket = getBasketNumber(productId);
+  const random = Date.now();
+  const URL = Constants.URLS.IMAGES[imageType];
+
+  return `${format(URL, basket, vol, part, productId, order)}?r=${random}`;
+};
+
+/**
+ * Generates a video URL for a WB product.
+ * Mirrors WB's own urlVideoProduct() from their frontend JS.
+ *
+ * @param {number|string} productId - nm_id of the product
+ * @param {"hls"|"mp4"} [videoFormat]   - "hls" → m3u8 playlist, "mp4" → preview file (360p)
+ * @param {string} [quality]       - HLS quality; WB always uses "1440p". MP4 preview is always "360p"
+ * @returns {string} full video URL
+ */
+const videoURL = (productId, videoFormat = "hls", quality = "1440p") => {
+  const id = parseInt(productId, 10);
+  const vol = id % 144;
+  const part = Math.floor(id / 10000);
+  const basket = getVideoBasket(vol);
+  if (videoFormat === "mp4") {
+    return format(Constants.URLS.VIDEO.MP4, basket, vol, part, id, quality);
+  }
+  return format(Constants.URLS.VIDEO.HLS, basket, vol, part, id, quality);
+};
+
+const brandImageURL = (brandId) => format(Constants.URLS.BRAND.IMAGE, brandId);
+
+const genNewUserID = function () {
+  const t = Math.floor(new Date().getTime() / 1e3);
+  const e = Math.floor(Math.random() * Math.pow(2, 30)).toString() + t.toString();
+  return e;
+};
+
+function pad(value) {
+  return String(value).padStart(2, "0");
+}
+
+function formatDateForQueryId(date = new Date()) {
+  return [
+    date.getFullYear(),
+    pad(date.getMonth() + 1),
+    pad(date.getDate()),
+    pad(date.getHours()),
+    pad(date.getMinutes()),
+    pad(date.getSeconds()),
+  ].join("");
+}
+
+const getQueryIdForSearch = function () {
+  return `qid${genNewUserID()}${formatDateForQueryId()}`;
+};
+
+const Utils = {
+  Card: {
+    imageURL,
+    getBasketNumber,
+    videoURL,
+    getVideoBasket,
+  },
+  Brand: {
+    imageURL: brandImageURL,
+  },
+  Search: {
+    getQueryIdForSearch,
+  },
+};
+
+module.exports = Utils;

package/src/WBCatalog.js

@@ -0,0 +1,37 @@
+const Constants = require("./Constants");
+
+class WBCatalog {
+  /* Creating a new instance of the class WBCatalog. */
+  constructor(data) {
+    this.catalog_type = data.catalog_type;
+    this.catalog_value = data.catalog_value;
+    this.pages = data.pages;
+    this.products = data.products;
+    this.totalProducts = data.totalProducts;
+  }
+
+  /**
+   * It takes a page number and returns a slice of plain product objects
+   * for that page.
+   * @param {number} number - the page number (1-based)
+   * @returns {array} - A slice of plain product objects from the catalog.
+   */
+  page(number) {
+    if (!Number.isInteger(number) || number < 1) return [];
+    const startIndex = (number - 1) * Constants.PRODUCTS_PER_PAGE;
+    if (startIndex >= this.products.length) return [];
+    return this.products.slice(startIndex, startIndex + Constants.PRODUCTS_PER_PAGE);
+  }
+
+  /**
+   * It returns the position of the product in the products array, or -1 if the
+   * product is not in the array
+   * @param {number} productId - The SKU of the product.
+   * @returns {number} - The position of the product in the array.
+   */
+  getPosition(productId) {
+    return this.products.findIndex((item) => item.id === productId);
+  }
+}
+
+module.exports = WBCatalog;

package/src/WBFeedback.js

@@ -0,0 +1,26 @@
+const Constants = require("./Constants");
+
+class WBFeedback {
+  constructor(feedback) {
+    Object.assign(this, feedback);
+  }
+
+  /**
+   * It takes a string as an argument, and if that string is not 'min', it adds
+   * 'SizeUri' to the end of it. Then it returns an array of photos, where each
+   * photo is a string that is the concatenation of the base URL for feedback
+   * images, and the photo's size URI
+   * @param [size=min] - The size of the image you want to get.
+   * @returns An array of the photos with the size specified.
+   */
+  getPhotos(size = "min") {
+    const field = `${size}SizeUri`;
+    const photos = Array.isArray(this.photos) ? this.photos : [];
+    return photos
+      .map((photo) => photo?.[field])
+      .filter(Boolean)
+      .map((p) => Constants.URLS.IMAGES.FEEDBACK_BASE + p);
+  }
+}
+
+module.exports = WBFeedback;