djs-selfbot-v13 3.1.5 → 3.1.7

package/src/managers/GuildBanManager.js

@@ -130,7 +130,7 @@ class GuildBanManager extends CachedManager {
    * @typedef {Object} BanOptions
    * @property {number} [days=0] Number of days of messages to delete, must be between 0 and 7, inclusive
    * <warn>This property is deprecated. Use `deleteMessageSeconds` instead.</warn>
-   * @property {number} [deleteMessageSeconds] Number of seconds of messages to delete,
+   * @property {number} [deleteMessageSeconds=0] Number of seconds of messages to delete,
    * must be between 0 and 604800 (7 days), inclusive
    * @property {string} [reason] The reason for the ban
    */

package/src/managers/GuildChannelManager.js

@@ -150,7 +150,6 @@ class GuildChannelManager extends CachedManager {
       defaultReactionEmoji,
       defaultSortOrder,
       defaultForumLayout,
-      defaultThreadRateLimitPerUser,
       reason,
     } = {},
   ) {
@@ -192,7 +191,6 @@ class GuildChannelManager extends CachedManager {
         default_reaction_emoji: defaultReactionEmoji && transformGuildDefaultReaction(defaultReactionEmoji),
         default_sort_order: sortMode,
         default_forum_layout: layoutMode,
-        default_thread_rate_limit_per_user: defaultThreadRateLimitPerUser,
       },
       reason,
     });

package/src/managers/GuildFolderManager.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const BaseManager = require('./BaseManager');
+
+/**
+ * Manages API methods for users and stores their cache.
+ * @extends {BaseManager}
+ */
+class GuildFolderManager extends BaseManager {
+  constructor(client) {
+    super(client);
+    /**
+     * The guild folder cache (Index, GuildFolder)
+     * @type {Collection<number, GuildFolder>}
+     */
+    this.cache = new Collection();
+  }
+  _refresh() {
+    this.cache.clear();
+  }
+}
+
+module.exports = GuildFolderManager;

package/src/managers/GuildForumThreadManager.js

@@ -3,7 +3,7 @@
 const ThreadManager = require('./ThreadManager');
 const { TypeError } = require('../errors');
 const MessagePayload = require('../structures/MessagePayload');
-const { resolveAutoArchiveMaxLimit, getUploadURL, uploadFile } = require('../util/Util');
+const { resolveAutoArchiveMaxLimit, getAttachments, uploadFile } = require('../util/Util');
 
 /**
  * Manages API methods for threads in forum channels and stores their cache.
@@ -20,7 +20,7 @@ class GuildForumThreadManager extends ThreadManager {
    * @typedef {BaseMessageOptions} GuildForumThreadMessageCreateOptions
    * @property {StickerResolvable} [stickers] The stickers to send with the message
    * @property {BitFieldResolvable} [flags] The flags to send with the message.
-   * Only `SUPPRESS_EMBEDS` and `SUPPRESS_NOTIFICATIONS` can be set.
+   * Only `SUPPRESS_EMBEDS`, `SUPPRESS_NOTIFICATIONS` and `IS_VOICE_MESSAGE` can be set.
    */
 
   /**
@@ -63,29 +63,35 @@ class GuildForumThreadManager extends ThreadManager {
     let messagePayload;
 
     if (message instanceof MessagePayload) {
-      messagePayload = message.resolveData();
+      messagePayload = await message.resolveData();
     } else {
-      messagePayload = MessagePayload.create(this, message).resolveData();
+      messagePayload = await MessagePayload.create(this, message).resolveData();
     }
 
-    const { data: body, files } = await messagePayload.resolveFiles();
+    let { data: body, files } = await messagePayload.resolveFiles();
 
-    // New API
-    const attachments = await getUploadURL(this.client, this.channel.id, files);
-    const requestPromises = attachments.map(async attachment => {
-      await uploadFile(files[attachment.id].file, attachment.upload_url);
-      return {
-        id: attachment.id,
-        filename: files[attachment.id].name,
-        uploaded_filename: attachment.upload_filename,
-        description: files[attachment.id].description,
-        duration_secs: files[attachment.id].duration_secs,
-        waveform: files[attachment.id].waveform,
-      };
-    });
-    const attachmentsData = await Promise.all(requestPromises);
-    attachmentsData.sort((a, b) => parseInt(a.id) - parseInt(b.id));
-    data.attachments = attachmentsData;
+    if (typeof message == 'object' && typeof message.usingNewAttachmentAPI !== 'boolean') {
+      message.usingNewAttachmentAPI = this.client.options.usingNewAttachmentAPI;
+    }
+
+    if (message?.usingNewAttachmentAPI === true) {
+      const attachments = await getAttachments(this.client, this.channel.id, ...files);
+      const requestPromises = attachments.map(async attachment => {
+        await uploadFile(files[attachment.id].file, attachment.upload_url);
+        return {
+          id: attachment.id,
+          filename: files[attachment.id].name,
+          uploaded_filename: attachment.upload_filename,
+          description: files[attachment.id].description,
+          duration_secs: files[attachment.id].duration_secs,
+          waveform: files[attachment.id].waveform,
+        };
+      });
+      const attachmentsData = await Promise.all(requestPromises);
+      attachmentsData.sort((a, b) => parseInt(a.id) - parseInt(b.id));
+      body.attachments = attachmentsData;
+      files = [];
+    }
 
     if (autoArchiveDuration === 'MAX') autoArchiveDuration = resolveAutoArchiveMaxLimit(this.channel.guild);
 
@@ -97,7 +103,7 @@ class GuildForumThreadManager extends ThreadManager {
         applied_tags: appliedTags,
         message: body,
       },
-      files: [],
+      files,
       reason,
     });
 

package/src/managers/GuildMemberManager.js

@@ -1,9 +1,10 @@
-/* eslint-disable newline-per-chained-call */
 'use strict';
 
 const { Buffer } = require('node:buffer');
 const { setTimeout } = require('node:timers');
 const { Collection } = require('@discordjs/collection');
+require('lodash.permutations');
+const _ = require('lodash');
 const CachedManager = require('./CachedManager');
 const { Error, TypeError, RangeError } = require('../errors');
 const BaseGuildVoiceChannel = require('../structures/BaseGuildVoiceChannel');
@@ -190,17 +191,26 @@ class GuildMemberManager extends CachedManager {
    * guild.members.fetch({ query: 'hydra', limit: 1 })
    *   .then(console.log)
    *   .catch(console.error);
+   * @see {@link https://github.com/aiko-chan-ai/discord.js-selfbot-v13/blob/main/Document/FetchGuildMember.md}
    */
   fetch(options) {
-    if (!options) {
+    if (!options || (typeof options === 'object' && !('user' in options) && !('query' in options))) {
       if (
-        this.me.permissions.has('KICK_MEMBERS') ||
-        this.me.permissions.has('BAN_MEMBERS') ||
-        this.me.permissions.has('MANAGE_ROLES')
+        this.guild.members.me.permissions.has('KICK_MEMBERS') ||
+        this.guild.members.me.permissions.has('BAN_MEMBERS') ||
+        this.guild.members.me.permissions.has('MANAGE_ROLES')
       ) {
         return this._fetchMany();
       } else {
         return this.fetchByMemberSafety();
+        /*
+        NOTE: This is a very slow method, and can take up to 999+ minutes to complete.
+        this.fetchBruteforce({
+          delay: 50,
+          skipWarn: true,
+          depth: 1,
+        });
+        */
       }
     }
     const user = this.client.users.resolveId(options);
@@ -463,60 +473,92 @@ class GuildMemberManager extends CachedManager {
   }
 
   /**
-   * Adds a role to a member.
-   * @param {GuildMemberResolvable} user The user to add the role from
-   * @param {RoleResolvable} role The role to add
-   * @param {string} [reason] Reason for adding the role
-   * @returns {Promise<GuildMember|User|Snowflake>}
+   * Options used to fetch multiple members from a guild.
+   * @typedef {Object} BruteforceOptions
+   * @property {number} [limit=100] Maximum number of members per request
+   * @property {number} [delay=500] Timeout for new requests in ms
+   * @property {number} [depth=1] Permutations length
    */
-  async addRole(user, role, reason) {
-    const userId = this.guild.members.resolveId(user);
-    const roleId = this.guild.roles.resolveId(role);
-
-    await this.client.api.guilds(this.guild.id).members(userId).roles(roleId).put({ reason });
-
-    return this.resolve(user) ?? this.client.users.resolve(user) ?? userId;
-  }
 
   /**
-   * Removes a role from a member.
-   * @param {UserResolvable} user The user to remove the role from
-   * @param {RoleResolvable} role The role to remove
-   * @param {string} [reason] Reason for removing the role
-   * @returns {Promise<GuildMember|User|Snowflake>}
+   * Fetches multiple members from the guild.
+   * @param {BruteforceOptions} options Options for the bruteforce
+   * @returns {Collection<Snowflake, GuildMember>} (All) members in the guild
+   * @see https://github.com/aiko-chan-ai/discord.js-selfbot-v13/blob/main/Document/FetchGuildMember.md
+   * @example
+   * guild.members.fetchBruteforce()
+   * .then(members => console.log(`Fetched ${members.size} members`))
+   * .catch(console.error);
    */
-  async removeRole(user, role, reason) {
-    const userId = this.guild.members.resolveId(user);
-    const roleId = this.guild.roles.resolveId(role);
-
-    await this.client.api.guilds(this.guild.id).members(userId).roles(roleId).delete({ reason });
-
-    return this.resolve(user) ?? this.client.users.resolve(user) ?? userId;
+  fetchBruteforce(options = {}) {
+    const defaultQuery = 'abcdefghijklmnopqrstuvwxyz0123456789!"#$%&\'()*+,-./:;<=>?@[]^_`{|}~ ';
+    let dictionary;
+    let limit = 100;
+    let delay = 500;
+    let depth = 1;
+    if (options?.limit) limit = options?.limit;
+    if (options?.delay) delay = options?.delay;
+    if (options?.depth) depth = options?.depth;
+    if (typeof limit !== 'number') throw new TypeError('INVALID_TYPE', 'limit', 'Number');
+    if (limit < 1 || limit > 100) throw new RangeError('INVALID_RANGE_QUERY_MEMBER');
+    if (typeof delay !== 'number') throw new TypeError('INVALID_TYPE', 'delay', 'Number');
+    if (typeof depth !== 'number') throw new TypeError('INVALID_TYPE', 'depth', 'Number');
+    if (depth < 1) throw new RangeError('INVALID_RANGE_QUERY_MEMBER');
+    if (depth > 2) {
+      console.warn(`[WARNING] GuildMemberManager#fetchBruteforce: depth greater than 2, can lead to very slow speeds`);
+    }
+    if (delay < 500 && !options?.skipWarn) {
+      console.warn(
+        `[WARNING] GuildMemberManager#fetchBruteforce: delay is less than 500ms, this may cause rate limits.`,
+      );
+    }
+    let skipValues = [];
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve, reject) => {
+      for (let i = 1; i <= depth; i++) {
+        dictionary = _(defaultQuery)
+          .permutations(i)
+          .map(v => _.join(v, ''))
+          .value();
+        for (const query of dictionary) {
+          if (this.guild.members.cache.size >= this.guild.memberCount) break;
+          this.client.emit(
+            'debug',
+            `[INFO] GuildMemberManager#fetchBruteforce: Querying ${query}, Skip: [${skipValues.join(', ')}]`,
+          );
+          if (skipValues.some(v => query.startsWith(v))) continue;
+          await this._fetchMany({ query, limit })
+            .then(members => {
+              if (members.size === 0) skipValues.push(query);
+            })
+            .catch(reject);
+          await this.guild.client.sleep(delay);
+        }
+      }
+      resolve(this.guild.members.cache);
+    });
   }
 
   /**
-   * Experimental method to fetch members from the guild.
-   * <info>Lists up to 10000 members of the guild.</info>
-   * @param {number} [timeout=15_000] Timeout for receipt of members in ms
+   * Experimental method to fetch all members from the guild.
+   * @param {number} [timeout=120000] Timeout for receipt of members in ms
    * @returns {Promise<Collection<Snowflake, GuildMember>>}
    */
-  fetchByMemberSafety(timeout = 15_000) {
+  fetchByMemberSafety(timeout = 120_000) {
     return new Promise(resolve => {
-      const nonce = SnowflakeUtil.generate();
       let timeout_ = setTimeout(() => {
         this.client.removeListener(Events.GUILD_MEMBER_LIST_UPDATE, handler);
         resolve(this.guild.members.cache);
       }, timeout).unref();
       const handler = (members, guild, raw) => {
-        if (guild.id == this.guild.id && raw.nonce == nonce) {
+        if (guild.id == this.guild.id && !raw.nonce && raw.index == 0 && raw.count == 1) {
           if (members.size > 0) {
             this.client.ws.broadcast({
-              op: Opcodes.SEARCH_RECENT_MEMBERS,
+              op: 35,
               d: {
                 guild_id: this.guild.id,
                 query: '',
                 continuation_token: members.first()?.id,
-                nonce,
               },
             });
           } else {
@@ -528,17 +570,151 @@ class GuildMemberManager extends CachedManager {
       };
       this.client.on('guildMembersChunk', handler);
       this.client.ws.broadcast({
-        op: Opcodes.SEARCH_RECENT_MEMBERS,
+        op: 35,
         d: {
           guild_id: this.guild.id,
           query: '',
           continuation_token: null,
-          nonce,
         },
       });
     });
   }
 
+  /**
+   * Fetches multiple members from the guild in the channel.
+   * @param {GuildTextChannelResolvable} channel The channel to get members from (Members has VIEW_CHANNEL permission)
+   * @param {number} [offset=0] Start index of the members to get
+   * @param {boolean} [double=false] Whether to use double range
+   * @param {number} [retryMax=3] Number of retries
+   * @param {number} [time=10e3] Timeout for receipt of members
+   * @returns {Collection<Snowflake, GuildMember>} Members in the guild
+   * @see {@link https://github.com/aiko-chan-ai/discord.js-selfbot-v13/blob/main/Document/FetchGuildMember.md}
+   * @example
+   * const guild = client.guilds.cache.get('id');
+   * const channel = guild.channels.cache.get('id');
+   * // Overlap (slow)
+   * for (let index = 0; index <= guild.memberCount; index += 100) {
+   *   await guild.members.fetchMemberList(channel, index, index !== 100).catch(() => {});
+   *   await client.sleep(500);
+   * }
+   * // Non-overlap (fast)
+   * for (let index = 0; index <= guild.memberCount; index += 200) {
+   *   await guild.members.fetchMemberList(channel, index == 0 ? 100 : index, index !== 100).catch(() => {});
+   *   await client.sleep(500);
+   * }
+   * console.log(guild.members.cache.size); // will print the number of members in the guild
+   */
+  fetchMemberList(channel, offset = 0, double = false, retryMax = 3, time = 10_000) {
+    const channel_ = this.guild.channels.resolve(channel);
+    if (!channel_?.isText()) throw new TypeError('INVALID_TYPE', 'channel', 'GuildTextChannelResolvable');
+    if (typeof offset !== 'number') throw new TypeError('INVALID_TYPE', 'offset', 'Number');
+    if (typeof time !== 'number') throw new TypeError('INVALID_TYPE', 'time', 'Number');
+    if (typeof retryMax !== 'number') throw new TypeError('INVALID_TYPE', 'retryMax', 'Number');
+    if (retryMax < 1) throw new RangeError('INVALID_RANGE_RETRY');
+    if (typeof double !== 'boolean') throw new TypeError('INVALID_TYPE', 'double', 'Boolean');
+    // TODO: if (this.guild.large) throw new Error('GUILD_IS_LARGE');
+    return new Promise((resolve, reject) => {
+      const default_ = [[0, 99]];
+      const fetchedMembers = new Collection();
+      if (offset > 99) {
+        // eslint-disable-next-line no-unused-expressions
+        double
+          ? default_.push([offset, offset + 99], [offset + 100, offset + 199])
+          : default_.push([offset, offset + 99]);
+      }
+      let retry = 0;
+      const handler = (members, guild, type, raw) => {
+        timeout.refresh();
+        if (guild.id !== this.guild.id) return;
+        if (type == 'INVALIDATE' && offset > 100) {
+          if (retry < retryMax) {
+            this.guild.shard.send({
+              op: Opcodes.GUILD_SUBSCRIPTIONS,
+              d: {
+                guild_id: this.guild.id,
+                typing: true,
+                threads: true,
+                activities: true,
+                channels: {
+                  [channel_.id]: default_,
+                },
+                thread_member_lists: [],
+                members: [],
+              },
+            });
+            retry++;
+          } else {
+            clearTimeout(timeout);
+            this.client.removeListener(Events.GUILD_MEMBER_LIST_UPDATE, handler);
+            this.client.decrementMaxListeners();
+            reject(new Error('INVALIDATE_MEMBER', raw.ops[0].range));
+          }
+        } else {
+          for (const member of members.values()) {
+            fetchedMembers.set(member.id, member);
+          }
+          clearTimeout(timeout);
+          this.client.removeListener(Events.GUILD_MEMBER_LIST_UPDATE, handler);
+          this.client.decrementMaxListeners();
+          resolve(fetchedMembers);
+        }
+      };
+      const timeout = setTimeout(() => {
+        this.client.removeListener(Events.GUILD_MEMBER_LIST_UPDATE, handler);
+        this.client.decrementMaxListeners();
+        reject(new Error('GUILD_MEMBERS_TIMEOUT'));
+      }, time).unref();
+      this.client.incrementMaxListeners();
+      this.client.on(Events.GUILD_MEMBER_LIST_UPDATE, handler);
+      this.guild.shard.send({
+        op: Opcodes.GUILD_SUBSCRIPTIONS,
+        d: {
+          guild_id: this.guild.id,
+          typing: true,
+          threads: true,
+          activities: true,
+          channels: {
+            [channel_.id]: default_,
+          },
+          thread_member_lists: [],
+          members: [],
+        },
+      });
+    });
+  }
+
+  /**
+   * Adds a role to a member.
+   * @param {GuildMemberResolvable} user The user to add the role from
+   * @param {RoleResolvable} role The role to add
+   * @param {string} [reason] Reason for adding the role
+   * @returns {Promise<GuildMember|User|Snowflake>}
+   */
+  async addRole(user, role, reason) {
+    const userId = this.guild.members.resolveId(user);
+    const roleId = this.guild.roles.resolveId(role);
+
+    await this.client.api.guilds(this.guild.id).members(userId).roles(roleId).put({ reason });
+
+    return this.resolve(user) ?? this.client.users.resolve(user) ?? userId;
+  }
+
+  /**
+   * Removes a role from a member.
+   * @param {UserResolvable} user The user to remove the role from
+   * @param {RoleResolvable} role The role to remove
+   * @param {string} [reason] Reason for removing the role
+   * @returns {Promise<GuildMember|User|Snowflake>}
+   */
+  async removeRole(user, role, reason) {
+    const userId = this.guild.members.resolveId(user);
+    const roleId = this.guild.roles.resolveId(role);
+
+    await this.client.api.guilds(this.guild.id).members(userId).roles(roleId).delete({ reason });
+
+    return this.resolve(user) ?? this.client.users.resolve(user) ?? userId;
+  }
+
   _fetchMany({
     limit = 0,
     withPresences: presences = true,

package/src/managers/GuildSettingManager.js

@@ -7,24 +7,19 @@ const BaseManager = require('./BaseManager');
  * @see {@link https://luna.gitlab.io/discord-unofficial-docs/user_settings.html}
  */
 class GuildSettingManager extends BaseManager {
-  #rawSetting = {};
-  constructor(guild) {
-    super(guild.client);
+  constructor(client, guildId = null) {
+    super(client);
+    /**
+     * Raw data
+     * @type {Object}
+     */
+    this.rawSetting = {};
     /**
      * Guild Id
      * @type {?Snowflake}
      */
-    this.guildId = guild.id;
-  }
-
-  /**
-   * Raw data
-   * @type {Object}
-   */
-  get raw() {
-    return this.#rawSetting;
+    this.guildId = guildId;
   }
-
   /**
    * Get the guild
    * @type {?Guild}
@@ -33,15 +28,13 @@ class GuildSettingManager extends BaseManager {
   get guild() {
     return this.client.guilds.cache.get(this.guildId);
   }
-
   /**
    * Patch data file
    * @private
    * @param {Object} data Raw Data to patch
    */
   _patch(data = {}) {
-    this.#rawSetting = Object.assign(this.#rawSetting, data);
-    this.client.emit('debug', `[SETTING > Guild ${this.guildId}] Sync setting`);
+    this.rawSetting = Object.assign(this.rawSetting, data);
     if ('suppress_everyone' in data) {
       /**
        * Notification setting > Suppress `@everyone` and `@here`
@@ -66,9 +59,9 @@ class GuildSettingManager extends BaseManager {
     if ('message_notifications' in data) {
       /**
        * Notification setting > Message notifications
-       * * `0`: All messages
-       * * `1`: Only @mentions
-       * * `2`: Nothing
+       * * `0` = All messages
+       * * `1` = Only @mentions
+       * * `2` = Nothing
        * @type {?number}
        */
       this.messageNotifications = data.message_notifications;
@@ -125,9 +118,9 @@ class GuildSettingManager extends BaseManager {
     if ('notify_highlights' in data) {
       /**
        * Notification setting > Suppress highlights
-       * * `0`: ??? (unknown)
-       * * `1`: Enable
-       * * `2`: Disable
+       * * `0` = ??? (unknown)
+       * * `1` = Enable
+       * * `2` = Disable
        * @type {?number}
        */
       this.notifyHighlights = data.notify_highlights;

package/src/managers/MessageManager.js

@@ -2,7 +2,7 @@
 
 const { Collection } = require('@discordjs/collection');
 const CachedManager = require('./CachedManager');
-const { TypeError } = require('../errors');
+const { TypeError, Error } = require('../errors');
 const { Message } = require('../structures/Message');
 const MessagePayload = require('../structures/MessagePayload');
 const Util = require('../util/Util');
@@ -123,32 +123,38 @@ class MessageManager extends CachedManager {
     const messageId = this.resolveId(message);
     if (!messageId) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
 
-    const { data, files } = await (options instanceof MessagePayload
-      ? options
-      : MessagePayload.create(message instanceof Message ? message : this, options)
-    )
-      .resolveData()
-      .resolveFiles();
-
-    // New API
-    const attachments = await Util.getUploadURL(this.client, this.channel.id, files);
-    const requestPromises = attachments.map(async attachment => {
-      await Util.uploadFile(files[attachment.id].file, attachment.upload_url);
-      return {
-        id: attachment.id,
-        filename: files[attachment.id].name,
-        uploaded_filename: attachment.upload_filename,
-        description: files[attachment.id].description,
-        duration_secs: files[attachment.id].duration_secs,
-        waveform: files[attachment.id].waveform,
-      };
-    });
-    const attachmentsData = await Promise.all(requestPromises);
-    attachmentsData.sort((a, b) => parseInt(a.id) - parseInt(b.id));
-    data.attachments = attachmentsData;
-    // Empty Files
+    let messagePayload;
+    if (options instanceof MessagePayload) {
+      messagePayload = await options.resolveData();
+    } else {
+      messagePayload = await MessagePayload.create(message instanceof Message ? message : this, options).resolveData();
+    }
+    let { data, files } = await messagePayload.resolveFiles();
+
+    if (typeof options == 'object' && typeof options.usingNewAttachmentAPI !== 'boolean') {
+      options.usingNewAttachmentAPI = this.client.options.usingNewAttachmentAPI;
+    }
 
-    const d = await this.client.api.channels[this.channel.id].messages[messageId].patch({ data });
+    if (options?.usingNewAttachmentAPI === true) {
+      const attachments = await Util.getAttachments(this.client, this.channel.id, ...files);
+      const requestPromises = attachments.map(async attachment => {
+        await Util.uploadFile(files[attachment.id].file, attachment.upload_url);
+        return {
+          id: attachment.id,
+          filename: files[attachment.id].name,
+          uploaded_filename: attachment.upload_filename,
+          description: files[attachment.id].description,
+          duration_secs: files[attachment.id].duration_secs,
+          waveform: files[attachment.id].waveform,
+        };
+      });
+      const attachmentsData = await Promise.all(requestPromises);
+      attachmentsData.sort((a, b) => parseInt(a.id) - parseInt(b.id));
+      data.attachments = attachmentsData;
+      files = [];
+    }
+
+    const d = await this.client.api.channels[this.channel.id].messages[messageId].patch({ data, files });
 
     const existing = this.cache.get(messageId);
     if (existing) {
@@ -245,16 +251,12 @@ class MessageManager extends CachedManager {
       const existing = this.cache.get(messageId);
       if (existing && !existing.partial) return existing;
     }
-
     // https://discord.com/api/v9/channels/:id/messages?limit=50&around=:msgid
     return new Promise((resolve, reject) => {
-      this._fetchMany(
-        {
-          around: messageId,
-          limit: 50,
-        },
-        cache,
-      )
+      this._fetchMany({
+        around: messageId,
+        limit: 50,
+      })
         .then(data_ =>
           data_.has(messageId) ? resolve(data_.get(messageId)) : reject(new Error('MESSAGE_ID_NOT_FOUND')),
         )
@@ -262,6 +264,13 @@ class MessageManager extends CachedManager {
     });
   }
 
+  async _fetchMany(options = {}, cache) {
+    const data = await this.client.api.channels[this.channel.id].messages.get({ query: options });
+    const messages = new Collection();
+    for (const message of data) messages.set(message.id, this._add(message, cache));
+    return messages;
+  }
+
   /**
    * @typedef {object} MessageSearchOptions
    * @property {Array<UserResolvable>} [authors] An array of author to filter by
@@ -372,20 +381,13 @@ class MessageManager extends CachedManager {
       stringQuery = stringQuery.filter(v => !v.startsWith('channel_id') && !v.startsWith('include_nsfw'));
       data = await this.client.api.channels[this.channel.id].messages[`search?${stringQuery.join('&')}`].get();
     }
-
+    console.log(stringQuery);
     for await (const message of data.messages) result.set(message[0].id, new Message(this.client, message[0]));
     return {
       messages: result,
       total: data.total_results,
     };
   }
-
-  async _fetchMany(options = {}, cache) {
-    const data = await this.client.api.channels[this.channel.id].messages.get({ query: options });
-    const messages = new Collection();
-    for (const message of data) messages.set(message.id, this._add(message, cache));
-    return messages;
-  }
 }
 
 module.exports = MessageManager;

package/src/managers/PermissionOverwriteManager.js

@@ -89,7 +89,7 @@ class PermissionOverwriteManager extends CachedManager {
    * @private
    */
   async upsert(userOrRole, options, overwriteOptions = {}, existing) {
-    let userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
+    const userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
     let { type, reason } = overwriteOptions;
     if (typeof type !== 'number') {
       userOrRole = this.channel.guild.roles.resolve(userOrRole) ?? this.client.users.resolve(userOrRole);