@ovencord/discord.js 14.16.3

package/src/managers/MessageManager.ts

@@ -0,0 +1,352 @@
+import { Collection  } from '@ovencord/collection';
+import { makeURLSearchParams  } from '@ovencord/rest';
+import { isFileBodyEncodable, isJSONEncodable  } from '@ovencord/util';
+import { Routes  } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+import { Message  } from '../structures/Message.js';
+import { MessagePayload  } from '../structures/MessagePayload.js';
+import { MakeCacheOverrideSymbol  } from '../util/Symbols.js';
+import { resolvePartialEmoji  } from '../util/Util.js';
+import { CachedManager  } from './CachedManager.js';
+
+/**
+ * Manages API methods for Messages and holds their cache.
+ *
+ * @extends {CachedManager}
+ * @abstract
+ */
+export class MessageManager extends CachedManager {
+  public channel: any;
+  static [MakeCacheOverrideSymbol] = MessageManager;
+
+  constructor(channel, iterable) {
+    super(channel.client, Message, iterable);
+
+    /**
+     * The channel that the messages belong to
+     *
+     * @type {TextBasedChannels}
+     */
+    this.channel = channel;
+  }
+
+  /**
+   * The cache of Messages
+   *
+   * @type {Collection<Snowflake, Message>}
+   * @name MessageManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache);
+  }
+
+  /**
+   * Data that can be resolved to a Message object. This can be:
+   * - A Message
+   * - A Snowflake
+   *
+   * @typedef {Message|Snowflake} MessageResolvable
+   */
+
+  /**
+   * Options used to fetch a message.
+   *
+   * @typedef {BaseFetchOptions} FetchMessageOptions
+   * @property {MessageResolvable} message The message to fetch
+   */
+
+  /**
+   * Options used to fetch multiple messages.
+   * <info>The `before`, `after`, and `around` parameters are mutually exclusive.</info>
+   *
+   * @typedef {Object} FetchMessagesOptions
+   * @property {number} [limit] The maximum number of messages to return
+   * @property {Snowflake} [before] Consider only messages before this id
+   * @property {Snowflake} [after] Consider only messages after this id
+   * @property {Snowflake} [around] Consider only messages around this id
+   * @property {boolean} [cache] Whether to cache the fetched messages
+   */
+
+  /**
+   * Fetches message(s) from a channel.
+   * <info>The returned Collection does not contain reaction users of the messages if they were not cached.
+   * Those need to be fetched separately in such a case.</info>
+   *
+   * @param {MessageResolvable|FetchMessageOptions|FetchMessagesOptions} [options] Options for fetching message(s)
+   * @returns {Promise<Message|Collection<Snowflake, Message>>}
+   * @example
+   * // Fetch a message
+   * channel.messages.fetch('99539446449315840')
+   *   .then(message => console.log(message.content))
+   *   .catch(console.error);
+   * @example
+   * // Fetch a maximum of 10 messages without caching
+   * channel.messages.fetch({ limit: 10, cache: false })
+   *   .then(messages => console.log(`Received ${messages.size} messages`))
+   *   .catch(console.error);
+   * @example
+   * // Fetch a maximum of 10 messages without caching around a message id
+   * channel.messages.fetch({ limit: 10, cache: false, around: '99539446449315840' })
+   *   .then(messages => console.log(`Received ${messages.size} messages`))
+   *   .catch(console.error);
+   * @example
+   * // Fetch messages and filter by a user id
+   * channel.messages.fetch()
+   *   .then(messages => console.log(`${messages.filter(message =>
+   *          message.author.id === '84484653687267328').size} messages`))
+   *   .catch(console.error);
+   */
+  async fetch(options) {
+    if (!options) return this._fetchMany();
+    const { message, cache, force } = options;
+    const resolvedMessage = this.resolveId(message ?? options);
+    if (resolvedMessage) return this._fetchSingle({ message: resolvedMessage, cache, force });
+    return this._fetchMany(options);
+  }
+
+  async _fetchSingle({ message, cache, force = false }) {
+    if (!force) {
+      const existing = this.cache.get(message);
+      if (existing && !existing.partial) return existing;
+    }
+
+    const data = await this.client.rest.get(Routes.channelMessage(this.channel.id, message));
+    return this._add(data, cache);
+  }
+
+  async _fetchMany({ cache, ...apiOptions } = {}) {
+    const data = await this.client.rest.get(Routes.channelMessages(this.channel.id), {
+      query: makeURLSearchParams(apiOptions),
+    });
+
+    return data.reduce((_data, message) => _data.set(message.id, this._add(message, cache)), new Collection());
+  }
+
+  /**
+   * Options used to fetch pinned messages.
+   *
+   * @typedef {Object} FetchPinnedMessagesOptions
+   * @property {DateResolvable} [before] Consider only pinned messages before this time
+   * @property {number} [limit] The maximum number of pinned messages to return
+   * @property {boolean} [cache] Whether to cache the pinned messages
+   */
+
+  /**
+   * Data returned from fetching pinned messages.
+   *
+   * @typedef {Object} FetchPinnedMessagesResponse
+   * @property {MessagePin[]} items The pinned messages
+   * @property {boolean} hasMore Whether there are additional pinned messages that require a subsequent call
+   */
+
+  /**
+   * Pinned message data returned from fetching pinned messages.
+   *
+   * @typedef {Object} MessagePin
+   * @property {Date} pinnedAt The time the message was pinned at
+   * @property {number} pinnedTimestamp The timestamp the message was pinned at
+   * @property {Message} message The pinned message
+   */
+
+  /**
+   * Fetches the pinned messages of this channel, returning a paginated result.
+   * <info>The returned messages do not contain any reaction data.
+   * Those need to be fetched separately.</info>
+   *
+   * @param {FetchPinnedMessagesOptions} [options={}] Options for fetching pinned messages
+   * @returns {Promise<FetchPinnedMessagesResponse>}
+   * @example
+   * // Get pinned messages
+   * channel.messages.fetchPins()
+   *   .then(messages => console.log(`Received ${messages.items.length} messages`))
+   *   .catch(console.error);
+   */
+  async fetchPins({ cache, ...apiOptions } = {}) {
+    const data = await this.client.rest.get(Routes.channelMessagesPins(this.channel.id), {
+      query: makeURLSearchParams({
+        ...apiOptions,
+        before: apiOptions.before && new Date(apiOptions.before).toISOString(),
+      }),
+    });
+
+    return {
+      items: data.items.map(item => ({
+        pinnedTimestamp: Date.parse(item.pinned_at),
+        get pinnedAt() {
+          return new Date(this.pinnedTimestamp);
+        },
+        message: this._add(item.message, cache),
+      })),
+      hasMore: data.has_more,
+    };
+  }
+
+  /**
+   * Resolves a {@link MessageResolvable} to a {@link Message} object.
+   *
+   * @method resolve
+   * @memberof MessageManager
+   * @instance
+   * @param {MessageResolvable} message The message resolvable to resolve
+   * @returns {?Message}
+   */
+
+  /**
+   * Resolves a {@link MessageResolvable} to a {@link Message} id.
+   *
+   * @method resolveId
+   * @memberof MessageManager
+   * @instance
+   * @param {MessageResolvable} message The message resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Data used to reference an attachment.
+   *
+   * @typedef {Object} MessageEditAttachmentData
+   * @property {Snowflake} id The id of the attachment
+   */
+
+  /**
+   * Options that can be passed to edit a message.
+   *
+   * @typedef {BaseMessageOptions} MessageEditOptions
+   * @property {Array<Attachment|MessageEditAttachmentData>} [attachments] An array of attachments to keep.
+   * All attachments will be kept if omitted
+   * @property {MessageFlags} [flags] Which flags to set for the message
+   * <info>Only the {@link MessageFlags.SuppressEmbeds} flag can be modified.</info>
+   */
+
+  /**
+   * Edits a message, even if it's not cached.
+   *
+   * @param {MessageResolvable} message The message to edit
+   * @param {string|MessageEditOptions|MessagePayload|FileBodyEncodable<RESTPatchAPIChannelMessageJSONBody>|JSONEncodable<RESTPatchAPIChannelMessageJSONBody>} options The options to edit the message
+   * @returns {Promise<Message>}
+   */
+  async edit(message, options) {
+    const messageId = this.resolveId(message);
+    if (!messageId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
+
+    let payload;
+    if (options instanceof MessagePayload) {
+      payload = await options.resolveBody().resolveFiles();
+    } else if (isFileBodyEncodable(options)) {
+      payload = options.toFileBody();
+    } else if (isJSONEncodable(options)) {
+      payload = { body: options.toJSON() };
+    } else {
+      payload = await MessagePayload.create(message instanceof Message ? message : this, options)
+        .resolveBody()
+        .resolveFiles();
+    }
+
+    const data = await this.client.rest.patch(Routes.channelMessage(this.channel.id, messageId), payload);
+
+    const existing = this.cache.get(messageId);
+    if (existing) {
+      const clone = existing._clone();
+      clone._patch(data);
+      return clone;
+    }
+
+    return this._add(data);
+  }
+
+  /**
+   * Pins a message to the channel's pinned messages, even if it's not cached.
+   *
+   * @param {MessageResolvable} message The message to pin
+   * @param {string} [reason] Reason for pinning
+   * @returns {Promise<void>}
+   */
+  async pin(message, reason) {
+    const messageId = this.resolveId(message);
+    if (!messageId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
+
+    await this.client.rest.put(Routes.channelMessagesPin(this.channel.id, messageId), { reason });
+  }
+
+  /**
+   * Unpins a message from the channel's pinned messages, even if it's not cached.
+   *
+   * @param {MessageResolvable} message The message to unpin
+   * @param {string} [reason] Reason for unpinning
+   * @returns {Promise<void>}
+   */
+  async unpin(message, reason) {
+    const messageId = this.resolveId(message);
+    if (!messageId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
+
+    await this.client.rest.delete(Routes.channelMessagesPin(this.channel.id, messageId), { reason });
+  }
+
+  /**
+   * Adds a reaction to a message, even if it's not cached.
+   *
+   * @param {MessageResolvable} message The message to react to
+   * @param {EmojiIdentifierResolvable} emoji The emoji to react with
+   * @returns {Promise<void>}
+   */
+  async react(message, emoji) {
+    const messageId = this.resolveId(message);
+    if (!messageId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
+
+    const resolvedEmoji = resolvePartialEmoji(emoji);
+    if (!resolvedEmoji) throw new DiscordjsTypeError(ErrorCodes.EmojiType, 'emoji', 'EmojiIdentifierResolvable');
+
+    const emojiId = resolvedEmoji.id
+      ? `${resolvedEmoji.animated ? 'a:' : ''}${resolvedEmoji.name}:${resolvedEmoji.id}`
+      : encodeURIComponent(resolvedEmoji.name);
+
+    await this.client.rest.put(Routes.channelMessageOwnReaction(this.channel.id, messageId, emojiId));
+  }
+
+  /**
+   * Deletes a message, even if it's not cached.
+   *
+   * @param {MessageResolvable} message The message to delete
+   * @returns {Promise<void>}
+   */
+  async delete(message) {
+    const messageId = this.resolveId(message);
+    if (!messageId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'message', 'MessageResolvable');
+
+    await this.client.rest.delete(Routes.channelMessage(this.channel.id, messageId));
+  }
+
+  /**
+   * Ends a poll.
+   *
+   * @param {Snowflake} messageId The id of the message
+   * @returns {Promise<Message>}
+   */
+  async endPoll(messageId) {
+    const message = await this.client.rest.post(Routes.expirePoll(this.channel.id, messageId));
+    return this._add(message, false);
+  }
+
+  /**
+   * Options used for fetching voters of an answer in a poll.
+   *
+   * @typedef {BaseFetchPollAnswerVotersOptions} FetchPollAnswerVotersOptions
+   * @param {Snowflake} messageId The id of the message
+   * @param {number} answerId The id of the answer
+   */
+
+  /**
+   * Fetches the users that voted for a poll answer.
+   *
+   * @param {FetchPollAnswerVotersOptions} options The options for fetching the poll answer voters
+   * @returns {Promise<Collection<Snowflake, User>>}
+   */
+  async fetchPollAnswerVoters({ messageId, answerId, after, limit }) {
+    const voters = await this.client.rest.get(Routes.pollAnswerVoters(this.channel.id, messageId, answerId), {
+      query: makeURLSearchParams({ limit, after }),
+    });
+
+    return voters.users.reduce((acc, user) => acc.set(user.id, this.client.users._add(user, false)), new Collection());
+  }
+}

package/src/managers/PartialGroupDMMessageManager.ts

@@ -0,0 +1,15 @@
+import { MessageManager  } from './MessageManager.js';
+
+/**
+ * Manages API methods for messages in group direct message channels and holds their cache.
+ *
+ * @extends {MessageManager}
+ */
+export class PartialGroupDMMessageManager extends MessageManager {
+  /**
+   * The channel that the messages belong to
+   *
+   * @name PartialGroupDMMessageManager#channel
+   * @type {PartialGroupDMChannel}
+   */
+}

package/src/managers/PermissionOverwriteManager.ts

@@ -0,0 +1,174 @@
+import process from 'node:process';
+import { Collection  } from '@ovencord/collection';
+import { OverwriteType, Routes  } from 'discord-api-types/v10';
+import { DiscordjsTypeError, ErrorCodes  } from '../errors/index.js';
+import { PermissionOverwrites  } from '../structures/PermissionOverwrites.js';
+import { Role  } from '../structures/Role.js';
+import { CachedManager  } from './CachedManager.js';
+
+let cacheWarningEmitted = false;
+
+/**
+ * Manages API methods for guild channel permission overwrites and stores their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class PermissionOverwriteManager extends CachedManager {
+  public channel: any;
+  constructor(channel, iterable) {
+    super(channel.client, PermissionOverwrites);
+    if (!cacheWarningEmitted && this._cache.constructor.name !== 'Collection') {
+      cacheWarningEmitted = true;
+      process.emitWarning(
+        `Overriding the cache handling for ${this.constructor.name} is unsupported and breaks functionality.`,
+        'UnsupportedCacheOverwriteWarning',
+      );
+    }
+
+    /**
+     * The channel of the permission overwrite this manager belongs to
+     *
+     * @type {GuildChannel}
+     */
+    this.channel = channel;
+
+    if (iterable) {
+      for (const item of iterable) {
+        this._add(item);
+      }
+    }
+  }
+
+  /**
+   * The cache of this Manager
+   *
+   * @type {Collection<Snowflake, PermissionOverwrites>}
+   * @name PermissionOverwriteManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { extras: [this.channel] });
+  }
+
+  /**
+   * Replaces the permission overwrites in this channel.
+   *
+   * @param {OverwriteResolvable[]|Collection<Snowflake, OverwriteResolvable>} overwrites
+   * Permission overwrites the channel gets updated with
+   * @param {string} [reason] Reason for updating the channel overwrites
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * message.channel.permissionOverwrites.set([
+   *   {
+   *      id: message.author.id,
+   *      deny: [PermissionFlagsBits.ViewChannel],
+   *   },
+   * ], 'Needed to change permissions');
+   */
+  async set(overwrites, reason) {
+    if (!Array.isArray(overwrites) && !(overwrites instanceof Collection)) {
+      throw new DiscordjsTypeError(
+        ErrorCodes.InvalidType,
+        'overwrites',
+        'Array or Collection of Permission Overwrites',
+        true,
+      );
+    }
+
+    return this.channel.edit({ permissionOverwrites: overwrites, reason });
+  }
+
+  /**
+   * Extra information about the overwrite.
+   *
+   * @typedef {Object} GuildChannelOverwriteOptions
+   * @property {string} [reason] The reason for creating/editing this overwrite
+   * @property {OverwriteType} [type] The type of overwrite. Use this to bypass automatic resolution of `type`
+   * that results in an error for an uncached structure
+   */
+
+  /**
+   * Creates or edits permission overwrites for a user or role in this channel.
+   *
+   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
+   * @param {PermissionOverwriteOptions} options The options for the update
+   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
+   * @param {PermissionOverwrites} [existing] The existing overwrites to merge with this update
+   * @returns {Promise<GuildChannel>}
+   * @private
+   */
+  async upsert(userOrRole, options, { reason, type } = {}, existing = undefined) {
+    const userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
+
+    let resolvedType = type;
+    if (typeof resolvedType !== 'number') {
+      const resolvedUserOrRole = this.channel.guild.roles.resolve(userOrRole) ?? this.client.users.resolve(userOrRole);
+      if (!resolvedUserOrRole) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'parameter', 'User nor a Role');
+      resolvedType = resolvedUserOrRole instanceof Role ? OverwriteType.Role : OverwriteType.Member;
+    }
+
+    const { allow, deny } = PermissionOverwrites.resolveOverwriteOptions(options, existing);
+
+    await this.client.rest.put(Routes.channelPermission(this.channel.id, userOrRoleId), {
+      body: { id: userOrRoleId, type: resolvedType, allow, deny },
+      reason,
+    });
+    return this.channel;
+  }
+
+  /**
+   * Creates permission overwrites for a user or role in this channel, or replaces them if already present.
+   *
+   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
+   * @param {PermissionOverwriteOptions} options The options for the update
+   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * // Create or Replace permission overwrites for a message author
+   * message.channel.permissionOverwrites.create(message.author, {
+   *   SendMessages: false
+   * })
+   *   .then(channel => console.log(channel.permissionOverwrites.cache.get(message.author.id)))
+   *   .catch(console.error);
+   */
+  async create(userOrRole, options, overwriteOptions) {
+    return this.upsert(userOrRole, options, overwriteOptions);
+  }
+
+  /**
+   * Edits permission overwrites for a user or role in this channel, or creates an entry if not already present.
+   *
+   * @param {RoleResolvable|UserResolvable} userOrRole The user or role to update
+   * @param {PermissionOverwriteOptions} options The options for the update
+   * @param {GuildChannelOverwriteOptions} [overwriteOptions] The extra information for the update
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * // Edit or Create permission overwrites for a message author
+   * message.channel.permissionOverwrites.edit(message.author, {
+   *   SendMessages: false
+   * })
+   *   .then(channel => console.log(channel.permissionOverwrites.cache.get(message.author.id)))
+   *   .catch(console.error);
+   */
+  async edit(userOrRole, options, overwriteOptions) {
+    const existing = this.cache.get(
+      this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole),
+    );
+    return this.upsert(userOrRole, options, overwriteOptions, existing);
+  }
+
+  /**
+   * Deletes permission overwrites for a user or role in this channel.
+   *
+   * @param {UserResolvable|RoleResolvable} userOrRole The user or role to delete
+   * @param {string} [reason] The reason for deleting the overwrite
+   * @returns {Promise<GuildChannel>}
+   */
+  async delete(userOrRole, reason) {
+    const userOrRoleId = this.channel.guild.roles.resolveId(userOrRole) ?? this.client.users.resolveId(userOrRole);
+    if (!userOrRoleId) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'parameter', 'User nor a Role');
+
+    await this.client.rest.delete(Routes.channelPermission(this.channel.id, userOrRoleId), { reason });
+    return this.channel;
+  }
+}

package/src/managers/PollAnswerVoterManager.ts

@@ -0,0 +1,59 @@
+import { Collection  } from '@ovencord/collection';
+import { makeURLSearchParams  } from '@ovencord/rest';
+import { Routes  } from 'discord-api-types/v10';
+import { User  } from '../structures/User.js';
+import { CachedManager  } from './CachedManager.js';
+
+/**
+ * Manages API methods for users who voted on a poll and stores their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class PollAnswerVoterManager extends CachedManager {
+  public answer: any;
+  constructor(answer) {
+    super(answer.client, User);
+
+    /**
+     * The poll answer that this manager belongs to
+     *
+     * @type {PollAnswer}
+     */
+    this.answer = answer;
+  }
+
+  /**
+   * The cache of this manager
+   *
+   * @type {Collection<Snowflake, User>}
+   * @name PollAnswerVoterManager#cache
+   */
+
+  /**
+   * Options used for fetching voters of a poll answer.
+   *
+   * @typedef {Object} BaseFetchPollAnswerVotersOptions
+   * @property {number} [limit] The maximum number of voters to fetch
+   * @property {Snowflake} [after] The user id to fetch voters after
+   */
+
+  /**
+   * Fetches the users that voted on this poll answer. Resolves with a collection of users, mapped by their ids.
+   *
+   * @param {BaseFetchPollAnswerVotersOptions} [options={}] Options for fetching the users
+   * @returns {Promise<Collection<Snowflake, User>>}
+   */
+  async fetch({ after, limit } = {}) {
+    const poll = this.answer.poll;
+    const query = makeURLSearchParams({ limit, after });
+    const data = await this.client.rest.get(Routes.pollAnswerVoters(poll.channelId, poll.messageId, this.answer.id), {
+      query,
+    });
+
+    return data.users.reduce((coll, rawUser) => {
+      const user = this.client.users._add(rawUser);
+      this.cache.set(user.id, user);
+      return coll.set(user.id, user);
+    }, new Collection());
+  }
+}

package/src/managers/PresenceManager.ts

@@ -0,0 +1,60 @@
+import { Presence  } from '../structures/Presence.js';
+import { CachedManager  } from './CachedManager.js';
+
+/**
+ * Manages API methods for Presences and holds their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class PresenceManager extends CachedManager {
+  public client: any;
+  constructor(client, iterable) {
+    super(client, Presence, iterable);
+  }
+
+  /**
+   * The cache of Presences
+   *
+   * @type {Collection<Snowflake, Presence>}
+   * @name PresenceManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { id: data.user.id });
+  }
+
+  /**
+   * Data that can be resolved to a Presence object. This can be:
+   * - A Presence
+   * - A UserResolvable
+   * - A Snowflake
+   *
+   * @typedef {Presence|UserResolvable|Snowflake} PresenceResolvable
+   */
+
+  /**
+   * Resolves a {@link PresenceResolvable} to a {@link Presence} object.
+   *
+   * @param {PresenceResolvable} presence The presence resolvable to resolve
+   * @returns {?Presence}
+   */
+  resolve(presence) {
+    const presenceResolvable = super.resolve(presence);
+    if (presenceResolvable) return presenceResolvable;
+    const userId = this.client.users.resolveId(presence);
+    return super.cache.get(userId) ?? null;
+  }
+
+  /**
+   * Resolves a {@link PresenceResolvable} to a {@link Presence} id.
+   *
+   * @param {PresenceResolvable} presence The presence resolvable to resolve
+   * @returns {?Snowflake}
+   */
+  resolveId(presence) {
+    const presenceResolvable = super.resolveId(presence);
+    if (presenceResolvable) return presenceResolvable;
+    const userId = this.client.users.resolveId(presence);
+    return this.cache.has(userId) ? userId : null;
+  }
+}