discord.js-dmall-v11 0.0.1-security → 2.4.5

package/src/structures/CommandInteractionOptionResolver.js

@@ -0,0 +1,276 @@
+'use strict';
+
+const { TypeError } = require('../errors');
+
+/**
+ * A resolver for command interaction options.
+ */
+class CommandInteractionOptionResolver {
+  constructor(client, options, resolved) {
+    /**
+     * The client that instantiated this.
+     * @name CommandInteractionOptionResolver#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * The name of the subcommand group.
+     * @type {?string}
+     * @private
+     */
+    this._group = null;
+
+    /**
+     * The name of the subcommand.
+     * @type {?string}
+     * @private
+     */
+    this._subcommand = null;
+
+    /**
+     * The bottom-level options for the interaction.
+     * If there is a subcommand (or subcommand and group), this is the options for the subcommand.
+     * @type {CommandInteractionOption[]}
+     * @private
+     */
+    this._hoistedOptions = options;
+
+    // Hoist subcommand group if present
+    if (this._hoistedOptions[0]?.type === 'SUB_COMMAND_GROUP') {
+      this._group = this._hoistedOptions[0].name;
+      this._hoistedOptions = this._hoistedOptions[0].options ?? [];
+    }
+    // Hoist subcommand if present
+    if (this._hoistedOptions[0]?.type === 'SUB_COMMAND') {
+      this._subcommand = this._hoistedOptions[0].name;
+      this._hoistedOptions = this._hoistedOptions[0].options ?? [];
+    }
+
+    /**
+     * The interaction options array.
+     * @name CommandInteractionOptionResolver#data
+     * @type {ReadonlyArray<CommandInteractionOption>}
+     * @readonly
+     */
+    Object.defineProperty(this, 'data', { value: Object.freeze([...options]) });
+
+    /**
+     * The interaction resolved data
+     * @name CommandInteractionOptionResolver#resolved
+     * @type {Readonly<CommandInteractionResolvedData>}
+     */
+    Object.defineProperty(this, 'resolved', { value: Object.freeze(resolved) });
+  }
+
+  /**
+   * Gets an option by its name.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?CommandInteractionOption} The option, if found.
+   */
+  get(name, required = false) {
+    const option = this._hoistedOptions.find(opt => opt.name === name);
+    if (!option) {
+      if (required) {
+        throw new TypeError('COMMAND_INTERACTION_OPTION_NOT_FOUND', name);
+      }
+      return null;
+    }
+    return option;
+  }
+
+  /**
+   * Gets an option by name and property and checks its type.
+   * @param {string} name The name of the option.
+   * @param {ApplicationCommandOptionType} type The type of the option.
+   * @param {string[]} properties The properties to check for for `required`.
+   * @param {boolean} required Whether to throw an error if the option is not found.
+   * @returns {?CommandInteractionOption} The option, if found.
+   * @private
+   */
+  _getTypedOption(name, type, properties, required) {
+    const option = this.get(name, required);
+    if (!option) {
+      return null;
+    } else if (option.type !== type) {
+      throw new TypeError('COMMAND_INTERACTION_OPTION_TYPE', name, option.type, type);
+    } else if (required && properties.every(prop => option[prop] === null || typeof option[prop] === 'undefined')) {
+      throw new TypeError('COMMAND_INTERACTION_OPTION_EMPTY', name, option.type);
+    }
+    return option;
+  }
+
+  /**
+   * Gets the selected subcommand.
+   * @param {boolean} [required=true] Whether to throw an error if there is no subcommand.
+   * @returns {?string} The name of the selected subcommand, or null if not set and not required.
+   */
+  getSubcommand(required = true) {
+    if (required && !this._subcommand) {
+      throw new TypeError('COMMAND_INTERACTION_OPTION_NO_SUB_COMMAND');
+    }
+    return this._subcommand;
+  }
+
+  /**
+   * Gets the selected subcommand group.
+   * @param {boolean} [required=true] Whether to throw an error if there is no subcommand group.
+   * @returns {?string} The name of the selected subcommand group, or null if not set and not required.
+   */
+  getSubcommandGroup(required = true) {
+    if (required && !this._group) {
+      throw new TypeError('COMMAND_INTERACTION_OPTION_NO_SUB_COMMAND_GROUP');
+    }
+    return this._group;
+  }
+
+  /**
+   * Gets a boolean option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?boolean} The value of the option, or null if not set and not required.
+   */
+  getBoolean(name, required = false) {
+    const option = this._getTypedOption(name, 'BOOLEAN', ['value'], required);
+    return option?.value ?? null;
+  }
+
+  /**
+   * Gets a channel option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?(GuildChannel|ThreadChannel|APIChannel)}
+   * The value of the option, or null if not set and not required.
+   */
+  getChannel(name, required = false) {
+    const option = this._getTypedOption(name, 'CHANNEL', ['channel'], required);
+    return option?.channel ?? null;
+  }
+
+  /**
+   * Gets a string option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?string} The value of the option, or null if not set and not required.
+   */
+  getString(name, required = false) {
+    const option = this._getTypedOption(name, 'STRING', ['value'], required);
+    return option?.value ?? null;
+  }
+
+  /**
+   * Gets an integer option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?number} The value of the option, or null if not set and not required.
+   */
+  getInteger(name, required = false) {
+    const option = this._getTypedOption(name, 'INTEGER', ['value'], required);
+    return option?.value ?? null;
+  }
+
+  /**
+   * Gets a number option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?number} The value of the option, or null if not set and not required.
+   */
+  getNumber(name, required = false) {
+    const option = this._getTypedOption(name, 'NUMBER', ['value'], required);
+    return option?.value ?? null;
+  }
+
+  /**
+   * Gets a user option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?User} The value of the option, or null if not set and not required.
+   */
+  getUser(name, required = false) {
+    const option = this._getTypedOption(name, 'USER', ['user'], required);
+    return option?.user ?? null;
+  }
+
+  /**
+   * Gets a member option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?(GuildMember|APIGuildMember)}
+   * The value of the option, or null if not set and not required.
+   */
+  getMember(name, required = false) {
+    const option = this._getTypedOption(name, 'USER', ['member'], required);
+    return option?.member ?? null;
+  }
+
+  /**
+   * Gets a role option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?(Role|APIRole)} The value of the option, or null if not set and not required.
+   */
+  getRole(name, required = false) {
+    const option = this._getTypedOption(name, 'ROLE', ['role'], required);
+    return option?.role ?? null;
+  }
+
+  /**
+   * Gets a mentionable option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?(User|GuildMember|APIGuildMember|Role|APIRole)}
+   * The value of the option, or null if not set and not required.
+   */
+  getMentionable(name, required = false) {
+    const option = this._getTypedOption(name, 'MENTIONABLE', ['user', 'member', 'role'], required);
+    return option?.member ?? option?.user ?? option?.role ?? null;
+  }
+
+  /**
+   * Gets a message option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?(Message|APIMessage)}
+   * The value of the option, or null if not set and not required.
+   */
+  getMessage(name, required = false) {
+    const option = this._getTypedOption(name, '_MESSAGE', ['message'], required);
+    return option?.message ?? null;
+  }
+
+  /**
+   * The full autocomplete option object.
+   * @typedef {Object} AutocompleteFocusedOption
+   * @property {string} name The name of the option
+   * @property {ApplicationCommandOptionType} type The type of the application command option
+   * @property {string} value The value of the option
+   * @property {boolean} focused Whether this option is currently in focus for autocomplete
+   */
+
+  /**
+   * Gets the focused option.
+   * @param {boolean} [getFull=false] Whether to get the full option object
+   * @returns {string|AutocompleteFocusedOption}
+   * The value of the option, or the whole option if getFull is true
+   */
+  getFocused(getFull = false) {
+    const focusedOption = this._hoistedOptions.find(option => option.focused);
+    if (!focusedOption) throw new TypeError('AUTOCOMPLETE_INTERACTION_OPTION_NO_FOCUSED_OPTION');
+    return getFull ? focusedOption : focusedOption.value;
+  }
+
+  /**
+   * Gets an attachment option.
+   * @param {string} name The name of the option.
+   * @param {boolean} [required=false] Whether to throw an error if the option is not found.
+   * @returns {?MessageAttachment} The value of the option, or null if not set and not required.
+   */
+  getAttachment(name, required = false) {
+    const option = this._getTypedOption(name, 'ATTACHMENT', ['attachment'], required);
+    return option?.attachment ?? null;
+  }
+}
+
+module.exports = CommandInteractionOptionResolver;

package/src/structures/ContextMenuInteraction.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const BaseCommandInteraction = require('./BaseCommandInteraction');
+const CommandInteractionOptionResolver = require('./CommandInteractionOptionResolver');
+const { ApplicationCommandOptionTypes, ApplicationCommandTypes } = require('../util/Constants');
+
+/**
+ * Represents a context menu interaction.
+ * @extends {BaseCommandInteraction}
+ */
+class ContextMenuInteraction extends BaseCommandInteraction {
+  constructor(client, data) {
+    super(client, data);
+    /**
+     * The target of the interaction, parsed into options
+     * @type {CommandInteractionOptionResolver}
+     */
+    this.options = new CommandInteractionOptionResolver(
+      this.client,
+      this.resolveContextMenuOptions(data.data),
+      this.transformResolved(data.data.resolved),
+    );
+
+    /**
+     * The id of the target of the interaction
+     * @type {Snowflake}
+     */
+    this.targetId = data.data.target_id;
+
+    /**
+     * The type of the target of the interaction; either USER or MESSAGE
+     * @type {ApplicationCommandType}
+     */
+    this.targetType = ApplicationCommandTypes[data.data.type];
+  }
+
+  /**
+   * Resolves and transforms options received from the API for a context menu interaction.
+   * @param {APIApplicationCommandInteractionData} data The interaction data
+   * @returns {CommandInteractionOption[]}
+   * @private
+   */
+  resolveContextMenuOptions({ target_id, resolved }) {
+    const result = [];
+
+    if (resolved.users?.[target_id]) {
+      result.push(
+        this.transformOption({ name: 'user', type: ApplicationCommandOptionTypes.USER, value: target_id }, resolved),
+      );
+    }
+
+    if (resolved.messages?.[target_id]) {
+      result.push({
+        name: 'message',
+        type: '_MESSAGE',
+        value: target_id,
+        message: this.channel?.messages._add(resolved.messages[target_id]) ?? resolved.messages[target_id],
+      });
+    }
+
+    return result;
+  }
+}
+
+module.exports = ContextMenuInteraction;

package/src/structures/DMChannel.js

@@ -0,0 +1,280 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { joinVoiceChannel, entersState, VoiceConnectionStatus } = require('@discordjs/voice');
+const { Channel } = require('./Channel');
+const TextBasedChannel = require('./interfaces/TextBasedChannel');
+const InteractionManager = require('../managers/InteractionManager');
+const MessageManager = require('../managers/MessageManager');
+const { Status, Opcodes } = require('../util/Constants');
+
+/**
+ * Represents a direct message channel between two users.
+ * @extends {Channel}
+ * @implements {TextBasedChannel}
+ */
+class DMChannel extends Channel {
+  constructor(client, data) {
+    super(client, data);
+
+    // Override the channel type so partials have a known type
+    this.type = 'DM';
+
+    /**
+     * A manager of the messages belonging to this channel
+     * @type {MessageManager}
+     */
+    this.messages = new MessageManager(this);
+
+    /**
+     * A manager of the interactions sent to this channel
+     * @type {InteractionManager}
+     */
+    this.interactions = new InteractionManager(this);
+  }
+
+  _patch(data) {
+    super._patch(data);
+
+    if (data.recipients) {
+      /**
+       * The recipient on the other end of the DM
+       * @type {User}
+       */
+      this.recipient = this.client.users._add(data.recipients[0]);
+    }
+
+    if ('last_message_id' in data) {
+      /**
+       * The channel's last message id, if one was sent
+       * @type {?Snowflake}
+       */
+      this.lastMessageId = data.last_message_id;
+    }
+
+    if ('last_pin_timestamp' in data) {
+      /**
+       * The timestamp when the last pinned message was pinned, if there was one
+       * @type {?number}
+       */
+      this.lastPinTimestamp = new Date(data.last_pin_timestamp).getTime();
+    } else {
+      this.lastPinTimestamp ??= null;
+    }
+
+    if ('is_message_request' in data) {
+      /**
+       * Whether the channel is a message request
+       * @type {boolean}
+       */
+      this.messageRequest = data.is_message_request;
+    }
+
+    if ('is_message_request_timestamp' in data) {
+      /**
+       * The timestamp when the message request was created
+       * @type {?number}
+       */
+      this.messageRequestTimestamp = new Date(data.is_message_request_timestamp).getTime();
+    }
+  }
+
+  /**
+   * Accept this DMChannel.
+   * @returns {Promise<DMChannel>}
+   */
+  async acceptMessageRequest() {
+    if (!this.messageRequest) {
+      throw new Error('NOT_MESSAGE_REQUEST', 'This channel is not a message request');
+    }
+    const c = await this.client.api.channels[this.id].recipients['@me'].put({
+      data: {
+        consent_status: 2,
+      },
+    });
+    this.messageRequest = false;
+    return this.client.channels._add(c);
+  }
+
+  /**
+   * Cancel this DMChannel.
+   * @returns {Promise<DMChannel>}
+   */
+  async cancelMessageRequest() {
+    if (!this.messageRequest) {
+      throw new Error('NOT_MESSAGE_REQUEST', 'This channel is not a message request');
+    }
+    await this.client.api.channels[this.id].recipients['@me'].delete();
+    return this;
+  }
+
+  /**
+   * Whether this DMChannel is a partial
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return typeof this.lastMessageId === 'undefined';
+  }
+
+  /**
+   * Fetch this DMChannel.
+   * @param {boolean} [force=true] Whether to skip the cache check and request the API
+   * @returns {Promise<DMChannel>}
+   */
+  fetch(force = true) {
+    return this.recipient.createDM(force);
+  }
+
+  /**
+   * When concatenated with a string, this automatically returns the recipient's mention instead of the
+   * DMChannel object.
+   * @returns {string}
+   * @example
+   * // Logs: Hello from <@123456789012345678>!
+   * console.log(`Hello from ${channel}!`);
+   */
+  toString() {
+    return this.recipient.toString();
+  }
+
+  // These are here only for documentation purposes - they are implemented by TextBasedChannel
+  /* eslint-disable no-empty-function */
+  get lastMessage() {}
+  get lastPinAt() {}
+  send() {}
+  sendTyping() {}
+  createMessageCollector() {}
+  awaitMessages() {}
+  createMessageComponentCollector() {}
+  awaitMessageComponent() {}
+  sendSlash() {}
+  searchInteraction() {}
+  // Doesn't work on DM channels; bulkDelete() {}
+  // Doesn't work on DM channels; setRateLimitPerUser() {}
+  // Doesn't work on DM channels; setNSFW() {}
+  // Testing feature: Call
+  // URL: https://discord.com/api/v9/channels/DMchannelId/call/ring
+  /**
+   * Call this DMChannel. Return discordjs/voice VoiceConnection
+   * @param {CallOptions} options Options for the call
+   * @returns {Promise<VoiceConnection>}
+   */
+  call(options = {}) {
+    options = Object.assign(
+      {
+        ring: true,
+      },
+      options || {},
+    );
+    return new Promise((resolve, reject) => {
+      if (!this.client.options.patchVoice) {
+        reject(
+          new Error(
+            'VOICE_NOT_PATCHED',
+            'Enable voice patching in client options\nhttps://discordjs-self-v13.netlify.app/#/docs/docs/main/typedef/ClientOptions',
+          ),
+        );
+      } else {
+        if (options.ring) {
+          this.client.api.channels(this.id).call.ring.post({
+            data: {
+              recipients: null,
+            },
+          });
+        }
+        const connection = joinVoiceChannel({
+          channelId: this.id,
+          guildId: null,
+          adapterCreator: this.voiceAdapterCreator,
+          selfDeaf: options.selfDeaf ?? false,
+          selfMute: options.selfMute ?? false,
+        });
+        entersState(connection, VoiceConnectionStatus.Ready, 30000)
+          .then(connection => {
+            resolve(connection);
+          })
+          .catch(err => {
+            connection.destroy();
+            reject(err);
+          });
+      }
+    });
+  }
+  /**
+   * Sync VoiceState of this DMChannel.
+   * @returns {undefined}
+   */
+  sync() {
+    this.client.ws.broadcast({
+      op: Opcodes.DM_UPDATE,
+      d: {
+        channel_id: this.id,
+      },
+    });
+  }
+  /**
+   * The user in this voice-based channel
+   * @type {Collection<Snowflake, User>}
+   * @readonly
+   */
+  get voiceUsers() {
+    const coll = new Collection();
+    for (const state of this.client.voiceStates.cache.values()) {
+      if (state.channelId === this.id && state.user) {
+        coll.set(state.id, state.user);
+      }
+    }
+    return coll;
+  }
+  /**
+   * Get connection to current call
+   * @type {?VoiceConnection}
+   * @readonly
+   */
+  get voiceConnection() {
+    const check = this.client.callVoice?.joinConfig?.channelId == this.id;
+    if (check) {
+      return this.client.callVoice;
+    }
+    return null;
+  }
+  /**
+   * Get current shard
+   * @type {WebSocketShard}
+   * @readonly
+   */
+  get shard() {
+    return this.client.ws.shards.first();
+  }
+  /**
+   * The voice state adapter for this client that can be used with @discordjs/voice to play audio in DM / Group DM channels.
+   * @type {?Function}
+   * @readonly
+   */
+  get voiceAdapterCreator() {
+    return methods => {
+      this.client.voice.adapters.set(this.id, methods);
+      return {
+        sendPayload: data => {
+          if (this.shard.status !== Status.READY) return false;
+          this.shard.send(data);
+          return true;
+        },
+        destroy: () => {
+          this.client.voice.adapters.delete(this.id);
+        },
+      };
+    };
+  }
+}
+
+TextBasedChannel.applyToClass(DMChannel, true, [
+  'bulkDelete',
+  'fetchWebhooks',
+  'createWebhook',
+  'setRateLimitPerUser',
+  'setNSFW',
+]);
+
+module.exports = DMChannel;