@biggy1337/discord-sbjs 1.3.11

package/src/managers/VoiceStateManager.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const CachedManager = require('./CachedManager');
+const VoiceState = require('../structures/VoiceState');
+
+/**
+ * Manages API methods for VoiceStates and stores their cache.
+ * @extends {CachedManager}
+ */
+class VoiceStateManager extends CachedManager {
+  constructor(guild, iterable) {
+    super(guild.client, VoiceState, iterable);
+
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, VoiceState>}
+   * @name VoiceStateManager#cache
+   */
+
+  _add(data, cache = true) {
+    const existing = this.cache.get(data.user_id);
+    if (existing) return existing._patch(data);
+
+    const entry = new this.holds(this.guild, data);
+    if (cache) this.cache.set(data.user_id, entry);
+    return entry;
+  }
+
+  /**
+   * Obtains a user's voice state from discord or from the cache if it's already available.
+   * @param {GuildMemberResolvable|'@me'} member The member whose voice state is to be fetched
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<VoiceState>}
+   * @example
+   * // Fetch a member's voice state
+   * guild.voiceStates.fetch("66564597481480192")
+   *    .then(console.log)
+   *    .catch(console.error);
+   */
+  async fetch(member, { cache = true, force = false } = {}) {
+    if (!this.guild?.id) throw new Error('Guild is not defined');
+    const id = member === '@me' ? member : this.guild.members.resolveId(member);
+    if (!force) {
+      const existing = this.cache.get(id === '@me' ? this.client.user.id : id);
+      if (existing) return existing;
+    }
+    const data = await this.client.api.guilds(this.guild.id)['voice-states'][id].get();
+    return this._add(data, cache);
+  }
+}
+
+module.exports = VoiceStateManager;

package/src/rest/APIRequest.js

@@ -0,0 +1,198 @@
+'use strict';
+
+const Buffer = require('node:buffer').Buffer;
+const { setTimeout } = require('node:timers');
+const { ciphers } = require('../util/Constants');
+const { getNativeFormData } = require('../util/FetchUtil');
+
+const cypherList = ciphers.join(':');
+
+const skyselfbotontop = (wsProperties = {}) => {
+  const locale = wsProperties.system_locale || 'en-US';
+  return {
+    accept: '*/*',
+    'accept-language': locale,
+    priority: 'u=1, i',
+    authority: 'discord.com',
+    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': locale,
+    origin: 'https://discord.com',
+  };
+};
+
+const isReadableStream = value => value && typeof value.getReader === 'function';
+const isNodeReadable = value => value && typeof value.pipe === 'function';
+const cloneHeaders = source => Object.assign({}, source);
+const applyHeaderOverrides = (headers, overrides) => {
+  if (!overrides) return;
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === undefined) delete headers[key];
+    else headers[key] = value;
+  }
+};
+
+const streamToBuffer = async stream => {
+  if (isReadableStream(stream)) {
+    const arrayBuffer = await new Response(stream).arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+
+  const chunks = [];
+  for await (const chunk of stream) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks);
+};
+
+const toFile = async (value, name) => {
+  if (value instanceof File) return value;
+  if (value instanceof Blob) return new File([value], name, { type: value.type || undefined });
+  if (Buffer.isBuffer(value) || value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    return new File([value], name);
+  }
+  if (isReadableStream(value) || isNodeReadable(value)) {
+    const buffer = await streamToBuffer(value);
+    return new File([buffer], name);
+  }
+  if (value?.arrayBuffer) {
+    const buffer = await value.arrayBuffer();
+    return new File([buffer], name);
+  }
+  return new File([String(value)], name);
+};
+
+class APIRequest {
+  constructor(rest, method, path, options) {
+    this.rest = rest;
+    this.client = rest.client;
+    this.method = method;
+    this.methodUpper = method.toUpperCase();
+    this.route = options.route;
+    this.options = options;
+    this.retries = 0;
+
+    this.fullUserAgent = this.client.options.http.headers['User-Agent'];
+    this.superProperties = rest.getSuperProperties(this.fullUserAgent);
+
+    let queryString = '';
+    if (options.query) {
+      const params = new URLSearchParams();
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value === null || typeof value === 'undefined') continue;
+        if (Array.isArray(value)) {
+          for (const v of value) params.append(key, v);
+        } else {
+          params.append(key, value);
+        }
+      }
+      queryString = params.toString();
+    }
+    this.path = queryString ? `${path}?${queryString}` : path;
+  }
+
+  getProxyConfig() {
+    return this.rest.getProxyConfig();
+  }
+
+  async make(captchaKey, captchaRqToken, captchaSessionId) {
+    const fetch = this.rest.fetch;
+    const FormData = typeof this.rest.getFormData === 'function' ? this.rest.getFormData() : getNativeFormData();
+
+    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;
+
+    const headers =
+      this.options.webhook === true ? {} : cloneHeaders(skyselfbotontop(this.client.options.ws?.properties || {}));
+
+    if (this.options.webhook !== true) {
+      headers['x-super-properties'] = this.superProperties;
+      headers['X-Super-Properties'] = this.superProperties;
+
+      const timezone = this.rest.getTimezone();
+      if (timezone !== undefined) headers['X-Discord-Timezone'] = timezone;
+
+      applyHeaderOverrides(headers, this.client.options.http.headers);
+      headers['User-Agent'] = this.fullUserAgent;
+
+      if (this.options.auth !== false) {
+        headers.Authorization = this.rest.getAuth();
+      }
+
+      const fingerprint = this.rest.getFingerprint?.();
+      if (fingerprint) {
+        headers.fingerprint = fingerprint;
+      }
+
+      if (this.options.reason) headers['X-Audit-Log-Reason'] = encodeURIComponent(this.options.reason);
+      applyHeaderOverrides(headers, this.options.headers);
+    } else {
+      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;
+    if (captchaSessionId && typeof captchaSessionId == 'string') headers['X-Captcha-Session-Id'] = captchaSessionId;
+
+    let body;
+    if (this.options.files?.length) {
+      body = new FormData();
+      for (const [index, file] of this.options.files.entries()) {
+        if (!file?.file) continue;
+        const resolved = await toFile(file.file, file.name ?? `file-${index}`);
+        body.append(file.key ?? `files[${index}]`, resolved);
+      }
+      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();
+    const timeout = setTimeout(() => controller.abort(), this.client.options.restRequestTimeout).unref();
+    const fetchOptions = {
+      method: this.methodUpper, // Undici doesn't normalize "patch" into "PATCH" (which surprisingly follows the spec).
+      headers,
+      body,
+      signal: controller.signal,
+      redirect: 'follow',
+      credentials: 'include',
+    };
+    if (cypherList) fetchOptions.tls = { ciphers: cypherList };
+    const proxy = this.getProxyConfig();
+    if (proxy) fetchOptions.proxy = proxy;
+    return fetch(url, fetchOptions).finally(() => clearTimeout(timeout));
+  }
+}
+
+module.exports = APIRequest;

package/src/rest/APIRouter.js

@@ -0,0 +1,94 @@
+/* eslint-disable space-before-function-paren */
+'use strict';
+
+const methods = new Set(['get', 'post', 'delete', 'patch', 'put']);
+const reflectors = new Set([
+  'toString',
+  'valueOf',
+  'inspect',
+  'constructor',
+  Symbol.toPrimitive,
+  Symbol.for('nodejs.util.inspect.custom'),
+]);
+const idRouteRegex = /\d{16,19}/;
+const majorIdRoutes = new Set(['channels', 'guilds', 'webhooks']);
+const kState = Symbol('api_route_state');
+
+function buildRoute(manager) {
+  const createProxy = state => {
+    // The target must be callable for the `apply` trap to work.
+    // eslint-disable-next-line func-style
+    const target = function () {}; // eslint-disable-line func-names
+    Object.defineProperty(target, kState, { value: state, writable: true });
+    return new Proxy(target, handler);
+  };
+
+  const appendSegment = (state, segment) => {
+    const seg = String(segment);
+
+    const nextPath = `${state.path}/${seg}`;
+    const nextPrev = seg;
+
+    const freezeBuckets = state.bucketFrozen || state.prev === 'reactions';
+    if (freezeBuckets) {
+      return {
+        path: nextPath,
+        bucketRoute: state.bucketRoute,
+        bucketFrozen: true,
+        prev: nextPrev,
+      };
+    }
+
+    const bucketSegment = idRouteRegex.test(seg) && !majorIdRoutes.has(state.prev) ? ':id' : seg;
+    const nextBucket = `${state.bucketRoute}/${bucketSegment}`;
+
+    return {
+      path: nextPath,
+      bucketRoute: nextBucket,
+      bucketFrozen: false,
+      prev: nextPrev,
+    };
+  };
+
+  const handler = {
+    get(target, name) {
+      const state = target[kState];
+
+      // Avoid the proxy being treated as a thenable by Promise resolution / `await`.
+      if (name === 'then') return undefined;
+
+      if (reflectors.has(name)) return () => state.path;
+
+      if (methods.has(name)) {
+        return options =>
+          manager.request(
+            name,
+            state.path,
+            Object.assign(
+              {
+                versioned: manager.versioned,
+                route: state.bucketRoute,
+              },
+              options,
+            ),
+          );
+      }
+      if (typeof name === 'symbol') return undefined;
+
+      return createProxy(appendSegment(state, name));
+    },
+    apply(target, _, args) {
+      let state = target[kState];
+      for (const arg of args) {
+        // eslint-disable-next-line eqeqeq
+        if (arg == null) continue;
+        state = appendSegment(state, arg);
+      }
+      return createProxy(state);
+    },
+  };
+
+  return createProxy({ path: '', bucketRoute: '', bucketFrozen: false, prev: '' });
+}
+
+module.exports = buildRoute;

package/src/rest/DiscordAPIError.js

@@ -0,0 +1,120 @@
+'use strict';
+
+/**
+ * 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 = 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: request.options.data,
+      files: request.options.files ?? [],
+      headers: 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]
+     * @property {string} [captcha_session_id]
+     */
+
+    /**
+     * 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,62 @@
+'use strict';
+
+/**
+ * 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 = 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: request.options.data,
+      files: request.options.files ?? [],
+      headers: request.options.headers,
+    };
+  }
+}
+
+module.exports = HTTPError;