feat: add support for guild forums

packages/discord.js/src/errors/ErrorCodes.js

@@ -143,6 +143,8 @@
 
  * @property {'NotImplemented'} NotImplemented
 
+ * @property {'GuildForumMessageRequired'} GuildForumMessageRequired
+
  * @property {'SweepFilterReturn'} SweepFilterReturn
  */
 
@@ -288,6 +290,8 @@ const keys = [
   'NotImplemented',
 
   'SweepFilterReturn',
+
+  'GuildForumMessageRequired',
 ];
 
 // JSDoc for IntelliSense purposes

packages/discord.js/src/errors/Messages.js

@@ -157,6 +157,8 @@ const Messages = {
   [DjsErrorCodes.NotImplemented]: (what, name) => `Method ${what} not implemented on ${name}.`,
 
   [DjsErrorCodes.SweepFilterReturn]: 'The return value of the sweepFilter function was not false or a Function',
+
+  [DjsErrorCodes.GuildForumMessageRequired]: 'You must provide a message to create a guild forum thread',
 };
 
 module.exports = Messages;

packages/discord.js/src/index.js

@@ -22,6 +22,7 @@ exports.ActivityFlagsBitField = require('./util/ActivityFlagsBitField');
 exports.ApplicationFlagsBitField = require('./util/ApplicationFlagsBitField');
 exports.BaseManager = require('./managers/BaseManager');
 exports.BitField = require('./util/BitField');
+exports.ChannelFlagsBitField = require('./util/ChannelFlagsBitField');
 exports.Collection = require('@discordjs/collection').Collection;
 exports.Constants = require('./util/Constants');
 exports.Colors = require('./util/Colors');
@@ -58,12 +59,14 @@ exports.GuildBanManager = require('./managers/GuildBanManager');
 exports.GuildChannelManager = require('./managers/GuildChannelManager');
 exports.GuildEmojiManager = require('./managers/GuildEmojiManager');
 exports.GuildEmojiRoleManager = require('./managers/GuildEmojiRoleManager');
+exports.GuildForumThreadManager = require('./managers/GuildForumThreadManager');
 exports.GuildInviteManager = require('./managers/GuildInviteManager');
 exports.GuildManager = require('./managers/GuildManager');
 exports.GuildMemberManager = require('./managers/GuildMemberManager');
 exports.GuildMemberRoleManager = require('./managers/GuildMemberRoleManager');
 exports.GuildScheduledEventManager = require('./managers/GuildScheduledEventManager');
 exports.GuildStickerManager = require('./managers/GuildStickerManager');
+exports.GuildTextThreadManager = require('./managers/GuildTextThreadManager');
 exports.MessageManager = require('./managers/MessageManager');
 exports.PermissionOverwriteManager = require('./managers/PermissionOverwriteManager');
 exports.PresenceManager = require('./managers/PresenceManager');
@@ -109,6 +112,7 @@ exports.DMChannel = require('./structures/DMChannel');
 exports.Embed = require('./structures/Embed');
 exports.EmbedBuilder = require('./structures/EmbedBuilder');
 exports.Emoji = require('./structures/Emoji').Emoji;
+exports.ForumChannel = require('./structures/ForumChannel');
 exports.Guild = require('./structures/Guild').Guild;
 exports.GuildAuditLogs = require('./structures/GuildAuditLogs');
 exports.GuildAuditLogsEntry = require('./structures/GuildAuditLogsEntry');

packages/discord.js/src/managers/GuildChannelManager.js

@@ -4,12 +4,13 @@ const process = require('node:process');
 const { Collection } = require('@discordjs/collection');
 const { ChannelType, Routes } = require('discord-api-types/v10');
 const CachedManager = require('./CachedManager');
-const ThreadManager = require('./ThreadManager');
+const GuildTextThreadManager = require('./GuildTextThreadManager');
 const { Error, TypeError, ErrorCodes } = require('../errors');
 const GuildChannel = require('../structures/GuildChannel');
 const PermissionOverwrites = require('../structures/PermissionOverwrites');
 const ThreadChannel = require('../structures/ThreadChannel');
 const Webhook = require('../structures/Webhook');
+const { transformGuildForumTag, transformGuildDefaultReaction } = require('../util/Channels');
 const { ThreadChannelTypes } = require('../util/Constants');
 const DataResolver = require('../util/DataResolver');
 const { setPosition } = require('../util/Util');
@@ -218,6 +219,9 @@ class GuildChannelManager extends CachedManager {
    * The default auto archive duration for all new threads in this channel
    * @property {?string} [rtcRegion] The RTC region of the channel
    * @property {?VideoQualityMode} [videoQualityMode] The camera video quality mode of the channel
+   * @property {GuildForumTag[]} [availableTags] The tags to set as available in a forum channel
+   * @property {DefaultReactionEmoji} [defaultReactionEmoji] The emoji to set as the default reaction emoji
+   * @property {number} [defaultThreadRateLimitPerUser] The rate limit per user (slowmode) to set on forum posts
    * @property {string} [reason] Reason for editing this channel
    */
 
@@ -274,6 +278,11 @@ class GuildChannelManager extends CachedManager {
         rate_limit_per_user: data.rateLimitPerUser,
         default_auto_archive_duration: data.defaultAutoArchiveDuration,
         permission_overwrites,
+        available_tags: data.availableTags?.map(availableTag => transformGuildForumTag(availableTag)),
+        default_reaction_emoji: data.defaultReactionEmoji
+          ? transformGuildDefaultReaction(data.defaultReactionEmoji)
+          : undefined,
+        default_thread_rate_limit_per_user: data.defaultThreadRateLimitPerUser,
       },
       reason: data.reason,
     });
@@ -418,7 +427,7 @@ class GuildChannelManager extends CachedManager {
    */
   async fetchActiveThreads(cache = true) {
     const raw = await this.client.rest.get(Routes.guildActiveThreads(this.guild.id));
-    return ThreadManager._mapThreads(raw, this.client, { guild: this.guild, cache });
+    return GuildTextThreadManager._mapThreads(raw, this.client, { guild: this.guild, cache });
   }
 
   /**

packages/discord.js/src/managers/GuildForumThreadManager.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const { Routes } = require('discord-api-types/v10');
+const ThreadManager = require('./ThreadManager');
+const { TypeError, ErrorCodes } = require('../errors');
+const MessagePayload = require('../structures/MessagePayload');
+
+/**
+ * Manages API methods for threads in forum channels and stores their cache.
+ * @extends {ThreadManager}
+ */
+class GuildForumThreadManager extends ThreadManager {
+  /**
+   * @typedef {BaseMessageOptions} GuildForumThreadCreateOptions
+   * @property {stickers} [stickers] The stickers to send with the message
+   * @property {BitFieldResolvable} [flags] The flags to send with the message
+   */
+
+  /**
+   * Options for creating a thread.
+   * @typedef {StartThreadOptions} GuildForumThreadCreateOptions
+   * @property {GuildForumThreadCreateOptions|MessagePayload} message The message associated with the thread post
+   * @property {Snowflake[]} [appliedTags] The tags to apply to the thread
+   */
+
+  /**
+   * Creates a new thread in the channel.
+   * @param {GuildForumThreadCreateOptions} [options] Options to create a new thread
+   * @returns {Promise<ThreadChannel>}
+   * @example
+   * // Create a new forum post
+   * forum.threads
+   *   .create({
+   *     name: 'Food Talk',
+   *     autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
+   *     message: {
+   *      content: 'Discuss your favorite food!',
+   *     },
+   *     reason: 'Needed a separate thread for food',
+   *   })
+   *   .then(threadChannel => console.log(threadChannel))
+   *   .catch(console.error);
+   */
+  async create({
+    name,
+    autoArchiveDuration = this.channel.defaultAutoArchiveDuration,
+    message,
+    reason,
+    rateLimitPerUser,
+    appliedTags,
+  } = {}) {
+    if (!message) {
+      throw new TypeError(ErrorCodes.GuildForumMessageRequired);
+    }
+
+    const messagePayload =
+      message instanceof MessagePayload ? message.resolveBody() : MessagePayload.create(this, message).resolveBody();
+
+    const { body, files } = await messagePayload.resolveFiles();
+
+    const data = await this.client.rest.post(Routes.threads(this.channel.id), {
+      body: {
+        name,
+        auto_archive_duration: autoArchiveDuration,
+        rate_limit_per_user: rateLimitPerUser,
+        applied_tags: appliedTags,
+        message: body,
+      },
+      files,
+      reason,
+    });
+
+    return this.client.actions.ThreadCreate.handle(data).thread;
+  }
+}
+
+module.exports = GuildForumThreadManager;

packages/discord.js/src/managers/GuildTextThreadManager.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const { ChannelType, Routes } = require('discord-api-types/v10');
+const ThreadManager = require('./ThreadManager');
+const { ErrorCodes, TypeError } = require('../errors');
+
+/**
+ * Manages API methods for {@link ThreadChannel} objects and stores their cache.
+ * @extends {CachedManager}
+ */
+class GuildTextThreadManager extends ThreadManager {
+  /**
+   * 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 the `type` of thread gets inferred automatically and cannot be changed.</warn>
+   * @property {ThreadChannelTypes|number} [type] The type of thread to create.
+   * Defaults to {@link ChannelType.GuildPublicThread} if created in a {@link TextChannel}
+   * <warn>When creating threads in a {@link NewsChannel} this is ignored and is always
+   * {@link ChannelType.GuildNewsThread}</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.GuildPrivateThread}</info>
+   */
+
+  /**
+   * Creates a new thread in the channel.
+   * @param {ThreadCreateOptions} [options] Options to create a new thread
+   * @returns {Promise<ThreadChannel>}
+   * @example
+   * // Create a new public thread
+   * channel.threads
+   *   .create({
+   *     name: 'food-talk',
+   *     autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
+   *     reason: 'Needed a separate thread for food',
+   *   })
+   *   .then(threadChannel => console.log(threadChannel))
+   *   .catch(console.error);
+   * @example
+   * // Create a new private thread
+   * channel.threads
+   *   .create({
+   *      name: 'mod-talk',
+   *      autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
+   *      type: ChannelType.GuildPrivateThread,
+   *      reason: 'Needed a separate thread for moderation',
+   *    })
+   *   .then(threadChannel => console.log(threadChannel))
+   *   .catch(console.error);
+   */
+  async create({
+    name,
+    autoArchiveDuration = this.channel.defaultAutoArchiveDuration,
+    startMessage,
+    type,
+    invitable,
+    reason,
+    rateLimitPerUser,
+  } = {}) {
+    if (type && typeof type !== 'string' && typeof type !== 'number') {
+      throw new TypeError(ErrorCodes.InvalidType, 'type', 'ThreadChannelType or Number');
+    }
+    let resolvedType =
+      this.channel.type === ChannelType.GuildNews ? ChannelType.GuildNewsThread : ChannelType.GuildPublicThread;
+    let startMessageId;
+    if (startMessage) {
+      startMessageId = this.channel.messages.resolveId(startMessage);
+      if (!startMessageId) throw new TypeError(ErrorCodes.InvalidType, 'startMessage', 'MessageResolvable');
+    } else if (this.channel.type !== ChannelType.GuildNews) {
+      resolvedType = type ?? resolvedType;
+    }
+
+    const data = await this.client.rest.post(Routes.threads(this.channel.id, startMessageId), {
+      body: {
+        name,
+        auto_archive_duration: autoArchiveDuration,
+        type: resolvedType,
+        invitable: resolvedType === ChannelType.GuildPrivateThread ? invitable : undefined,
+        rate_limit_per_user: rateLimitPerUser,
+      },
+      reason,
+    });
+
+    return this.client.actions.ThreadCreate.handle(data).thread;
+  }
+}
+
+module.exports = GuildTextThreadManager;

packages/discord.js/src/managers/ThreadManager.js

@@ -2,13 +2,13 @@
 
 const { Collection } = require('@discordjs/collection');
 const { makeURLSearchParams } = require('@discordjs/rest');
-const { ChannelType, Routes } = require('discord-api-types/v10');
+const { Routes } = require('discord-api-types/v10');
 const CachedManager = require('./CachedManager');
 const { TypeError, ErrorCodes } = require('../errors');
 const ThreadChannel = require('../structures/ThreadChannel');
 
 /**
- * Manages API methods for {@link ThreadChannel} objects and stores their cache.
+ * Manages API methods for thread-based channels and stores their cache.
  * @extends {CachedManager}
  */
 class ThreadManager extends CachedManager {
@@ -17,11 +17,18 @@ class ThreadManager extends CachedManager {
 
     /**
      * The channel this Manager belongs to
-     * @type {NewsChannel|TextChannel}
+     * @type {NewsChannel|TextChannel|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>}
@@ -35,13 +42,6 @@ class ThreadManager extends CachedManager {
     return thread;
   }
 
-  /**
-   * Data that can be resolved to a Thread Channel object. This can be:
-   * * A ThreadChannel object
-   * * A Snowflake
-   * @typedef {ThreadChannel|Snowflake} ThreadChannelResolvable
-   */
-
   /**
    * Resolves a {@link ThreadChannelResolvable} to a {@link ThreadChannel} object.
    * @method resolve
@@ -74,68 +74,6 @@ class ThreadManager extends CachedManager {
    * <info>Can only be set when type will be {@link ChannelType.PrivateThread}</info>
    */
 
-  /**
-   * Creates a new thread in the channel.
-   * @param {ThreadCreateOptions} [options] Options to create a new thread
-   * @returns {Promise<ThreadChannel>}
-   * @example
-   * // Create a new public thread
-   * channel.threads
-   *   .create({
-   *     name: 'food-talk',
-   *     autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
-   *     reason: 'Needed a separate thread for food',
-   *   })
-   *   .then(threadChannel => console.log(threadChannel))
-   *   .catch(console.error);
-   * @example
-   * // Create a new private thread
-   * channel.threads
-   *   .create({
-   *      name: 'mod-talk',
-   *      autoArchiveDuration: ThreadAutoArchiveDuration.OneHour,
-   *      type: ChannelType.PrivateThread,
-   *      reason: 'Needed a separate thread for moderation',
-   *    })
-   *   .then(threadChannel => console.log(threadChannel))
-   *   .catch(console.error);
-   */
-  async create({
-    name,
-    autoArchiveDuration = this.channel.defaultAutoArchiveDuration,
-    startMessage,
-    type,
-    invitable,
-    reason,
-    rateLimitPerUser,
-  } = {}) {
-    if (type && typeof type !== 'string' && typeof type !== 'number') {
-      throw new TypeError(ErrorCodes.InvalidType, 'type', 'ThreadChannelType or Number');
-    }
-    let resolvedType =
-      this.channel.type === ChannelType.GuildAnnouncement ? ChannelType.AnnouncementThread : ChannelType.PublicThread;
-    let startMessageId;
-    if (startMessage) {
-      startMessageId = this.channel.messages.resolveId(startMessage);
-      if (!startMessageId) throw new TypeError(ErrorCodes.InvalidType, 'startMessage', 'MessageResolvable');
-    } else if (this.channel.type !== ChannelType.GuildAnnouncement) {
-      resolvedType = type ?? resolvedType;
-    }
-
-    const data = await this.client.rest.post(Routes.threads(this.channel.id, startMessageId), {
-      body: {
-        name,
-        auto_archive_duration: autoArchiveDuration,
-        type: resolvedType,
-        invitable: resolvedType === ChannelType.PrivateThread ? invitable : undefined,
-        rate_limit_per_user: rateLimitPerUser,
-      },
-      reason,
-    });
-
-    return this.client.actions.ThreadCreate.handle(data).thread;
-  }
-
   /**
    * The options for fetching multiple threads, the properties are mutually exclusive
    * @typedef {Object} FetchThreadsOptions