@velliajs/discord 1.0.0

package/src/managers/ThreadManager.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { makeURLSearchParams } = require('@discordjs/rest');
+const { Routes } = require('discord-api-types/v10');
+const CachedManager = require('./CachedManager');
+const { DiscordjsTypeError, ErrorCodes } = require('../errors');
+const ThreadChannel = require('../structures/ThreadChannel');
+
+/**
+ * Manages API methods for thread-based channels and stores their cache.
+ * @extends {CachedManager}
+ */
+class ThreadManager extends CachedManager {
+  constructor(channel, iterable) {
+    super(channel.client, ThreadChannel, iterable);
+
+    /**
+     * The channel this Manager belongs to
+     * @type {TextChannel|NewsChannel|ForumChannel}
+     */
+    this.channel = channel;
+  }
+
+  /**
+   * Data that can be resolved to a Thread Channel object. This can be:
+   * * A ThreadChannel object
+   * * A Snowflake
+   * @typedef {ThreadChannel|Snowflake} ThreadChannelResolvable
+   */
+
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, ThreadChannel>}
+   * @name ThreadManager#cache
+   */
+
+  _add(thread) {
+    const existing = this.cache.get(thread.id);
+    if (existing) return existing;
+    this.cache.set(thread.id, thread);
+    return thread;
+  }
+
+  /**
+   * Resolves a {@link ThreadChannelResolvable} to a {@link ThreadChannel} object.
+   * @method resolve
+   * @memberof ThreadManager
+   * @instance
+   * @param {ThreadChannelResolvable} thread The ThreadChannel resolvable to resolve
+   * @returns {?ThreadChannel}
+   */
+
+  /**
+   * Resolves a {@link ThreadChannelResolvable} to a {@link ThreadChannel} id.
+   * @method resolveId
+   * @memberof ThreadManager
+   * @instance
+   * @param {ThreadChannelResolvable} thread The ThreadChannel resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Options for creating a thread. <warn>Only one of `startMessage` or `type` can be defined.</warn>
+   * @typedef {StartThreadOptions} ThreadCreateOptions
+   * @property {MessageResolvable} [startMessage] The message to start a thread from. <warn>If this is defined then type
+   * of thread gets automatically defined and cannot be changed. The provided `type` field will be ignored</warn>
+   * @property {ChannelType.AnnouncementThread|ChannelType.PublicThread|ChannelType.PrivateThread} [type]
+   * The type of thread to create.
+   * Defaults to {@link ChannelType.PublicThread} if created in a {@link TextChannel}
+   * <warn>When creating threads in a {@link NewsChannel} this is ignored and is always
+   * {@link ChannelType.AnnouncementThread}</warn>
+   * @property {boolean} [invitable] Whether non-moderators can add other non-moderators to the thread
+   * <info>Can only be set when type will be {@link ChannelType.PrivateThread}</info>
+   */
+
+  /**
+   * Options for fetching multiple threads.
+   * @typedef {Object} FetchThreadsOptions
+   * @property {FetchArchivedThreadOptions} [archived] Options used to fetch archived threads
+   */
+
+  /**
+   * Obtains a thread from Discord, or the channel cache if it's already available.
+   * @param {ThreadChannelResolvable|FetchThreadsOptions} [options] The options to fetch threads. If it is a
+   * ThreadChannelResolvable then the specified thread will be fetched. Fetches all active threads if `undefined`
+   * @param {BaseFetchOptions} [cacheOptions] Additional options for this fetch. <warn>The `force` field gets ignored
+   * if `options` is not a {@link ThreadChannelResolvable}</warn>
+   * @returns {Promise<?(ThreadChannel|FetchedThreads|FetchedThreadsMore)>}
+   * {@link FetchedThreads} if active & {@link FetchedThreadsMore} if archived.
+   * @example
+   * // Fetch a thread by its id
+   * channel.threads.fetch('831955138126104859')
+   *   .then(channel => console.log(channel.name))
+   *   .catch(console.error);
+   */
+  fetch(options, { cache, force } = {}) {
+    if (!options) return this.fetchActive(cache);
+    const channel = this.client.channels.resolveId(options);
+    if (channel) return this.client.channels.fetch(channel, { cache, force });
+    if (options.archived) {
+      return this.fetchArchived(options.archived, cache);
+    }
+    return this.fetchActive(cache);
+  }
+
+  /**
+   * Data that can be resolved to a Date object. This can be:
+   * * A Date object
+   * * A number representing a timestamp
+   * * An [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) string
+   * @typedef {Date|number|string} DateResolvable
+   */
+
+  /**
+   * The options used to fetch archived threads.
+   * @typedef {Object} FetchArchivedThreadOptions
+   * @property {string} [type='public'] The type of threads to fetch (`public` or `private`)
+   * @property {boolean} [fetchAll=false] Whether to fetch **all** archived threads when `type` is `private`
+   * <info>This property requires the {@link PermissionFlagsBits.ManageThreads} permission if `true`.</info>
+   * @property {DateResolvable|ThreadChannelResolvable} [before] Only return threads that were archived before this Date
+   * or Snowflake
+   * <warn>Must be a {@link ThreadChannelResolvable} when `type` is `private` and `fetchAll` is `false`.</warn>
+   * @property {number} [limit] Maximum number of threads to return
+   */
+
+  /**
+   * Data returned from fetching multiple threads.
+   * @typedef {FetchedThreads} FetchedThreadsMore
+   * @property {?boolean} hasMore Whether there are potentially additional threads that require a subsequent call
+   */
+
+  /**
+   * Obtains a set of archived threads from Discord.
+   * <info>This method requires the {@link PermissionFlagsBits.ReadMessageHistory} permission
+   * in the parent channel.</info>
+   * @param {FetchArchivedThreadOptions} [options] The options to fetch archived threads
+   * @param {boolean} [cache=true] Whether to cache the new thread objects if they aren't already
+   * @returns {Promise<FetchedThreadsMore>}
+   */
+  async fetchArchived({ type = 'public', fetchAll = false, before, limit } = {}, cache = true) {
+    let path = Routes.channelThreads(this.channel.id, type);
+    if (type === 'private' && !fetchAll) {
+      path = Routes.channelJoinedArchivedThreads(this.channel.id);
+    }
+    let timestamp;
+    let id;
+    const query = makeURLSearchParams({ limit });
+    if (before !== undefined) {
+      if (before instanceof ThreadChannel || /^\d{17,19}$/.test(String(before))) {
+        id = this.resolveId(before);
+        timestamp = this.resolve(before)?.archivedAt?.toISOString();
+        const toUse = type === 'private' && !fetchAll ? id : timestamp;
+        if (toUse) {
+          query.set('before', toUse);
+        }
+      } else {
+        try {
+          timestamp = new Date(before).toISOString();
+          if (type === 'public' || fetchAll) {
+            query.set('before', timestamp);
+          }
+        } catch {
+          throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'before', 'DateResolvable or ThreadChannelResolvable');
+        }
+      }
+    }
+
+    const raw = await this.client.rest.get(path, { query });
+    return this.constructor._mapThreads(raw, this.client, { parent: this.channel, cache });
+  }
+
+  /**
+   * Obtains all active thread channels in the guild.
+   * This internally calls {@link GuildChannelManager#fetchActiveThreads}.
+   * @param {boolean} [cache=true] Whether to cache the fetched data
+   * @returns {Promise<FetchedThreads>}
+   */
+  fetchActive(cache = true) {
+    return this.channel.guild.channels.fetchActiveThreads(cache);
+  }
+
+  static _mapThreads(rawThreads, client, { parent, guild, cache }) {
+    const threads = rawThreads.threads.reduce((coll, raw) => {
+      const thread = client.channels._add(raw, guild ?? parent?.guild, { cache });
+      if (parent && thread.parentId !== parent.id) return coll;
+      return coll.set(thread.id, thread);
+    }, new Collection());
+
+    // Discord sends the thread id as id in this object
+    const threadMembers = rawThreads.members.reduce(
+      (coll, raw) => coll.set(raw.user_id, threads.get(raw.id).members._add(raw)),
+      new Collection(),
+    );
+
+    const response = { threads, members: threadMembers };
+
+    // The GET `/guilds/{guild.id}/threads/active` route does not return `has_more`.
+    if ('has_more' in rawThreads) response.hasMore = rawThreads.has_more;
+    return response;
+  }
+}
+
+module.exports = ThreadManager;

package/src/managers/ThreadMemberManager.js

@@ -0,0 +1,182 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { makeURLSearchParams } = require('@discordjs/rest');
+const { Routes } = require('discord-api-types/v10');
+const CachedManager = require('./CachedManager');
+const { DiscordjsTypeError, ErrorCodes } = require('../errors');
+const ThreadMember = require('../structures/ThreadMember');
+
+/**
+ * Manages API methods for GuildMembers and stores their cache.
+ * @extends {CachedManager}
+ */
+class ThreadMemberManager extends CachedManager {
+  constructor(thread, iterable) {
+    super(thread.client, ThreadMember, iterable);
+
+    /**
+     * The thread this manager belongs to
+     * @type {ThreadChannel}
+     */
+    this.thread = thread;
+  }
+
+  /**
+   * The cache of this Manager
+   * @type {Collection<Snowflake, ThreadMember>}
+   * @name ThreadMemberManager#cache
+   */
+
+  _add(data, cache = true) {
+    const existing = this.cache.get(data.user_id);
+    if (cache) existing?._patch(data, { cache });
+    if (existing) return existing;
+
+    const member = new ThreadMember(this.thread, data, { cache });
+    if (cache) this.cache.set(data.user_id, member);
+    return member;
+  }
+
+  /**
+   * Fetches the client user as a ThreadMember of the thread.
+   * @param {BaseFetchOptions} [options] The options for fetching the member
+   * @returns {Promise<ThreadMember>}
+   */
+  fetchMe(options) {
+    return this.fetch({ ...options, member: this.client.user.id });
+  }
+
+  /**
+   * The client user as a ThreadMember of this ThreadChannel
+   * @type {?ThreadMember}
+   * @readonly
+   */
+  get me() {
+    return this.resolve(this.client.user.id);
+  }
+
+  /**
+   * Data that resolves to give a ThreadMember object. This can be:
+   * * A ThreadMember object
+   * * A User resolvable
+   * @typedef {ThreadMember|UserResolvable} ThreadMemberResolvable
+   */
+
+  /**
+   * Resolves a {@link ThreadMemberResolvable} to a {@link ThreadMember} object.
+   * @param {ThreadMemberResolvable} member The user that is part of the thread
+   * @returns {?GuildMember}
+   */
+  resolve(member) {
+    const memberResolvable = super.resolve(member);
+    if (memberResolvable) return memberResolvable;
+    const userResolvable = this.client.users.resolveId(member);
+    if (userResolvable) return super.resolve(userResolvable);
+    return null;
+  }
+
+  /**
+   * Resolves a {@link ThreadMemberResolvable} to a {@link ThreadMember} id string.
+   * @param {ThreadMemberResolvable} member The user that is part of the guild
+   * @returns {?Snowflake}
+   */
+  resolveId(member) {
+    const memberResolvable = super.resolveId(member);
+    if (memberResolvable) return memberResolvable;
+    const userResolvable = this.client.users.resolveId(member);
+    return this.cache.has(userResolvable) ? userResolvable : null;
+  }
+
+  /**
+   * Adds a member to the thread.
+   * @param {UserResolvable|'@me'} member The member to add
+   * @param {string} [reason] The reason for adding this member
+   * @returns {Promise<Snowflake>}
+   */
+  async add(member, reason) {
+    const id = member === '@me' ? member : this.client.users.resolveId(member);
+    if (!id) throw new DiscordjsTypeError(ErrorCodes.InvalidType, 'member', 'UserResolvable');
+    await this.client.rest.put(Routes.threadMembers(this.thread.id, id), { reason });
+    return id;
+  }
+
+  /**
+   * Remove a user from the thread.
+   * @param {Snowflake|'@me'} id The id of the member to remove
+   * @param {string} [reason] The reason for removing this member from the thread
+   * @returns {Promise<Snowflake>}
+   */
+  async remove(id, reason) {
+    await this.client.rest.delete(Routes.threadMembers(this.thread.id, id), { reason });
+    return id;
+  }
+
+  /**
+   * Options used to fetch a thread member.
+   * @typedef {BaseFetchOptions} FetchThreadMemberOptions
+   * @property {ThreadMemberResolvable} member The thread member to fetch
+   * @property {boolean} [withMember] Whether to also return the guild member associated with this thread member
+   */
+
+  /**
+   * Options used to fetch multiple thread members with guild member data.
+   * <info>With `withMember` set to `true`, pagination is enabled.</info>
+   * @typedef {Object} FetchThreadMembersWithGuildMemberDataOptions
+   * @property {true} withMember Whether to also return the guild member data
+   * @property {Snowflake} [after] Consider only thread members after this id
+   * @property {number} [limit] The maximum number of thread members to return
+   * @property {boolean} [cache] Whether to cache the fetched thread members and guild members
+   */
+
+  /**
+   * Options used to fetch multiple thread members without guild member data.
+   * @typedef {Object} FetchThreadMembersWithoutGuildMemberDataOptions
+   * @property {false} [withMember] Whether to also return the guild member data
+   * @property {boolean} [cache] Whether to cache the fetched thread members
+   */
+
+  /**
+   * Options used to fetch multiple thread members.
+   * @typedef {FetchThreadMembersWithGuildMemberDataOptions|
+   * FetchThreadMembersWithoutGuildMemberDataOptions} FetchThreadMembersOptions
+   */
+
+  /**
+   * Fetches thread member(s) from Discord.
+   * <info>This method requires the {@link GatewayIntentBits.GuildMembers} privileged gateway intent.</info>
+   * @param {ThreadMemberResolvable|FetchThreadMemberOptions|FetchThreadMembersOptions} [options]
+   * Options for fetching thread member(s)
+   * @returns {Promise<ThreadMember|Collection<Snowflake, ThreadMember>>}
+   */
+  fetch(options) {
+    if (!options) return this._fetchMany();
+    const { member, withMember, cache, force } = options;
+    const resolvedMember = this.resolveId(member ?? options);
+    if (resolvedMember) return this._fetchSingle({ member: resolvedMember, withMember, cache, force });
+    return this._fetchMany(options);
+  }
+
+  async _fetchSingle({ member, withMember, cache, force = false }) {
+    if (!force) {
+      const existing = this.cache.get(member);
+      if (existing) return existing;
+    }
+
+    const data = await this.client.rest.get(Routes.threadMembers(this.thread.id, member), {
+      query: makeURLSearchParams({ with_member: withMember }),
+    });
+
+    return this._add(data, cache);
+  }
+
+  async _fetchMany({ withMember, after, limit, cache } = {}) {
+    const data = await this.client.rest.get(Routes.threadMembers(this.thread.id), {
+      query: makeURLSearchParams({ with_member: withMember, after, limit }),
+    });
+
+    return data.reduce((col, member) => col.set(member.user_id, this._add(member, cache)), new Collection());
+  }
+}
+
+module.exports = ThreadMemberManager;

package/src/managers/UserManager.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const { ChannelType, Routes } = require('discord-api-types/v10');
+const CachedManager = require('./CachedManager');
+const { DiscordjsError, ErrorCodes } = require('../errors');
+const { GuildMember } = require('../structures/GuildMember');
+const { Message } = require('../structures/Message');
+const ThreadMember = require('../structures/ThreadMember');
+const User = require('../structures/User');
+
+/**
+ * Manages API methods for users and stores their cache.
+ * @extends {CachedManager}
+ */
+class UserManager extends CachedManager {
+  constructor(client, iterable) {
+    super(client, User, iterable);
+  }
+
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, User>}
+   * @name UserManager#cache
+   */
+
+  /**
+   * Data that resolves to give a User object. This can be:
+   * * A User object
+   * * A Snowflake
+   * * A Message object (resolves to the message author)
+   * * A GuildMember object
+   * * A ThreadMember object
+   * @typedef {User|Snowflake|Message|GuildMember|ThreadMember} UserResolvable
+   */
+
+  /**
+   * The DM between the client's user and a user
+   * @param {Snowflake} userId The user id
+   * @returns {?DMChannel}
+   * @private
+   */
+  dmChannel(userId) {
+    return this.client.channels.cache.find(c => c.type === ChannelType.DM && c.recipientId === userId) ?? null;
+  }
+
+  /**
+   * Creates a {@link DMChannel} between the client and a user.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<DMChannel>}
+   */
+  async createDM(user, { cache = true, force = false } = {}) {
+    const id = this.resolveId(user);
+
+    if (!force) {
+      const dmChannel = this.dmChannel(id);
+      if (dmChannel && !dmChannel.partial) return dmChannel;
+    }
+
+    const data = await this.client.rest.post(Routes.userChannels(), { body: { recipient_id: id } });
+    return this.client.channels._add(data, null, { cache });
+  }
+
+  /**
+   * Deletes a {@link DMChannel} (if one exists) between the client and a user. Resolves with the channel if successful.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @returns {Promise<DMChannel>}
+   */
+  async deleteDM(user) {
+    const id = this.resolveId(user);
+    const dmChannel = this.dmChannel(id);
+    if (!dmChannel) throw new DiscordjsError(ErrorCodes.UserNoDMChannel);
+    await this.client.rest.delete(Routes.channel(dmChannel.id));
+    this.client.channels._remove(dmChannel.id);
+    return dmChannel;
+  }
+
+  /**
+   * Obtains a user from Discord, or the user cache if it's already available.
+   * @param {UserResolvable} user The user to fetch
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<User>}
+   */
+  async fetch(user, { cache = true, force = false } = {}) {
+    const id = this.resolveId(user);
+    if (!force) {
+      const existing = this.cache.get(id);
+      if (existing && !existing.partial) return existing;
+    }
+
+    const data = await this.client.rest.get(Routes.user(id));
+    return this._add(data, cache);
+  }
+
+  /**
+   * Fetches a user's flags.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<UserFlagsBitField>}
+   */
+  async fetchFlags(user, options) {
+    return (await this.fetch(user, options)).flags;
+  }
+
+  /**
+   * Sends a message to a user.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @param {string|MessagePayload|MessageCreateOptions} options The options to provide
+   * @returns {Promise<Message>}
+   */
+  async send(user, options) {
+    return (await this.createDM(user)).send(options);
+  }
+
+  /**
+   * Resolves a {@link UserResolvable} to a {@link User} object.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @returns {?User}
+   */
+  resolve(user) {
+    if (user instanceof GuildMember || user instanceof ThreadMember) return user.user;
+    if (user instanceof Message) return user.author;
+    return super.resolve(user);
+  }
+
+  /**
+   * Resolves a {@link UserResolvable} to a {@link User} id.
+   * @param {UserResolvable} user The UserResolvable to identify
+   * @returns {?Snowflake}
+   */
+  resolveId(user) {
+    if (user instanceof ThreadMember) return user.id;
+    if (user instanceof GuildMember) return user.user.id;
+    if (user instanceof Message) return user.author.id;
+    return super.resolveId(user);
+  }
+}
+
+module.exports = UserManager;

package/src/managers/VoiceStateManager.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const CachedManager = require('./CachedManager');
+const VoiceState = require('../structures/VoiceState');
+
+/**
+ * Manages API methods for VoiceStates and stores their cache.
+ * @extends {CachedManager}
+ */
+class VoiceStateManager extends CachedManager {
+  constructor(guild, iterable) {
+    super(guild.client, VoiceState, iterable);
+
+    /**
+     * The guild this manager belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of this manager
+   * @type {Collection<Snowflake, VoiceState>}
+   * @name VoiceStateManager#cache
+   */
+
+  _add(data, cache = true) {
+    const existing = this.cache.get(data.user_id);
+    if (existing) return existing._patch(data);
+
+    const entry = new this.holds(this.guild, data);
+    if (cache) this.cache.set(data.user_id, entry);
+    return entry;
+  }
+}
+
+module.exports = VoiceStateManager;