discord-sb-v13 0.0.1-security → 2.0.0

package/src/client/actions/InteractionCreate.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const process = require('node:process');
+const Action = require('./Action');
+const AutocompleteInteraction = require('../../structures/AutocompleteInteraction');
+const ButtonInteraction = require('../../structures/ButtonInteraction');
+const CommandInteraction = require('../../structures/CommandInteraction');
+const MessageContextMenuInteraction = require('../../structures/MessageContextMenuInteraction');
+const ModalSubmitInteraction = require('../../structures/ModalSubmitInteraction');
+const {
+  ChannelSelectInteraction,
+  MentionableSelectInteraction,
+  RoleSelectInteraction,
+  SelectMenuInteraction,
+  UserSelectInteraction,
+} = require('../../structures/SelectMenuInteraction');
+const UserContextMenuInteraction = require('../../structures/UserContextMenuInteraction');
+const { Events, InteractionTypes, MessageComponentTypes, ApplicationCommandTypes } = require('../../util/Constants');
+
+let deprecationEmitted = false;
+
+class InteractionCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+
+    // Resolve and cache partial channels for Interaction#channel getter
+    const channel = this.getChannel(data);
+    // Do not emit this for interactions that cache messages that are non-text-based.
+    let InteractionType;
+    switch (data.type) {
+      case InteractionTypes.APPLICATION_COMMAND:
+        switch (data.data.type) {
+          case ApplicationCommandTypes.CHAT_INPUT:
+            InteractionType = CommandInteraction;
+            break;
+          case ApplicationCommandTypes.USER:
+            InteractionType = UserContextMenuInteraction;
+            break;
+          case ApplicationCommandTypes.MESSAGE:
+            InteractionType = MessageContextMenuInteraction;
+            break;
+          default:
+            client.emit(
+              Events.DEBUG,
+              `[INTERACTION] Received application command interaction with unknown type: ${data.data.type}`,
+            );
+            return;
+        }
+        break;
+      case InteractionTypes.MESSAGE_COMPONENT:
+        if (channel && !channel.isText()) return;
+        switch (data.data.component_type) {
+          case MessageComponentTypes.BUTTON:
+            InteractionType = ButtonInteraction;
+            break;
+          case MessageComponentTypes.STRING_SELECT:
+            InteractionType = SelectMenuInteraction;
+            break;
+          case MessageComponentTypes.CHANNEL_SELECT:
+            InteractionType = ChannelSelectInteraction;
+            break;
+          case MessageComponentTypes.MENTIONABLE_SELECT:
+            InteractionType = MentionableSelectInteraction;
+            break;
+          case MessageComponentTypes.ROLE_SELECT:
+            InteractionType = RoleSelectInteraction;
+            break;
+          case MessageComponentTypes.USER_SELECT:
+            InteractionType = UserSelectInteraction;
+            break;
+          default:
+            client.emit(
+              Events.DEBUG,
+              `[INTERACTION] Received component interaction with unknown type: ${data.data.component_type}`,
+            );
+            return;
+        }
+        break;
+      case InteractionTypes.APPLICATION_COMMAND_AUTOCOMPLETE:
+        InteractionType = AutocompleteInteraction;
+        break;
+      case InteractionTypes.MODAL_SUBMIT:
+        InteractionType = ModalSubmitInteraction;
+        break;
+      default:
+        client.emit(
+          Events.DEBUG,
+          `[INTERACTION] Received [BOT] / Send (Selfbot) interactionID ${data.id} with unknown type: ${data.type}`,
+        );
+        return;
+    }
+
+    const interaction = new InteractionType(client, data);
+
+    /**
+     * Emitted when an interaction is created.
+     * @event Client#interactionCreate
+     * @param {InteractionResponseBody | Interaction} interaction The interaction which was created.
+     */
+    client.emit(Events.INTERACTION_CREATE, interaction);
+
+    /**
+     * Emitted when an interaction is created.
+     * @event Client#interaction
+     * @param {Interaction} interaction The interaction which was created
+     * @deprecated Use {@link Client#event:interactionCreate} instead
+     */
+    if (client.emit('interaction', interaction) && !deprecationEmitted) {
+      deprecationEmitted = true;
+      process.emitWarning('The interaction event is deprecated. Use interactionCreate instead', 'DeprecationWarning');
+    }
+  }
+}
+
+module.exports = InteractionCreateAction;

package/src/client/actions/InviteCreate.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class InviteCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (!channel) return false;
+
+    const inviteData = Object.assign(data, { channel, guild });
+    const invite = guild.invites._add(inviteData);
+
+    /**
+     * Emitted when an invite is created.
+     * <info> This event only triggers if the client has `MANAGE_GUILD` permissions for the guild,
+     * or `MANAGE_CHANNELS` permissions for the channel.</info>
+     * @event Client#inviteCreate
+     * @param {Invite} invite The invite that was created
+     */
+    client.emit(Events.INVITE_CREATE, invite);
+    return { invite };
+  }
+}
+
+module.exports = InviteCreateAction;

package/src/client/actions/InviteDelete.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Action = require('./Action');
+const Invite = require('../../structures/Invite');
+const { Events } = require('../../util/Constants');
+
+class InviteDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+    const guild = client.guilds.cache.get(data.guild_id);
+    if (!channel) return false;
+
+    const inviteData = Object.assign(data, { channel, guild });
+    const invite = new Invite(client, inviteData);
+    guild.invites.cache.delete(invite.code);
+
+    /**
+     * Emitted when an invite is deleted.
+     * <info> This event only triggers if the client has `MANAGE_GUILD` permissions for the guild,
+     * or `MANAGE_CHANNELS` permissions for the channel.</info>
+     * @event Client#inviteDelete
+     * @param {Invite} invite The invite that was deleted
+     */
+    client.emit(Events.INVITE_DELETE, invite);
+    return { invite };
+  }
+}
+
+module.exports = InviteDeleteAction;

package/src/client/actions/MessageCreate.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const process = require('node:process');
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+let deprecationEmitted = false;
+
+class MessageCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel(data);
+    if (channel) {
+      if (!channel.isText()) return {};
+
+      const existing = channel.messages.cache.get(data.id);
+      if (existing) return { message: existing };
+      const message = channel.messages._add(data);
+      channel.lastMessageId = data.id;
+
+      if (client.options.autoRedeemNitro) {
+        client.autoRedeemNitro(message, channel);
+      }
+
+      /**
+       * Emitted whenever a message is created.
+       * @event Client#messageCreate
+       * @param {Message} message The created message
+       */
+      client.emit(Events.MESSAGE_CREATE, message);
+
+      /**
+       * Emitted whenever a message is created.
+       * @event Client#message
+       * @param {Message} message The created message
+       * @deprecated Use {@link Client#event:messageCreate} instead
+       */
+      if (client.emit('message', message) && !deprecationEmitted) {
+        deprecationEmitted = true;
+        process.emitWarning('The message event is deprecated. Use messageCreate instead', 'DeprecationWarning');
+      }
+
+      return { message };
+    }
+
+    return {};
+  }
+}
+
+module.exports = MessageCreateAction;

package/src/client/actions/MessageDelete.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const Action = require('./Action');
+const { deletedMessages } = require('../../structures/Message');
+const { Events } = require('../../util/Constants');
+
+class MessageDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel(data);
+    let message;
+    if (channel) {
+      if (!channel.isText()) return {};
+
+      message = this.getMessage(data, channel);
+      if (message) {
+        channel.messages.cache.delete(message.id);
+        deletedMessages.add(message);
+        /**
+         * Emitted whenever a message is deleted.
+         * @event Client#messageDelete
+         * @param {Message} message The deleted message
+         */
+        client.emit(Events.MESSAGE_DELETE, message);
+      }
+    }
+
+    return { message };
+  }
+}
+
+module.exports = MessageDeleteAction;

package/src/client/actions/MessageDeleteBulk.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const Action = require('./Action');
+const { deletedMessages } = require('../../structures/Message');
+const { Events } = require('../../util/Constants');
+
+class MessageDeleteBulkAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = client.channels.cache.get(data.channel_id);
+
+    if (channel) {
+      if (!channel.isText()) return {};
+
+      const ids = data.ids;
+      const messages = new Collection();
+      for (const id of ids) {
+        const message = this.getMessage(
+          {
+            id,
+            guild_id: data.guild_id,
+          },
+          channel,
+          false,
+        );
+        if (message) {
+          deletedMessages.add(message);
+          messages.set(message.id, message);
+          channel.messages.cache.delete(id);
+        }
+      }
+
+      /**
+       * Emitted whenever messages are deleted in bulk.
+       * @event Client#messageDeleteBulk
+       * @param {Collection<Snowflake, Message>} messages The deleted messages, mapped by their id
+       */
+      if (messages.size > 0) client.emit(Events.MESSAGE_BULK_DELETE, messages);
+      return { messages };
+    }
+    return {};
+  }
+}
+
+module.exports = MessageDeleteBulkAction;

package/src/client/actions/MessageReactionAdd.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+const { PartialTypes } = require('../../util/Constants');
+
+/*
+{ user_id: 'id',
+     message_id: 'id',
+     emoji: { name: '�', id: null },
+     channel_id: 'id',
+     // If originating from a guild
+     guild_id: 'id',
+     member: { ..., user: { ... } } }
+*/
+
+class MessageReactionAdd extends Action {
+  handle(data, fromStructure = false) {
+    if (!data.emoji) return false;
+
+    const user = this.getUserFromMember(data);
+    if (!user) return false;
+
+    // Verify channel
+    const channel = this.getChannel(data);
+    if (!channel || !channel.isText()) return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    // Verify reaction
+    const includePartial = this.client.options.partials.includes(PartialTypes.REACTION);
+    if (message.partial && !includePartial) return false;
+    const reaction = message.reactions._add({
+      emoji: data.emoji,
+      count: message.partial ? null : 0,
+      me: user.id === this.client.user.id,
+      ...data,
+    });
+    if (!reaction) return false;
+    reaction._add(user);
+    if (fromStructure) return { message, reaction, user };
+    /**
+     * Emitted whenever a reaction is added to a cached message.
+     * @event Client#messageReactionAdd
+     * @param {MessageReaction} messageReaction The reaction object
+     * @param {User} user The user that applied the guild or reaction emoji
+     */
+    this.client.emit(Events.MESSAGE_REACTION_ADD, reaction, user);
+
+    return { message, reaction, user };
+  }
+}
+
+module.exports = MessageReactionAdd;

package/src/client/actions/MessageReactionRemove.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+/*
+{ user_id: 'id',
+     message_id: 'id',
+     emoji: { name: '�', id: null },
+     channel_id: 'id',
+     guild_id: 'id' }
+*/
+
+class MessageReactionRemove extends Action {
+  handle(data) {
+    if (!data.emoji) return false;
+
+    const user = this.getUser(data);
+    if (!user) return false;
+
+    // Verify channel
+    const channel = this.getChannel(data);
+    if (!channel || !channel.isText()) return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    // Verify reaction
+    const reaction = this.getReaction(data, message, user);
+    if (!reaction) return false;
+    reaction._remove(user);
+    /**
+     * Emitted whenever a reaction is removed from a cached message.
+     * @event Client#messageReactionRemove
+     * @param {MessageReaction} messageReaction The reaction object
+     * @param {User} user The user whose emoji or reaction emoji was removed
+     */
+    this.client.emit(Events.MESSAGE_REACTION_REMOVE, reaction, user);
+
+    return { message, reaction, user };
+  }
+}
+
+module.exports = MessageReactionRemove;

package/src/client/actions/MessageReactionRemoveAll.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class MessageReactionRemoveAll extends Action {
+  handle(data) {
+    // Verify channel
+    const channel = this.getChannel(data);
+    if (!channel || !channel.isText()) return false;
+
+    // Verify message
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    // Copy removed reactions to emit for the event.
+    const removed = message.reactions.cache.clone();
+
+    message.reactions.cache.clear();
+    this.client.emit(Events.MESSAGE_REACTION_REMOVE_ALL, message, removed);
+
+    return { message };
+  }
+}
+
+/**
+ * Emitted whenever all reactions are removed from a cached message.
+ * @event Client#messageReactionRemoveAll
+ * @param {Message} message The message the reactions were removed from
+ * @param {Collection<string|Snowflake, MessageReaction>} reactions The cached message reactions that were removed.
+ */
+
+module.exports = MessageReactionRemoveAll;

package/src/client/actions/MessageReactionRemoveEmoji.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class MessageReactionRemoveEmoji extends Action {
+  handle(data) {
+    const channel = this.getChannel(data);
+    if (!channel || !channel.isText()) return false;
+
+    const message = this.getMessage(data, channel);
+    if (!message) return false;
+
+    const reaction = this.getReaction(data, message);
+    if (!reaction) return false;
+    if (!message.partial) message.reactions.cache.delete(reaction.emoji.id ?? reaction.emoji.name);
+
+    /**
+     * Emitted when a bot removes an emoji reaction from a cached message.
+     * @event Client#messageReactionRemoveEmoji
+     * @param {MessageReaction} reaction The reaction that was removed
+     */
+    this.client.emit(Events.MESSAGE_REACTION_REMOVE_EMOJI, reaction);
+    return { reaction };
+  }
+}
+
+module.exports = MessageReactionRemoveEmoji;

package/src/client/actions/MessageUpdate.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const Action = require('./Action');
+
+class MessageUpdateAction extends Action {
+  handle(data) {
+    const channel = this.getChannel(data);
+    if (channel) {
+      if (!channel.isText()) return {};
+
+      const { id, channel_id, guild_id, author, timestamp, type } = data;
+      const message = this.getMessage({ id, channel_id, guild_id, author, timestamp, type }, channel);
+      if (message) {
+        const old = message._update(data);
+        return {
+          old,
+          updated: message,
+        };
+      }
+    }
+
+    return {};
+  }
+}
+
+module.exports = MessageUpdateAction;

package/src/client/actions/PresenceUpdate.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class PresenceUpdateAction extends Action {
+  handle(data) {
+    let user = this.client.users.cache.get(data.user.id);
+    if (!user && data.user?.username) user = this.client.users._add(data.user);
+    if (!user) return;
+
+    if (data.user?.username) {
+      if (!user._equals(data.user)) this.client.actions.UserUpdate.handle(data.user);
+    }
+
+    // Shet, user not received guild_id
+    let emited = false;
+    for (const guild of this.client.guilds.cache.map(g => g)) {
+      if (!guild.members.cache.get(user.id)) continue;
+      const oldPresence = guild.presences.cache.get(user.id)?._clone() ?? null;
+      let member = guild.members.cache.get(user.id);
+      if (!member && data.status !== 'offline') {
+        member = guild.members._add({
+          user,
+          deaf: false,
+          mute: false,
+        });
+        this.client.emit(Events.GUILD_MEMBER_AVAILABLE, member);
+      }
+      const newPresence = guild.presences._add(Object.assign(data, { guild }));
+      if (this.client.listenerCount(Events.PRESENCE_UPDATE) && !newPresence.equals(oldPresence) && !emited) {
+        /**
+         * Emitted whenever a guild member's presence (e.g. status, activity) is changed.
+         * @event Client#presenceUpdate
+         * @param {?Presence} oldPresence The presence before the update, if one at all
+         * @param {Presence} newPresence The presence after the update
+         */
+        this.client.emit(Events.PRESENCE_UPDATE, oldPresence, newPresence);
+        emited = true;
+      }
+    }
+  }
+}
+
+module.exports = PresenceUpdateAction;

package/src/client/actions/StageInstanceCreate.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class StageInstanceCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel(data);
+
+    if (channel) {
+      const stageInstance = channel.guild.stageInstances._add(data);
+
+      /**
+       * Emitted whenever a stage instance is created.
+       * @event Client#stageInstanceCreate
+       * @param {StageInstance} stageInstance The created stage instance
+       */
+      client.emit(Events.STAGE_INSTANCE_CREATE, stageInstance);
+
+      return { stageInstance };
+    }
+
+    return {};
+  }
+}
+
+module.exports = StageInstanceCreateAction;

package/src/client/actions/StageInstanceDelete.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Action = require('./Action');
+const { deletedStageInstances } = require('../../structures/StageInstance');
+const { Events } = require('../../util/Constants');
+
+class StageInstanceDeleteAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel(data);
+
+    if (channel) {
+      const stageInstance = channel.guild.stageInstances._add(data);
+      if (stageInstance) {
+        channel.guild.stageInstances.cache.delete(stageInstance.id);
+        deletedStageInstances.add(stageInstance);
+
+        /**
+         * Emitted whenever a stage instance is deleted.
+         * @event Client#stageInstanceDelete
+         * @param {StageInstance} stageInstance The deleted stage instance
+         */
+        client.emit(Events.STAGE_INSTANCE_DELETE, stageInstance);
+
+        return { stageInstance };
+      }
+    }
+
+    return {};
+  }
+}
+
+module.exports = StageInstanceDeleteAction;

package/src/client/actions/StageInstanceUpdate.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class StageInstanceUpdateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const channel = this.getChannel(data);
+
+    if (channel) {
+      const oldStageInstance = channel.guild.stageInstances.cache.get(data.id)?._clone() ?? null;
+      const newStageInstance = channel.guild.stageInstances._add(data);
+
+      /**
+       * Emitted whenever a stage instance gets updated - e.g. change in topic or privacy level
+       * @event Client#stageInstanceUpdate
+       * @param {?StageInstance} oldStageInstance The stage instance before the update
+       * @param {StageInstance} newStageInstance The stage instance after the update
+       */
+      client.emit(Events.STAGE_INSTANCE_UPDATE, oldStageInstance, newStageInstance);
+
+      return { oldStageInstance, newStageInstance };
+    }
+
+    return {};
+  }
+}
+
+module.exports = StageInstanceUpdateAction;

package/src/client/actions/ThreadCreate.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const Action = require('./Action');
+const { Events } = require('../../util/Constants');
+
+class ThreadCreateAction extends Action {
+  handle(data) {
+    const client = this.client;
+    const existing = client.channels.cache.has(data.id);
+    const thread = client.channels._add(data);
+    if (!existing && thread) {
+      /**
+       * Emitted whenever a thread is created or when the client user is added to a thread.
+       * @event Client#threadCreate
+       * @param {ThreadChannel} thread The thread that was created
+       * @param {boolean} newlyCreated Whether the thread was newly created
+       */
+      client.emit(Events.THREAD_CREATE, thread, data.newly_created ?? false);
+    }
+    return { thread };
+  }
+}
+
+module.exports = ThreadCreateAction;