@biggy1337/discord-sbjs 1.3.11

package/src/rest/RESTManager.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const Buffer = require('node:buffer').Buffer;
+const { setInterval } = require('node:timers');
+const { Collection } = require('@discordjs/collection');
+const APIRequest = require('./APIRequest');
+const routeBuilder = require('./APIRouter');
+const RateLimitCoordinator = require('./RateLimitCoordinator');
+const RequestHandler = require('./RequestHandler');
+const { Error } = require('../errors');
+const { Endpoints } = require('../util/Constants');
+const FetchUtil = require('../util/FetchUtil');
+const Util = require('../util/Util');
+class RESTManager {
+  constructor(client) {
+    this.client = client;
+    this.handlers = new Collection();
+    this.versioned = true;
+    this.globalLimit = client.options.restGlobalRateLimit > 0 ? client.options.restGlobalRateLimit : Infinity;
+    this.globalRemaining = this.globalLimit;
+    this.globalReset = null;
+    this.globalDelay = null;
+    this.cookieJar = FetchUtil.createCookieJar();
+    let baseFetch;
+    if (typeof client.options.http?.fetch === 'function') {
+      baseFetch = client.options.http.fetch;
+    } else if (client.options.http?.tlsFingerprint) {
+      const proxyConfig = this.getProxyConfig();
+      const proxyUrl = typeof proxyConfig === 'string' ? proxyConfig : proxyConfig?.url;
+      baseFetch = FetchUtil.getImpitFetch({ proxyUrl }) ?? FetchUtil.getNativeFetch();
+    } else {
+      baseFetch = FetchUtil.getNativeFetch();
+    }
+    this.fetch = FetchUtil.wrapFetchWithCookies(baseFetch, this.cookieJar);
+
+    this._api = routeBuilder(this);
+    this._cdn = null;
+    this._cdnRoot = null;
+    this._superProperties = null;
+    this._superPropertiesUA = null;
+    this._superPropertiesWsProps = null;
+    this._timezone = null;
+    this._proxyConfig = null;
+    this._proxySource = null;
+    this._authToken = null;
+    this._auth = null;
+    this._installationId = null;
+    this._fingerprint = null;
+    this._routeBuckets = new Collection();
+    this._bucketHandlers = new Collection();
+    this._formData = null;
+    this.coordinator = new RateLimitCoordinator(this);
+
+    if (client.options.restSweepInterval > 0) {
+      this.sweepInterval = setInterval(() => {
+        this.handlers.sweep(handler => handler._inactive);
+        this._bucketHandlers.sweep(handler => handler._inactive);
+        this._routeBuckets.sweep(bucketHash => !this._bucketHandlers.has(bucketHash));
+      }, client.options.restSweepInterval * 1_000).unref();
+    }
+  }
+
+  get api() {
+    return this._api;
+  }
+
+  _routeKey(method, route) {
+    return `${String(method).toUpperCase()}:${route}`;
+  }
+
+  bindBucket(method, route, bucketHash, handler) {
+    if (!bucketHash || !handler) return;
+    this._bucketHandlers.set(bucketHash, handler);
+    this._routeBuckets.set(this._routeKey(method, route), bucketHash);
+  }
+
+  getFormData() {
+    if (!this._formData) this._formData = FetchUtil.getNativeFormData();
+    return this._formData;
+  }
+
+  getAuth() {
+    const token = this.client.token ?? this.client.accessToken;
+    if (!token) throw new Error('TOKEN_MISSING');
+    if (token === this._authToken && this._auth) return this._auth;
+    this._authToken = token;
+    this._auth = token.replace(/Bot /g, '');
+    return this._auth;
+  }
+
+  invalidateSuperProperties() {
+    this._superProperties = null;
+    this._superPropertiesUA = null;
+    this._superPropertiesWsProps = null;
+  }
+
+  /**
+   * Sets the installation ID from the Ready event (apex_experiments).
+   * Used for X-Installation-ID header per docs.discord.food experiments.
+   * @param {?string} id Installation ID from Ready.installation or apex_experiments
+   */
+  setInstallationId(id) {
+    this._installationId = id || null;
+  }
+
+  getInstallationId() {
+    return this._installationId;
+  }
+
+  setFingerprint(fingerprint) {
+    this._fingerprint = fingerprint || null;
+  }
+
+  getFingerprint() {
+    return this._fingerprint ?? this.client.options.fingerprint;
+  }
+
+  getSuperProperties(userAgent) {
+    const wsProps = this.client.options.ws.properties;
+    if (wsProps.browser_user_agent !== userAgent) wsProps.browser_user_agent = userAgent;
+
+    if (this._superProperties && this._superPropertiesUA === userAgent && this._superPropertiesWsProps === wsProps) {
+      return this._superProperties;
+    }
+
+    this._superPropertiesUA = userAgent;
+    this._superPropertiesWsProps = wsProps;
+    this._superProperties = Buffer.from(JSON.stringify(wsProps), 'ascii').toString('base64');
+    return this._superProperties;
+  }
+
+  getTimezone() {
+    if (this._timezone !== null) return this._timezone;
+    try {
+      this._timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch {
+      this._timezone = undefined;
+    }
+    return this._timezone;
+  }
+
+  getProxyConfig() {
+    const source = this.client.options.http.agent;
+    if (source === this._proxySource) return this._proxyConfig;
+
+    this._proxySource = source;
+
+    const proxyConfig = Util.checkUndiciProxyAgent(source);
+    if (!proxyConfig) {
+      this._proxyConfig = null;
+      return this._proxyConfig;
+    }
+    if (typeof proxyConfig === 'string') {
+      this._proxyConfig = proxyConfig;
+      return this._proxyConfig;
+    }
+    if (proxyConfig?.uri) {
+      if (proxyConfig.headers) {
+        this._proxyConfig = { url: proxyConfig.uri, headers: proxyConfig.headers };
+      } else {
+        this._proxyConfig = proxyConfig.uri;
+      }
+      return this._proxyConfig;
+    }
+    this._proxyConfig = null;
+    return this._proxyConfig;
+  }
+
+  get cdn() {
+    const root = this.client.options.http.cdn;
+    if (!this._cdn || this._cdnRoot !== root) {
+      this._cdn = Endpoints.CDN(root);
+      this._cdnRoot = root;
+    }
+    return this._cdn;
+  }
+
+  request(method, url, options = {}) {
+    const apiRequest = new APIRequest(this, method, url, options);
+    const routeKey = this._routeKey(apiRequest.method, apiRequest.route);
+    const bucketHash = this._routeBuckets.get(routeKey);
+    let handler = bucketHash ? this._bucketHandlers.get(bucketHash) : null;
+    if (!handler) handler = this.handlers.get(apiRequest.route);
+
+    if (!handler) {
+      handler = new RequestHandler(this);
+    }
+    this.handlers.set(apiRequest.route, handler);
+    if (bucketHash) this._bucketHandlers.set(bucketHash, handler);
+
+    return handler.push(apiRequest);
+  }
+
+  get endpoint() {
+    return this.client.options.http.api;
+  }
+
+  set endpoint(endpoint) {
+    this.client.options.http.api = endpoint;
+  }
+}
+
+module.exports = RESTManager;

package/src/rest/RateLimitCoordinator.js

@@ -0,0 +1,156 @@
+'use strict';
+
+const { setTimeout: sleep } = require('node:timers/promises');
+
+function parseJSONResponse(res) {
+  if (res.headers.get('content-type')?.startsWith('application/json')) return res.json();
+  return Promise.resolve(null);
+}
+
+function getAPIOffset(serverDate) {
+  if (!serverDate) return 0;
+  const parsed = new Date(serverDate).getTime();
+  if (!Number.isFinite(parsed)) return 0;
+  return parsed - Date.now();
+}
+
+function calculateReset(reset, resetAfter, serverDate) {
+  if (resetAfter) return Date.now() + Number(resetAfter) * 1_000;
+  const parsedReset = new Date(Number(reset) * 1_000).getTime();
+  if (!Number.isFinite(parsedReset)) return Date.now();
+  return parsedReset - getAPIOffset(serverDate);
+}
+
+class RateLimitCoordinator {
+  constructor(manager) {
+    this.manager = manager;
+    this.buckets = new Map();
+  }
+
+  getRateLimitScope(headers, bodyGlobal = false) {
+    const scopeHeader = String(headers?.get('x-ratelimit-scope') || '').toLowerCase();
+    if (scopeHeader === 'global' || scopeHeader === 'shared' || scopeHeader === 'user') {
+      return scopeHeader;
+    }
+    if (bodyGlobal) return 'global';
+    return null;
+  }
+
+  isSharedScope(headers) {
+    return this.getRateLimitScope(headers) === 'shared';
+  }
+
+  isGlobalScope(headers, bodyGlobal = false) {
+    if (headers?.get('x-ratelimit-global')) return true;
+    return this.getRateLimitScope(headers, bodyGlobal) === 'global';
+  }
+
+  getActiveRateLimit(handler, now = Date.now(), request) {
+    if (!request?.options?.webhook && this.manager.globalRemaining <= 0 && now < this.manager.globalReset) {
+      const timeout = this.manager.globalReset + this.manager.client.options.restTimeOffset - now;
+      return { isGlobal: true, limit: this.manager.globalLimit, timeout };
+    }
+
+    if (handler.remaining <= 0 && now < handler.reset) {
+      const timeout = handler.reset + this.manager.client.options.restTimeOffset - now;
+      return { isGlobal: false, limit: handler.limit, timeout };
+    }
+
+    return null;
+  }
+
+  markRequestStart(request, now = Date.now()) {
+    if (request?.options?.webhook) return;
+    if (!this.manager.globalReset || this.manager.globalReset < now) {
+      this.manager.globalReset = now + 1_000;
+      this.manager.globalRemaining = this.manager.globalLimit;
+    }
+    this.manager.globalRemaining--;
+  }
+
+  applyHeaders(handler, request, headers) {
+    if (!headers) return { sublimitTimeout: null };
+
+    const serverDate = headers.get('date');
+    const bucketHash = headers.get('x-ratelimit-bucket');
+    const limit = headers.get('x-ratelimit-limit');
+    const remaining = headers.get('x-ratelimit-remaining');
+    const reset = headers.get('x-ratelimit-reset');
+    const resetAfter = headers.get('x-ratelimit-reset-after');
+
+    if (bucketHash) {
+      this.manager.bindBucket?.(request.method, request.route, bucketHash, handler);
+    }
+
+    handler.limit = limit ? Number(limit) : Infinity;
+    handler.remaining = remaining ? Number(remaining) : 1;
+    handler.reset = reset || resetAfter ? calculateReset(reset, resetAfter, serverDate) : Date.now();
+
+    if (!resetAfter && serverDate && request.route.includes('reactions')) {
+      handler.reset = new Date(serverDate).getTime() - getAPIOffset(serverDate) + 250;
+    }
+
+    let retryAfter = headers.get('retry-after');
+    retryAfter = retryAfter ? Number(retryAfter) * 1_000 : -1;
+
+    let sublimitTimeout = null;
+    if (retryAfter > 0) {
+      if (this.isGlobalScope(headers)) {
+        this.manager.globalRemaining = 0;
+        this.manager.globalReset = Date.now() + retryAfter;
+      } else if (!(handler.remaining <= 0 && Date.now() < handler.reset)) {
+        sublimitTimeout = retryAfter;
+      }
+    }
+
+    if (bucketHash) {
+      this.buckets.set(bucketHash, {
+        limit: handler.limit,
+        remaining: handler.remaining,
+        reset: handler.reset,
+      });
+    }
+
+    return { sublimitTimeout };
+  }
+
+  async resolve429Timeout(res, computedTimeout) {
+    let safeTimeout = Math.max(computedTimeout, 0);
+    let bodyRetryAfter = null;
+    let bodyGlobal = false;
+
+    if (safeTimeout <= 0 || !res.headers.get('x-ratelimit-global')) {
+      try {
+        const body = await parseJSONResponse(res.clone());
+        const retryAfter = Number(body?.retry_after);
+        bodyGlobal = Boolean(body?.global);
+        if (Number.isFinite(retryAfter) && retryAfter > 0) {
+          bodyRetryAfter = retryAfter * 1_000;
+          safeTimeout = bodyRetryAfter;
+        }
+      } catch {
+        // Ignore invalid fallback payload.
+      }
+    }
+
+    const scope = this.getRateLimitScope(res.headers, bodyGlobal);
+    if (scope === 'global') bodyGlobal = true;
+    return { safeTimeout, bodyRetryAfter, bodyGlobal, scope };
+  }
+
+  getRetryBackoff(status, retries) {
+    if (!retries) return 0;
+    const base = status === 429 ? 125 : 200;
+    const cap = status === 429 ? 1_500 : 3_000;
+    const exp = Math.min(cap, base * 2 ** Math.min(retries, 5));
+    const jitter = Math.floor(Math.random() * (exp * 0.2));
+    return exp + jitter;
+  }
+
+  async sleepBackoff(status, retries) {
+    const delay = this.getRetryBackoff(status, retries);
+    if (delay > 0) await sleep(delay);
+  }
+}
+
+module.exports = RateLimitCoordinator;

package/src/rest/RateLimitError.js

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * Represents a RateLimit error from a request.
+ * @extends Error
+ */
+class RateLimitError extends Error {
+  constructor({ timeout, limit, method, path, route, global }) {
+    super(`A ${global ? 'global ' : ''}rate limit was hit on route ${route}`);
+
+    /**
+     * The name of the error
+     * @type {string}
+     */
+    this.name = 'RateLimitError';
+
+    /**
+     * Time until this rate limit ends, in milliseconds
+     * @type {number}
+     */
+    this.timeout = timeout;
+
+    /**
+     * The HTTP method used for the request
+     * @type {string}
+     */
+    this.method = method;
+
+    /**
+     * The path of the request relative to the HTTP endpoint
+     * @type {string}
+     */
+    this.path = path;
+
+    /**
+     * The route of the request relative to the HTTP endpoint
+     * @type {string}
+     */
+    this.route = route;
+
+    /**
+     * Whether this rate limit is global
+     * @type {boolean}
+     */
+    this.global = global;
+
+    /**
+     * The maximum amount of requests of this endpoint
+     * @type {number}
+     */
+    this.limit = limit;
+  }
+}
+
+module.exports = RateLimitError;