discord.js-selfv13 13.0.1

package/src/sharding/ShardClientUtil.js

@@ -0,0 +1,146 @@
+const Util = require('../util/Util');
+
+/**
+ * Helper class for sharded clients spawned as a child process, such as from a ShardingManager.
+ */
+class ShardClientUtil {
+  /**
+   * @param {Client} client The client of the current shard
+   */
+  constructor(client) {
+    this.client = client;
+    process.on('message', this._handleMessage.bind(this));
+    client.on('ready', () => { process.send({ _ready: true }); });
+    client.on('disconnect', () => { process.send({ _disconnect: true }); });
+    client.on('reconnecting', () => { process.send({ _reconnecting: true }); });
+  }
+
+  /**
+   * ID of this shard
+   * @type {number}
+   * @readonly
+   */
+  get id() {
+    return this.client.options.shardId;
+  }
+
+  /**
+   * Total number of shards
+   * @type {number}
+   * @readonly
+   */
+  get count() {
+    return this.client.options.shardCount;
+  }
+
+  /**
+   * Sends a message to the master process.
+   * @param {*} message Message to send
+   * @returns {Promise<void>}
+   */
+  send(message) {
+    return new Promise((resolve, reject) => {
+      process.send(message, err => {
+        if (err) reject(err); else resolve();
+      });
+    });
+  }
+
+  /**
+   * Fetches a client property value of each shard.
+   * @param {string} prop Name of the client property to get, using periods for nesting
+   * @returns {Promise<Array>}
+   * @example
+   * client.shard.fetchClientValues('guilds.size')
+   *   .then(results => {
+   *     console.log(`${results.reduce((prev, val) => prev + val, 0)} total guilds`);
+   *   })
+   *   .catch(console.error);
+   */
+  fetchClientValues(prop) {
+    return new Promise((resolve, reject) => {
+      const listener = message => {
+        if (!message || message._sFetchProp !== prop) return;
+        process.removeListener('message', listener);
+        if (!message._error) resolve(message._result); else reject(Util.makeError(message._error));
+      };
+      process.on('message', listener);
+
+      this.send({ _sFetchProp: prop }).catch(err => {
+        process.removeListener('message', listener);
+        reject(err);
+      });
+    });
+  }
+
+  /**
+   * Evaluates a script on all shards, in the context of the Clients.
+   * @param {string} script JavaScript to run on each shard
+   * @returns {Promise<Array>} Results of the script execution
+   */
+  broadcastEval(script) {
+    return new Promise((resolve, reject) => {
+      const listener = message => {
+        if (!message || message._sEval !== script) return;
+        process.removeListener('message', listener);
+        if (!message._error) resolve(message._result); else reject(Util.makeError(message._error));
+      };
+      process.on('message', listener);
+
+      this.send({ _sEval: script }).catch(err => {
+        process.removeListener('message', listener);
+        reject(err);
+      });
+    });
+  }
+
+  /**
+   * Handles an IPC message.
+   * @param {*} message Message received
+   * @private
+   */
+  _handleMessage(message) {
+    if (!message) return;
+    if (message._fetchProp) {
+      const props = message._fetchProp.split('.');
+      let value = this.client;
+      for (const prop of props) value = value[prop];
+      this._respond('fetchProp', { _fetchProp: message._fetchProp, _result: value });
+    } else if (message._eval) {
+      try {
+        this._respond('eval', { _eval: message._eval, _result: this.client._eval(message._eval) });
+      } catch (err) {
+        this._respond('eval', { _eval: message._eval, _error: Util.makePlainError(err) });
+      }
+    }
+  }
+
+  /**
+   * Sends a message to the master process, emitting an error from the client upon failure.
+   * @param {string} type Type of response to send
+   * @param {*} message Message to send
+   * @private
+   */
+  _respond(type, message) {
+    this.send(message).catch(err => {
+      err.message = `Error when sending ${type} response to master process: ${err.message}`;
+      this.client.emit('error', err);
+    });
+  }
+
+  /**
+   * Creates/gets the singleton of this class.
+   * @param {Client} client The client to use
+   * @returns {ShardClientUtil}
+   */
+  static singleton(client) {
+    if (!this._singleton) {
+      this._singleton = new this(client);
+    } else {
+      client.emit('warn', 'Multiple clients created in child process; only the first will handle sharding helpers.');
+    }
+    return this._singleton;
+  }
+}
+
+module.exports = ShardClientUtil;

package/src/sharding/ShardingManager.js

@@ -0,0 +1,220 @@
+const path = require('path');
+const fs = require('fs');
+const EventEmitter = require('events').EventEmitter;
+const Shard = require('./Shard');
+const Collection = require('../util/Collection');
+const Util = require('../util/Util');
+
+/**
+ * This is a utility class that can be used to help you spawn shards of your client. Each shard is completely separate
+ * from the other. The Shard Manager takes a path to a file and spawns it under the specified amount of shards safely.
+ * If you do not select an amount of shards, the manager will automatically decide the best amount.
+ * @extends {EventEmitter}
+ */
+class ShardingManager extends EventEmitter {
+  /**
+   * @param {string} file Path to your shard script file
+   * @param {Object} [options] Options for the sharding manager
+   * @param {number|string} [options.totalShards='auto'] Number of shards to spawn, or "auto"
+   * @param {boolean} [options.respawn=true] Whether shards should automatically respawn upon exiting
+   * @param {string[]} [options.shardArgs=[]] Arguments to pass to the shard script when spawning
+   * @param {string} [options.token] Token to use for automatic shard count and passing to shards
+   */
+  constructor(file, options = {}) {
+    super();
+    options = Util.mergeDefault({
+      totalShards: 'auto',
+      respawn: true,
+      shardArgs: [],
+      token: null,
+    }, options);
+
+    /**
+     * Path to the shard script file
+     * @type {string}
+     */
+    this.file = file;
+    if (!file) throw new Error('File must be specified.');
+    if (!path.isAbsolute(file)) this.file = path.resolve(process.cwd(), file);
+    const stats = fs.statSync(this.file);
+    if (!stats.isFile()) throw new Error('File path does not point to a file.');
+
+    /**
+     * Amount of shards that this manager is going to spawn
+     * @type {number|string}
+     */
+    this.totalShards = options.totalShards;
+    if (this.totalShards !== 'auto') {
+      if (typeof this.totalShards !== 'number' || isNaN(this.totalShards)) {
+        throw new TypeError('Amount of shards must be a number.');
+      }
+      if (this.totalShards < 1) throw new RangeError('Amount of shards must be at least 1.');
+      if (this.totalShards !== Math.floor(this.totalShards)) {
+        throw new RangeError('Amount of shards must be an integer.');
+      }
+    }
+
+    /**
+     * Whether shards should automatically respawn upon exiting
+     * @type {boolean}
+     */
+    this.respawn = options.respawn;
+
+    /**
+     * An array of arguments to pass to shards
+     * @type {string[]}
+     */
+    this.shardArgs = options.shardArgs;
+
+    /**
+     * Arguments for the shard's process executable
+     * @type {?string[]}
+     */
+    this.execArgv = options.execArgv;
+
+    /**
+     * Token to use for obtaining the automatic shard count, and passing to shards
+     * @type {?string}
+     */
+    this.token = options.token ? options.token.replace(/^Bot\s*/i, '') : null;
+
+    /**
+     * A collection of shards that this manager has spawned
+     * @type {Collection<number, Shard>}
+     */
+    this.shards = new Collection();
+  }
+
+  /**
+   * Spawns a single shard.
+   * @param {number} id The ID of the shard to spawn. **This is usually not necessary**
+   * @returns {Promise<Shard>}
+   */
+  createShard(id = this.shards.size) {
+    const shard = new Shard(this, id, this.shardArgs);
+    this.shards.set(id, shard);
+    /**
+     * Emitted upon launching a shard.
+     * @event ShardingManager#launch
+     * @param {Shard} shard Shard that was launched
+     */
+    this.emit('launch', shard);
+    return Promise.resolve(shard);
+  }
+
+  /**
+   * Spawns multiple shards.
+   * @param {number} [amount=this.totalShards] Number of shards to spawn
+   * @param {number} [delay=7500] How long to wait in between spawning each shard (in milliseconds)
+   * @returns {Promise<Collection<number, Shard>>}
+   */
+  spawn(amount = this.totalShards, delay = 7500) {
+    if (amount === 'auto') {
+      return Util.fetchRecommendedShards(this.token).then(count => {
+        this.totalShards = count;
+        return this._spawn(count, delay);
+      });
+    } else {
+      if (typeof amount !== 'number' || isNaN(amount)) throw new TypeError('Amount of shards must be a number.');
+      if (amount < 1) throw new RangeError('Amount of shards must be at least 1.');
+      if (amount !== Math.floor(amount)) throw new TypeError('Amount of shards must be an integer.');
+      return this._spawn(amount, delay);
+    }
+  }
+
+  /**
+   * Actually spawns shards, unlike that poser above >:(
+   * @param {number} amount Number of shards to spawn
+   * @param {number} delay How long to wait in between spawning each shard (in milliseconds)
+   * @returns {Promise<Collection<number, Shard>>}
+   * @private
+   */
+  _spawn(amount, delay) {
+    return new Promise(resolve => {
+      if (this.shards.size >= amount) throw new Error(`Already spawned ${this.shards.size} shards.`);
+      this.totalShards = amount;
+
+      this.createShard();
+      if (this.shards.size >= this.totalShards) {
+        resolve(this.shards);
+        return;
+      }
+
+      if (delay <= 0) {
+        while (this.shards.size < this.totalShards) this.createShard();
+        resolve(this.shards);
+      } else {
+        const interval = setInterval(() => {
+          this.createShard();
+          if (this.shards.size >= this.totalShards) {
+            clearInterval(interval);
+            resolve(this.shards);
+          }
+        }, delay);
+      }
+    });
+  }
+
+  /**
+   * Send a message to all shards.
+   * @param {*} message Message to be sent to the shards
+   * @returns {Promise<Shard[]>}
+   */
+  broadcast(message) {
+    const promises = [];
+    for (const shard of this.shards.values()) promises.push(shard.send(message));
+    return Promise.all(promises);
+  }
+
+  /**
+   * Evaluates a script on all shards, in the context of the Clients.
+   * @param {string} script JavaScript to run on each shard
+   * @returns {Promise<Array>} Results of the script execution
+   */
+  broadcastEval(script) {
+    const promises = [];
+    for (const shard of this.shards.values()) promises.push(shard.eval(script));
+    return Promise.all(promises);
+  }
+
+  /**
+   * Fetches a client property value of each shard.
+   * @param {string} prop Name of the client property to get, using periods for nesting
+   * @returns {Promise<Array>}
+   * @example
+   * manager.fetchClientValues('guilds.size')
+   *   .then(results => {
+   *     console.log(`${results.reduce((prev, val) => prev + val, 0)} total guilds`);
+   *   })
+   *   .catch(console.error);
+   */
+  fetchClientValues(prop) {
+    if (this.shards.size === 0) return Promise.reject(new Error('No shards have been spawned.'));
+    if (this.shards.size !== this.totalShards) return Promise.reject(new Error('Still spawning shards.'));
+    const promises = [];
+    for (const shard of this.shards.values()) promises.push(shard.fetchClientValue(prop));
+    return Promise.all(promises);
+  }
+
+  /**
+   * Kills all running shards and respawns them.
+   * @param {number} [shardDelay=5000] How long to wait between shards (in milliseconds)
+   * @param {number} [respawnDelay=500] How long to wait between killing a shard's process and restarting it
+   * (in milliseconds)
+   * @param {boolean} [waitForReady=true] Whether to wait for a shard to become ready before continuing to another
+   * @param {number} [currentShardIndex=0] The shard index to start respawning at
+   * @returns {Promise<Collection<number, Shard>>}
+   */
+  respawnAll(shardDelay = 5000, respawnDelay = 500, waitForReady = true, currentShardIndex = 0) {
+    let s = 0;
+    const shard = this.shards.get(currentShardIndex);
+    const promises = [shard.respawn(respawnDelay, waitForReady)];
+    if (++s < this.shards.size && shardDelay > 0) promises.push(Util.delayFor(shardDelay));
+    return Promise.all(promises).then(() => {
+      if (++currentShardIndex === this.shards.size) return this.shards;
+      return this.respawnAll(shardDelay, respawnDelay, waitForReady, currentShardIndex);
+    });
+  }
+}
+
+module.exports = ShardingManager;

package/src/structures/Attachment.js

@@ -0,0 +1,75 @@
+/**
+ * Represents an attachment in a message.
+ * @param {BufferResolvable|Stream} file The file
+ * @param {string} [name] The name of the file, if any
+ */
+class Attachment {
+  constructor(file, name) {
+    this.file = null;
+    if (name) this.setAttachment(file, name);
+    else this._attach(file);
+  }
+
+  /**
+    * The name of the file
+    * @type {?string}
+    * @readonly
+    */
+  get name() {
+    return this.file.name;
+  }
+
+  /**
+    * The file
+    * @type {?BufferResolvable|Stream}
+    * @readonly
+    */
+  get attachment() {
+    return this.file.attachment;
+  }
+
+  /**
+    * Set the file of this attachment.
+    * @param {BufferResolvable|Stream} file The file
+    * @param {string} name The name of the file
+    * @returns {Attachment} This attachment
+    */
+  setAttachment(file, name) {
+    this.file = { attachment: file, name };
+    return this;
+  }
+
+  /**
+    * Set the file of this attachment.
+    * @param {BufferResolvable|Stream} attachment The file
+    * @returns {Attachment} This attachment
+    */
+  setFile(attachment) {
+    this.file = { attachment };
+    return this;
+  }
+
+  /**
+    * Set the name of this attachment.
+    * @param {string} name The name of the image
+    * @returns {Attachment} This attachment
+    */
+  setName(name) {
+    this.file.name = name;
+    return this;
+  }
+
+  /**
+    * Set the file of this attachment.
+    * @param {BufferResolvable|Stream} file The file
+    * @param {string} name The name of the file
+    * @returns {void}
+    * @private
+    */
+  _attach(file, name) {
+    if (typeof file === 'string') this.file = file;
+    else this.setAttachment(file, name);
+  }
+}
+
+module.exports = Attachment;

package/src/structures/CategoryChannel.js

@@ -0,0 +1,22 @@
+const GuildChannel = require('./GuildChannel');
+
+/**
+ * Represents a guild category channel on Discord.
+ * @extends {GuildChannel}
+ */
+class CategoryChannel extends GuildChannel {
+  constructor(guild, data) {
+    super(guild, data);
+    this.type = 'category';
+  }
+  /**
+   * The channels that are part of this category
+   * @type {?Collection<Snowflake, GuildChannel>}
+   * @readonly
+   */
+  get children() {
+    return this.guild.channels.filter(c => c.parentID === this.id);
+  }
+}
+
+module.exports = CategoryChannel;

package/src/structures/Channel.js

@@ -0,0 +1,78 @@
+const Snowflake = require('../util/Snowflake');
+
+/**
+ * Represents any channel on Discord.
+ */
+class Channel {
+  constructor(client, data) {
+    /**
+     * The client that instantiated the Channel
+     * @name Channel#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * The type of the channel, either:
+     * * `dm` - a DM channel
+     * * `group` - a Group DM channel
+     * * `text` - a guild text channel
+     * * `voice` - a guild voice channel
+     * * `category` - a guild category channel
+     * * `news` - a guild news channel
+     * * `store` - a guild store channel
+     * @type {string}
+     */
+    this.type = null;
+
+    /**
+     * Whether the channel has been deleted
+     * @type {boolean}
+     */
+    this.deleted = false;
+
+    if (data) this.setup(data);
+  }
+
+  setup(data) {
+    /**
+     * The unique ID of the channel
+     * @type {Snowflake}
+     */
+    this.id = data.id;
+  }
+
+  /**
+   * The timestamp the channel was created at
+   * @type {number}
+   * @readonly
+   */
+  get createdTimestamp() {
+    return Snowflake.deconstruct(this.id).timestamp;
+  }
+
+  /**
+   * The time the channel was created
+   * @type {Date}
+   * @readonly
+   */
+  get createdAt() {
+    return new Date(this.createdTimestamp);
+  }
+
+  /**
+   * Deletes the channel.
+   * @returns {Promise<Channel>}
+   * @example
+   * // Delete the channel
+   * channel.delete()
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  delete() {
+    return this.client.rest.methods.deleteChannel(this);
+  }
+}
+
+module.exports = Channel;