safeness-sb-new 0.0.1

package/src/managers/UserNoteManager.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const BaseManager = require('./BaseManager');
+
+/**
+ * Manages API methods for Client and stores their cache.
+ * @extends {BaseManager}
+ */
+class UserNoteManager extends BaseManager {
+  constructor(client, data = {}) {
+    super(client);
+    /**
+     * Cache User Note
+     * @type {Collection<Snowflake, string>}
+     */
+    this.cache = new Collection(Object.entries(data));
+  }
+
+  _reload(data = {}) {
+    this.cache = new Collection(Object.entries(data));
+    return this;
+  }
+
+  async updateNote(id, note = null) {
+    await this.client.api.users['@me'].notes(id).put({ data: { note } });
+    if (!note) this.cache.delete(id, note);
+    else this.cache.set(id, note);
+    return this;
+  }
+
+  /**
+   * Obtains a user from Discord, or the user cache if it's already available.
+   * @param {UserResolvable} user The user to fetch
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<string>}
+   */
+  async fetch(user, { cache = true, force = false } = {}) {
+    const id = this.resolveId(user);
+    if (!force) {
+      const existing = this.cache.get(id);
+      if (existing) return existing;
+    }
+    const data = await this.client.api.users['@me'].notes[id]
+      .get()
+      .then(d => d.note)
+      .catch(() => '');
+    if (cache) this.cache.set(id, data);
+    return data;
+  }
+}
+
+module.exports = UserNoteManager;

package/src/managers/VoiceStateManager.js

@@ -0,0 +1,37 @@
+'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;
+  }
+}
+
+module.exports = VoiceStateManager;

package/src/rest/APIRequest.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const Buffer = require('node:buffer').Buffer;
+const https = require('node:https');
+const { setTimeout } = require('node:timers');
+const makeFetchCookie = require('fetch-cookie');
+const FormData = require('form-data');
+const fetchOriginal = require('node-fetch');
+const { CookieJar } = require('tough-cookie');
+const { ciphers } = require('../util/Constants');
+const Util = require('../util/Util');
+
+const cookieJar = new CookieJar();
+const fetch = makeFetchCookie(fetchOriginal, cookieJar);
+
+let agent = null;
+
+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}`}`;
+  }
+
+  make(captchaKey, captchaRqToken) {
+    if (!agent) {
+      if (Util.verifyProxyAgent(this.client.options.http.agent)) {
+        // Bad code
+        for (const [k, v] of Object.entries({
+          keepAlive: true,
+          honorCipherOrder: true,
+          secureProtocol: 'TLSv1_2_method',
+          ciphers: ciphers.join(':'),
+        })) {
+          this.client.options.http.agent.httpsAgent[k] = v;
+        }
+        agent = this.client.options.http.agent;
+      } else {
+        agent = new https.Agent({
+          ...this.client.options.http.agent,
+          keepAlive: true,
+          honorCipherOrder: true,
+          secureProtocol: 'TLSv1_2_method',
+          ciphers: ciphers.join(':'),
+        });
+      }
+    }
+
+    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 = {
+      authority: 'discord.com',
+      accept: '*/*',
+      'accept-language': 'en-US',
+      'sec-ch-ua': '"Not?A_Brand";v="8", "Chromium";v="108"',
+      'sec-ch-ua-mobile': '?0',
+      'sec-ch-ua-platform': '"Windows"',
+      'sec-fetch-dest': 'empty',
+      'sec-fetch-mode': 'cors',
+      'sec-fetch-site': 'same-origin',
+      'x-debug-options': 'bugReporterEnabled',
+      'x-discord-locale': 'en-US',
+      'x-discord-timezone': 'Asia/Saigon',
+      'x-super-properties': `${Buffer.from(JSON.stringify(this.client.options.ws.properties), 'ascii').toString(
+        'base64',
+      )}`,
+      Referer: 'https://discord.com/channels/@me',
+      origin: 'https://discord.com',
+      'Referrer-Policy': 'strict-origin-when-cross-origin',
+      ...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;
+    }
+
+    let body;
+    if (this.options.files?.length) {
+      body = new FormData();
+      for (const [index, file] of this.options.files.entries()) {
+        if (file?.file) body.append(file.key ?? `files[${index}]`, file.file, file.name);
+      }
+      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));
+        }
+      }
+      headers = Object.assign(headers, body.getHeaders());
+      // 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';
+      }
+    }
+
+    // Captcha
+    if (captchaKey && typeof captchaKey == 'string') headers['X-Captcha-Key'] = captchaKey;
+    if (captchaRqToken && typeof captchaRqToken == 'string') headers['X-Captcha-Rqtoken'] = captchaRqToken;
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.client.options.restRequestTimeout).unref();
+    return fetch(url, {
+      method: this.method,
+      headers,
+      agent,
+      body,
+      signal: controller.signal,
+    }).finally(() => clearTimeout(timeout));
+  }
+}
+
+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,104 @@
+'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]
+     */
+
+    /**
+     * Captcha response data if the request requires a captcha
+     * @type {Captcha | null}
+     */
+    this.captcha = error?.captcha_service ? error : null;
+  }
+
+  /**
+   * 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;

package/src/rest/RESTManager.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const { setInterval } = require('node:timers');
+const { Collection } = require('@discordjs/collection');
+const APIRequest = require('./APIRequest');
+const routeBuilder = require('./APIRouter');
+const RequestHandler = require('./RequestHandler');
+const { Error } = require('../errors');
+const { Endpoints } = require('../util/Constants');
+
+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;
+    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 Error('TOKEN_MISSING');
+  }
+
+  get cdn() {
+    return Endpoints.CDN(this.client.options.http.cdn);
+  }
+
+  request(method, url, options = {}) {
+    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;
+  }
+}
+
+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;