feat(MessageManager): extend API coverage

src/managers/MessageManager.js

@@ -2,6 +2,7 @@
 
 const BaseManager = require('./BaseManager');
 const { TypeError } = require('../errors');
+const APIMessage = require('../structures/APIMessage');
 const Message = require('../structures/Message');
 const Collection = require('../util/Collection');
 const LimitedCollection = require('../util/LimitedCollection');
@@ -113,6 +114,95 @@ class MessageManager extends BaseManager {
    * @returns {?Snowflake}
    */
 
+  /**
+   * Edits a message, even if it's not cached.
+   * @param {MessageResolvable} message The message to edit
+   * @param {StringResolvable|APIMessage} [content] The new content for the message
+   * @param {MessageEditOptions|MessageEmbed} [options] The options to provide
+   * @returns {Promise<void>}
+   */
+  async edit(message, content, options) {
+    message = this.resolveID(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+    const { data } =
+      content instanceof APIMessage ? content.resolveData() : APIMessage.create(this, content, options).resolveData();
+    await this.client.api
+      .channels(this.channel.id)
+      .messages(message)
+      .patch({ data })
+      .then(d => {
+        if (this.cache.has(message)) {
+          const clone = this.cache.get(message)._clone();
+          clone._patch(d);
+        }
+      });
+  }
+
+  /**
+   * Publishes a message in an announcement channel to all channels following it, even if it's not cached.
+   * @param {MessageResolvable} message The message to publish
+   * @returns {Promise<void>}
+   */
+  async crosspost(message) {
+    message = this.resolveID(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    await this.client.api.channels(this.channel.id).messages(message).crosspost.post();
+  }
+
+  /**
+   * Pins a message to the channel's pinned messages, even if it's not cached.
+   * @param {MessageResolvable} message The message to pin
+   * @param {Object} [options] Options for pinning
+   * @param {string} [options.reason] Reason for pinning
+   * @returns {Promise<void>}
+   */
+  async pin(message, options) {
+    message = this.resolveID(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    await this.client.api
+      .channels(this.channel.id)
+      .pins(message)
+      .put(options)
+      .then(() => this);
+  }
+
+  /**
+   * Unins a message from the channel's pinned messages, even if it's not cached.
+   * @param {MessageResolvable} message The message to unpin
+   * @param {Object} [options] Options for unpinning
+   * @param {string} [options.reason] Reason for unpinning
+   * @returns {Promise<void>}
+   */
+  async unpin(message, options) {
+    message = this.resolveID(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    await this.client.api
+      .channels(this.channel.id)
+      .pins(message)
+      .delete(options)
+      .then(() => this);
+  }
+
+  /**
+   * Adds a reaction to the message, even if it's not cached.
+   * @param {MessageResolvable} message The messag to react to
+   * @param {EmojiIdentifierResolvable} emoji The emoji to react with
+   * @returns {Promise<void>}
+   */
+  async react(message, emoji) {
+    message = this.resolveID(message);
+    if (!message) throw new TypeError('INVALID_TYPE', 'message', 'MessageResolvable');
+
+    emoji = this.client.emojis.resolveIdentifier(emoji);
+    if (!emoji) throw new TypeError('EMOJI_TYPE', 'emoji', 'EmojiIdentifierResolvable');
+
+    // eslint-disable-next-line newline-per-chained-call
+    await this.client.api.channels(this.channel.id).messages(message).reactions(emoji, '@me').put();
+  }
+
   /**
    * Deletes a message, even if it's not cached.
    * @param {MessageResolvable} message The message to delete

src/structures/Message.js

@@ -419,7 +419,7 @@ class Message extends Base {
   }
 
   /**
-   * Options that can be passed into editMessage.
+   * Options that can be passed into Message#edit.
    * @typedef {Object} MessageEditOptions
    * @property {string} [content] Content to be edited
    * @property {MessageEmbed|Object} [embed] An embed to be added/edited
@@ -439,13 +439,7 @@ class Message extends Base {
    *   .catch(console.error);
    */
   edit(content, options) {
-    const { data } =
-      content instanceof APIMessage ? content.resolveData() : APIMessage.create(this, content, options).resolveData();
-    return this.client.api.channels[this.channel.id].messages[this.id].patch({ data }).then(d => {
-      const clone = this._clone();
-      clone._patch(d);
-      return clone;
-    });
+    return this.channel.messages.edit(this.id, content, options).then(() => this);
   }
 
   /**
@@ -459,9 +453,8 @@ class Message extends Base {
    *     .catch(console.error);
    * }
    */
-  async crosspost() {
-    await this.client.api.channels(this.channel.id).messages(this.id).crosspost.post();
-    return this;
+  crosspost() {
+    return this.channel.messages.crosspost(this.id).then(() => this);
   }
 
   /**
@@ -476,11 +469,7 @@ class Message extends Base {
    *   .catch(console.error)
    */
   pin(options) {
-    return this.client.api
-      .channels(this.channel.id)
-      .pins(this.id)
-      .put(options)
-      .then(() => this);
+    return this.channel.messages.pin(this.id, options).then(() => this);
   }
 
   /**
@@ -495,11 +484,7 @@ class Message extends Base {
    *   .catch(console.error)
    */
   unpin(options) {
-    return this.client.api
-      .channels(this.channel.id)
-      .pins(this.id)
-      .delete(options)
-      .then(() => this);
+    return this.channel.messages.unpin(this.id, options).then(() => this);
   }
 
   /**
@@ -518,23 +503,15 @@ class Message extends Base {
    *   .catch(console.error);
    */
   react(emoji) {
-    emoji = this.client.emojis.resolveIdentifier(emoji);
-    if (!emoji) throw new TypeError('EMOJI_TYPE');
-
-    return this.client.api
-      .channels(this.channel.id)
-      .messages(this.id)
-      .reactions(emoji, '@me')
-      .put()
-      .then(
-        () =>
-          this.client.actions.MessageReactionAdd.handle({
-            user: this.client.user,
-            channel: this.channel,
-            message: this,
-            emoji: Util.parseEmoji(emoji),
-          }).reaction,
-      );
+    return this.channel.messages.react(this.id, emoji).then(
+      () =>
+        this.client.actions.MessageReactionAdd.handle({
+          user: this.client.user,
+          channel: this.channel,
+          message: this,
+          emoji: Util.parseEmoji(emoji),
+        }).reaction,
+    );
   }
 
   /**

typings/index.d.ts

@@ -1982,14 +1982,27 @@ declare module 'discord.js' {
     constructor(channel: TextChannel | DMChannel, iterable?: Iterable<any>);
     public channel: TextBasedChannelFields;
     public cache: Collection<Snowflake, Message>;
+    public crosspost(message: MessageResolvable): Promise<void>;
+    public delete(message: MessageResolvable, reason?: string): Promise<void>;
+    public edit(
+      message: MessageResolvable,
+      content: APIMessageContentResolvable | MessageEditOptions | MessageEmbed | APIMessage,
+    ): Promise<void>;
+    public edit(
+      message: MessageResolvable,
+      content: StringResolvable,
+      options: MessageEditOptions | MessageEmbed,
+    ): Promise<void>;
     public fetch(message: Snowflake, cache?: boolean, force?: boolean): Promise<Message>;
     public fetch(
       options?: ChannelLogsQueryOptions,
       cache?: boolean,
       force?: boolean,
     ): Promise<Collection<Snowflake, Message>>;
     public fetchPinned(cache?: boolean): Promise<Collection<Snowflake, Message>>;
-    public delete(message: MessageResolvable, reason?: string): Promise<void>;
+    public react(message: MessageResolvable, emoji: EmojiIdentifierResolvable): Promise<void>;
+    public pin(message: MessageResolvable, options?: { reason?: string }): Promise<void>;
+    public unpin(message: MessageResolvable, options?: { reason?: string }): Promise<void>;
   }
 
   // Hacky workaround because changing the signature of an overridden method errors