rockcord 4.0.0-dev.4

package/src/rest/APIRequest.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const Buffer = require('node:buffer').Buffer;
+const { setTimeout } = require('node:timers');
+const { FormData, Response } = require('undici');
+
+class APIRequest {
+  constructor(rest, method, path, options) {
+    this.rest = rest;
+    this.client = rest.client;
+    this.method = method;
+    this.route = options.route;
+    this.options = options;
+    this.retries = 0;
+
+    this.fullUserAgent = this.client.options.http.headers['User-Agent'];
+
+    this.client.options.ws.properties.browser_user_agent = this.fullUserAgent;
+
+    let queryString = '';
+    if (options.query) {
+      const query = Object.entries(options.query)
+        .filter(([, value]) => value !== null && typeof value !== 'undefined')
+        .flatMap(([key, value]) => (Array.isArray(value) ? value.map(v => [key, v]) : [[key, value]]));
+      queryString = new URLSearchParams(query).toString();
+    }
+    this.path = `${path}${queryString && `?${queryString}`}`;
+  }
+
+  async make(captchaKey, captchaRqToken) {
+    const API =
+      this.options.versioned === false
+        ? this.client.options.http.api
+        : `${this.client.options.http.api}/v${this.client.options.http.version}`;
+    const url = API + this.path;
+
+    let headers = {
+      accept: '*/*',
+      'accept-language': 'en-US',
+      priority: 'u=1, i',
+      referer: 'https://discord.com/channels/@me',
+      'sec-ch-ua': '"Not:A-Brand";v="24", "Chromium";v="134"',
+      'sec-ch-ua-mobile': '?0',
+      'sec-ch-ua-platform': '"Windows"',
+      'sec-fetch-dest': 'empty',
+      'sec-fetch-mode': 'cors',
+      'sec-fetch-site': 'same-origin',
+      'x-discord-locale': 'en-US',
+      'x-discord-timezone': Intl.DateTimeFormat().resolvedOptions().timeZone,
+      'x-super-properties': `${Buffer.from(JSON.stringify(this.client.options.ws.properties), 'ascii').toString(
+        'base64',
+      )}`,
+      origin: 'https://discord.com',
+      'x-debug-options': 'bugReporterEnabled',
+      ...this.client.options.http.headers,
+      'User-Agent': this.fullUserAgent,
+    };
+
+    if (this.options.auth !== false) headers.Authorization = this.rest.getAuth();
+    if (this.options.reason) headers['X-Audit-Log-Reason'] = encodeURIComponent(this.options.reason);
+    if (this.options.headers) headers = Object.assign(headers, this.options.headers);
+
+    // Delete all headers if undefined
+    for (const [key, value] of Object.entries(headers)) {
+      if (value === undefined) delete headers[key];
+    }
+    if (this.options.webhook === true) {
+      headers = {
+        'User-Agent': this.client.options.http.headers['User-Agent'],
+      };
+    }
+
+    // Some options
+    if (this.options.DiscordContext) {
+      headers['X-Context-Properties'] = Buffer.from(JSON.stringify(this.options.DiscordContext), 'utf8').toString(
+        'base64',
+      );
+    }
+
+    if (this.options.mfaToken) {
+      headers['X-Discord-Mfa-Authorization'] = this.options.mfaToken;
+    }
+
+    // Captcha
+    if (captchaKey && typeof captchaKey == 'string') headers['X-Captcha-Key'] = captchaKey;
+    if (captchaRqToken && typeof captchaRqToken == 'string') headers['X-Captcha-Rqtoken'] = captchaRqToken;
+
+    let body;
+    if (this.options.files?.length) {
+      body = new FormData();
+      for (const [index, file] of this.options.files.entries()) {
+        // Why undici#FormData doesn't support file stream?
+        // Hacky way to support file stream
+        if (file?.file) {
+          body.set(file.key ?? `files[${index}]`, {
+            [Symbol.toStringTag]: 'File',
+            name: file.name,
+            stream: () => file.file,
+          });
+        }
+      }
+      if (typeof this.options.data !== 'undefined') {
+        if (this.options.dontUsePayloadJSON) {
+          for (const [key, value] of Object.entries(this.options.data)) body.append(key, value);
+        } else {
+          body.append('payload_json', JSON.stringify(this.options.data));
+        }
+      }
+      // eslint-disable-next-line eqeqeq
+    } else if (this.options.data != null) {
+      if (this.options.usePayloadJSON) {
+        body = new FormData();
+        body.append('payload_json', JSON.stringify(this.options.data));
+      } else {
+        body = JSON.stringify(this.options.data);
+        headers['Content-Type'] = 'application/json';
+      }
+    }
+
+    const controller = new AbortController();
+    this.rest.controllers.add(controller);
+    const timeout = setTimeout(() => controller.abort(), this.client.options.restRequestTimeout).unref();
+    try {
+      const response = await this.rest.fetch(url, {
+        method: this.method.toUpperCase(), // Undici doesn't normalize "patch" into "PATCH" (which surprisingly follows the spec).
+        headers,
+        body,
+        signal: controller.signal,
+        redirect: 'follow',
+        dispatcher: this.rest.getDispatcher(url),
+        credentials: 'include',
+      });
+      // Keep the deadline active until the body is consumed, including errors and retries.
+      const bytes = await response.arrayBuffer();
+      const buffered = new Response([101, 204, 205, 304].includes(response.status) ? null : bytes, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+      Object.defineProperty(buffered, 'url', { value: response.url });
+      return buffered;
+    } finally {
+      clearTimeout(timeout);
+      this.rest.controllers.delete(controller);
+    }
+  }
+}
+
+module.exports = APIRequest;

package/src/rest/APIRouter.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const noop = () => {}; // eslint-disable-line no-empty-function
+const methods = ['get', 'post', 'delete', 'patch', 'put'];
+const reflectors = [
+  'toString',
+  'valueOf',
+  'inspect',
+  'constructor',
+  Symbol.toPrimitive,
+  Symbol.for('nodejs.util.inspect.custom'),
+];
+
+function buildRoute(manager) {
+  const route = [''];
+  const handler = {
+    get(target, name) {
+      if (reflectors.includes(name)) return () => route.join('/');
+      if (methods.includes(name)) {
+        const routeBucket = [];
+        for (let i = 0; i < route.length; i++) {
+          // Reactions routes and sub-routes all share the same bucket
+          if (route[i - 1] === 'reactions') break;
+          // Literal ids should only be taken account if they are the Major id (the Channel/Guild id)
+          if (/\d{16,19}/g.test(route[i]) && !/channels|guilds/.test(route[i - 1])) routeBucket.push(':id');
+          // All other parts of the route should be considered as part of the bucket identifier
+          else routeBucket.push(route[i]);
+        }
+        return options =>
+          manager.request(
+            name,
+            route.join('/'),
+            Object.assign(
+              {
+                versioned: manager.versioned,
+                route: routeBucket.join('/'),
+              },
+              options,
+            ),
+          );
+      }
+      route.push(name);
+      return new Proxy(noop, handler);
+    },
+    apply(target, _, args) {
+      route.push(...args.filter(x => x != null)); // eslint-disable-line eqeqeq
+      return new Proxy(noop, handler);
+    },
+  };
+  return new Proxy(noop, handler);
+}
+
+module.exports = buildRoute;

package/src/rest/DiscordAPIError.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const redact = require('../util/Redact');
+
+/**
+ * Represents an error from the Discord API.
+ * @extends Error
+ */
+class DiscordAPIError extends Error {
+  constructor(error, status, request) {
+    super();
+    const flattened = this.constructor.flattenErrors(error.errors ?? error).join('\n');
+    this.name = 'DiscordAPIError';
+    this.message = error.message && flattened ? `${error.message}\n${flattened}` : error.message ?? flattened;
+
+    /**
+     * The HTTP method used for the request
+     * @type {string}
+     */
+    this.method = request.method;
+
+    /**
+     * The path of the request relative to the HTTP endpoint
+     * @type {string}
+     */
+    this.path = redact.path(request.path);
+
+    /**
+     * HTTP error code returned by Discord
+     * @type {number}
+     */
+    this.code = error.code;
+
+    /**
+     * The HTTP status code
+     * @type {number}
+     */
+    this.httpStatus = status;
+
+    /**
+     * The data associated with the request that caused this error
+     * @type {HTTPErrorData}
+     */
+    this.requestData = {
+      json: redact(request.options.data),
+      files: request.options.files ?? [],
+      headers: redact(request.options.headers),
+    };
+
+    /**
+     * The number of times this request has been retried
+     * @type {number}
+     */
+    this.retries = request.retries;
+
+    /**
+     * @typedef {Object} Captcha
+     * @property {Array<string>} captcha_key ['message']
+     * @property {string} captcha_sitekey Captcha sitekey (hcaptcha)
+     * @property {string} captcha_service hcaptcha
+     * @property {string} [captcha_rqdata]
+     * @property {string} [captcha_rqtoken]
+     */
+
+    /**
+     * Captcha response data if the request requires a captcha
+     * @type {Captcha | null}
+     */
+    this.captcha = error?.captcha_service ? error : null;
+  }
+
+  /**
+   * A special `40333` JSON error code is returned if your request is blocked by Cloudflare.
+   * This may be due to a malformed request or improper user agent.
+   * The response resembles a normal error structure:
+   * @type {boolean}
+   * @example
+   * {
+   *  "message": "internal network error",
+   *  "code": 40333
+   * }
+   */
+  get isBlockedByCloudflare() {
+    return this.code === 40333;
+  }
+
+  /**
+   * Flattens an errors object returned from the API into an array.
+   * @param {APIError} obj Discord errors object
+   * @param {string} [key] Used internally to determine key names of nested fields
+   * @returns {string[]}
+   * @private
+   */
+  static flattenErrors(obj, key = '') {
+    let messages = [];
+
+    for (const [k, v] of Object.entries(obj)) {
+      if (k === 'message') continue;
+      const newKey = key ? (isNaN(k) ? `${key}.${k}` : `${key}[${k}]`) : k;
+
+      if (v._errors) {
+        messages.push(`${newKey}: ${v._errors.map(e => e.message).join(' ')}`);
+      } else if (v.code ?? v.message) {
+        messages.push(`${v.code ? `${v.code}: ` : ''}${v.message}`.trim());
+      } else if (typeof v === 'string') {
+        messages.push(v);
+      } else {
+        messages = messages.concat(this.flattenErrors(v, newKey));
+      }
+    }
+
+    return messages;
+  }
+}
+
+module.exports = DiscordAPIError;
+
+/**
+ * @external APIError
+ * @see {@link https://discord.com/developers/docs/reference#error-messages}
+ */

package/src/rest/HTTPError.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const redact = require('../util/Redact');
+
+/**
+ * Represents an HTTP error from a request.
+ * @extends Error
+ */
+class HTTPError extends Error {
+  constructor(message, name, code, request) {
+    super(message);
+
+    /**
+     * The name of the error
+     * @type {string}
+     */
+    this.name = name;
+
+    /**
+     * HTTP error code returned from the request
+     * @type {number}
+     */
+    this.code = code ?? 500;
+
+    /**
+     * The HTTP method used for the request
+     * @type {string}
+     */
+    this.method = request.method;
+
+    /**
+     * The path of the request relative to the HTTP endpoint
+     * @type {string}
+     */
+    this.path = redact.path(request.path);
+
+    /**
+     * The HTTP data that was sent to Discord
+     * @typedef {Object} HTTPErrorData
+     * @property {*} json The JSON data that was sent
+     * @property {HTTPAttachmentData[]} files The files that were sent with this request, if any
+     */
+
+    /**
+     * The attachment data that is sent to Discord
+     * @typedef {Object} HTTPAttachmentData
+     * @property {string|Buffer|Stream} attachment The source of this attachment data
+     * @property {string} name The file name
+     * @property {Buffer|Stream} file The file buffer
+     */
+
+    /**
+     * The data associated with the request that caused this error
+     * @type {HTTPErrorData}
+     */
+    this.requestData = {
+      json: redact(request.options.data),
+      files: request.options.files ?? [],
+      headers: redact(request.options.headers),
+    };
+  }
+}
+
+module.exports = HTTPError;

package/src/rest/RESTManager.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const { setInterval } = require('node:timers');
+const { Collection } = require('@discordjs/collection');
+const makeFetchCookie = require('fetch-cookie');
+const { CookieJar } = require('tough-cookie');
+const { fetch: fetchOriginal, buildConnector, Client, ProxyAgent } = require('undici');
+const APIRequest = require('./APIRequest');
+const routeBuilder = require('./APIRouter');
+const RequestHandler = require('./RequestHandler');
+const { Error: DiscordError } = require('../errors');
+const { Endpoints, ciphers } = require('../util/Constants');
+const Util = require('../util/Util');
+
+class RESTManager {
+  constructor(client) {
+    this.client = client;
+    this.handlers = new Collection();
+    this.dispatchers = new Map();
+    this.controllers = new Set();
+    this.destroyed = false;
+    this.abortController = new AbortController();
+    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 = new CookieJar();
+    this.fetch = makeFetchCookie.default(fetchOriginal, this.cookieJar);
+    if (client.options.restSweepInterval > 0) {
+      this.sweepInterval = setInterval(() => {
+        this.handlers.sweep(handler => handler._inactive);
+      }, client.options.restSweepInterval * 1_000).unref();
+    }
+  }
+
+  get api() {
+    return routeBuilder(this);
+  }
+
+  getAuth() {
+    const token = this.client.token ?? this.client.accessToken;
+    if (token) return token?.replace(/Bot /g, '');
+    throw new DiscordError('TOKEN_MISSING');
+  }
+
+  get cdn() {
+    return Endpoints.CDN(this.client.options.http.cdn);
+  }
+
+  request(method, url, options = {}) {
+    if (this.destroyed) return Promise.reject(new Error('REST manager has been destroyed'));
+    const apiRequest = new APIRequest(this, method, url, options);
+    let handler = this.handlers.get(apiRequest.route);
+
+    if (!handler) {
+      handler = new RequestHandler(this);
+      this.handlers.set(apiRequest.route, handler);
+    }
+
+    return handler.push(apiRequest);
+  }
+
+  get endpoint() {
+    return this.client.options.http.api;
+  }
+
+  set endpoint(endpoint) {
+    this.client.options.http.api = endpoint;
+  }
+
+  getDispatcher(url) {
+    if (this.destroyed) throw new Error('REST manager has been destroyed');
+    const origin = new URL(url).origin;
+    let dispatcher = this.dispatchers.get(origin);
+    if (!dispatcher) {
+      const proxy = Util.checkUndiciProxyAgent(this.client.options.http.agent);
+      dispatcher = proxy
+        ? new ProxyAgent({ ...proxy, ciphers: ciphers.join(':') })
+        : new Client(origin, { connect: buildConnector({ ciphers: ciphers.join(':') }) });
+      this.dispatchers.set(origin, dispatcher);
+    }
+    return dispatcher;
+  }
+
+  destroy() {
+    this.destroyed = true;
+    this.abortController.abort();
+    clearInterval(this.sweepInterval);
+    for (const controller of this.controllers) controller.abort();
+    this.controllers.clear();
+    for (const dispatcher of this.dispatchers.values()) dispatcher.destroy().catch(() => {});
+    this.dispatchers.clear();
+  }
+}
+
+module.exports = RESTManager;

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;