refactor: switch api and gateway to V8

src/client/Client.js

@@ -29,9 +29,9 @@ const Structures = require('../util/Structures');
  */
 class Client extends BaseClient {
   /**
-   * @param {ClientOptions} [options] Options for the client
+   * @param {ClientOptions} options Options for the client
    */
-  constructor(options = {}) {
+  constructor(options) {
     super(Object.assign({ _tokenType: 'Bot' }, options));
 
     // Obtain shard details from environment or if present, worker threads
@@ -444,8 +444,10 @@ class Client extends BaseClient {
    * @private
    */
   _validateOptions(options = this.options) {
-    if (typeof options.ws.intents !== 'undefined') {
-      options.ws.intents = Intents.resolve(options.ws.intents);
+    if (typeof options.intents === 'undefined') {
+      throw new TypeError('CLIENT_MISSING_INTENTS');
+    } else {
+      options.intents = Intents.resolve(options.intents);
     }
     if (typeof options.shardCount !== 'number' || isNaN(options.shardCount) || options.shardCount < 1) {
       throw new TypeError('CLIENT_INVALID_OPTION', 'shardCount', 'a number greater than or equal to 1');

src/client/actions/ChannelCreate.js

@@ -10,9 +10,9 @@ class ChannelCreateAction extends Action {
     const channel = client.channels.add(data);
     if (!existing && channel) {
       /**
-       * Emitted whenever a channel is created.
+       * Emitted whenever a guild channel is created.
        * @event Client#channelCreate
-       * @param {DMChannel|GuildChannel} channel The channel that was created
+       * @param {GuildChannel} channel The channel that was created
        */
       client.emit(Events.CHANNEL_CREATE, channel);
     }

src/client/actions/MessageCreate.js

@@ -6,7 +6,7 @@ const { Events } = require('../../util/Constants');
 class MessageCreateAction extends Action {
   handle(data) {
     const client = this.client;
-    const channel = client.channels.cache.get(data.channel_id);
+    const channel = this.getChannel(data);
     if (channel) {
       const existing = channel.messages.cache.get(data.id);
       if (existing) return { message: existing };

src/client/actions/PresenceUpdate.js

@@ -22,7 +22,6 @@ class PresenceUpdateAction extends Action {
     if (!member && data.status !== 'offline') {
       member = guild.members.add({
         user,
-        roles: data.roles,
         deaf: false,
         mute: false,
       });

src/client/websocket/WebSocketShard.js

@@ -3,6 +3,7 @@
 const EventEmitter = require('events');
 const WebSocket = require('../../WebSocket');
 const { Status, Events, ShardEvents, OPCodes, WSEvents } = require('../../util/Constants');
+const Intents = require('../../util/Intents');
 
 const STATUS_KEYS = Object.keys(Status);
 const CONNECTION_STATE = Object.keys(WebSocket.WebSocket);
@@ -594,6 +595,7 @@ class WebSocketShard extends EventEmitter {
     // Clone the identify payload and assign the token and shard info
     const d = {
       ...client.options.ws,
+      intents: Intents.resolve(client.options.intents),
       token: client.token,
       shard: [this.id, Number(client.options.shardCount)],
     };

src/errors/Messages.js

@@ -5,6 +5,7 @@ const { register } = require('./DJSError');
 const Messages = {
   CLIENT_INVALID_OPTION: (prop, must) => `The ${prop} option must be ${must}`,
   CLIENT_INVALID_PROVIDED_SHARDS: 'None of the provided shards were valid.',
+  CLIENT_MISSING_INTENTS: 'Valid intents must be provided for the Client.',
 
   TOKEN_INVALID: 'An invalid token was provided.',
   TOKEN_MISSING: 'Request to use token, but token was unavailable to the client.',

src/managers/GuildManager.js

@@ -53,7 +53,7 @@ class GuildManager extends BaseManager {
    * @property {ColorResolvable} [color] The color of the role, either a hex string or a base 10 number
    * @property {boolean} [hoist] Whether or not the role should be hoisted
    * @property {number} [position] The position of the role
-   * @property {PermissionResolvable|number} [permissions] The permissions of the role
+   * @property {PermissionResolvable} [permissions] The permissions of the role
    * @property {boolean} [mentionable] Whether or not the role should be mentionable
    */
 

src/managers/RoleManager.js

@@ -115,7 +115,7 @@ class RoleManager extends BaseManager {
   create(options = {}) {
     let { name, color, hoist, permissions, position, mentionable, reason } = options;
     if (color) color = resolveColor(color);
-    if (permissions) permissions = Permissions.resolve(permissions);
+    if (permissions) permissions = Permissions.resolve(permissions).toString();
 
     return this.client.api
       .guilds(this.guild.id)

src/rest/RequestHandler.js

@@ -105,7 +105,7 @@ class RequestHandler {
       this.limit = limit ? Number(limit) : Infinity;
       this.remaining = remaining ? Number(remaining) : 1;
       this.reset = reset ? calculateReset(reset, serverDate) : Date.now();
-      this.retryAfter = retryAfter ? Number(retryAfter) : -1;
+      this.retryAfter = retryAfter ? Number(retryAfter) * 1000 : -1;
 
       // https://github.com/discordapp/discord-api-docs/issues/182
       if (request.route.includes('reactions')) {

src/structures/ClientPresence.js

@@ -2,7 +2,6 @@
 
 const { Presence } = require('./Presence');
 const { TypeError } = require('../errors');
-const Collection = require('../util/Collection');
 const { ActivityTypes, OPCodes } = require('../util/Constants');
 
 class ClientPresence extends Presence {
@@ -14,8 +13,8 @@ class ClientPresence extends Presence {
     super(client, Object.assign(data, { status: data.status || 'online', user: { id: null } }));
   }
 
-  async set(presence) {
-    const packet = await this._parse(presence);
+  set(presence) {
+    const packet = this._parse(presence);
     this.patch(packet);
     if (typeof presence.shardID === 'undefined') {
       this.client.ws.broadcast({ op: OPCodes.STATUS_UPDATE, d: packet });
@@ -29,58 +28,33 @@ class ClientPresence extends Presence {
     return this;
   }
 
-  async _parse({ status, since, afk, activity }) {
-    const applicationID = activity && (activity.application ? activity.application.id || activity.application : null);
-    let assets = new Collection();
-    if (activity) {
-      if (typeof activity.name !== 'string') throw new TypeError('INVALID_TYPE', 'name', 'string');
-      if (!activity.type) activity.type = 0;
-      if (activity.assets && applicationID) {
-        try {
-          const a = await this.client.api.oauth2.applications(applicationID).assets.get();
-          for (const asset of a) assets.set(asset.name, asset.id);
-        } catch {} // eslint-disable-line no-empty
-      }
-    }
-
-    const packet = {
-      afk: afk != null ? afk : false, // eslint-disable-line eqeqeq
-      since: since != null ? since : null, // eslint-disable-line eqeqeq
+  _parse({ status, since, afk, activities }) {
+    const data = {
+      activities: [],
+      afk: typeof afk === 'boolean' ? afk : false,
+      since: typeof since === 'number' && !Number.isNaN(since) ? since : null,
       status: status || this.status,
-      game: activity
-        ? {
-            type: activity.type,
-            name: activity.name,
-            url: activity.url,
-            details: activity.details || undefined,
-            state: activity.state || undefined,
-            assets: activity.assets
-              ? {
-                  large_text: activity.assets.largeText || undefined,
-                  small_text: activity.assets.smallText || undefined,
-                  large_image: assets.get(activity.assets.largeImage) || activity.assets.largeImage,
-                  small_image: assets.get(activity.assets.smallImage) || activity.assets.smallImage,
-                }
-              : undefined,
-            timestamps: activity.timestamps || undefined,
-            party: activity.party || undefined,
-            application_id: applicationID || undefined,
-            secrets: activity.secrets || undefined,
-            instance: activity.instance || undefined,
-          }
-        : null,
     };
-
-    if ((status || afk || since) && !activity) {
-      packet.game = this.activities[0] || null;
+    if (activities === null) {
+      data.activities = null;
+      return data;
     }
-
-    if (packet.game) {
-      packet.game.type =
-        typeof packet.game.type === 'number' ? packet.game.type : ActivityTypes.indexOf(packet.game.type);
+    if (activities && activities.length) {
+      for (const [i, activity] of activities.entries()) {
+        if (typeof activity.name !== 'string') throw new TypeError('INVALID_TYPE', `activities[${i}].name`, 'string');
+        if (!activity.type) activity.type = 0;
+
+        data.activities.push({
+          type: typeof activity.type === 'number' ? activity.type : ActivityTypes.indexOf(activity.type),
+          name: activity.name,
+          url: activity.url,
+        });
+      }
+    } else if ((status || afk || since) && this.activities.length) {
+      data.activities.push(...this.activities);
     }
 
-    return packet;
+    return data;
   }
 }
 

src/structures/ClientUser.js

@@ -46,16 +46,18 @@ class ClientUser extends Structures.get('User') {
     return this.client.presence;
   }
 
-  edit(data) {
-    return this.client.api
-      .users('@me')
-      .patch({ data })
-      .then(newData => {
-        this.client.token = newData.token;
-        const { updated } = this.client.actions.UserUpdate.handle(newData);
-        if (updated) return updated;
-        return this;
-      });
+  /**
+   * Edits the logged in client.
+   * @param {Object} data The new data
+   * @param {string} [data.username] The new username
+   * @param {BufferResolvable|Base64Resolvable} [data.avatar] The new avatar
+   */
+  async edit(data) {
+    const newData = await this.client.api.users('@me').patch({ data });
+    this.client.token = newData.token;
+    const { updated } = this.client.actions.UserUpdate.handle(newData);
+    if (updated) return updated;
+    return this;
   }
 
   /**
@@ -103,7 +105,7 @@ class ClientUser extends Structures.get('User') {
   /**
    * Sets the full presence of the client user.
    * @param {PresenceData} data Data for the presence
-   * @returns {Promise<Presence>}
+   * @returns {Presence}
    * @example
    * // Set the client user's presence
    * client.user.setPresence({ activity: { name: 'with discord.js' }, status: 'idle' })
@@ -127,7 +129,7 @@ class ClientUser extends Structures.get('User') {
    * Sets the status of the client user.
    * @param {PresenceStatusData} status Status to change to
    * @param {?number|number[]} [shardID] Shard ID(s) to have the activity set on
-   * @returns {Promise<Presence>}
+   * @returns {Presence}
    * @example
    * // Set the client user's status
    * client.user.setStatus('idle')
@@ -144,34 +146,35 @@ class ClientUser extends Structures.get('User') {
    * @type {Object}
    * @property {string} [url] Twitch / YouTube stream URL
    * @property {ActivityType|number} [type] Type of the activity
-   * @property {?number|number[]} [shardID] Shard Id(s) to have the activity set on
+   * @property {number|number[]} [shardID] Shard Id(s) to have the activity set on
    */
 
   /**
    * Sets the activity the client user is playing.
    * @param {string|ActivityOptions} [name] Activity being played, or options for setting the activity
    * @param {ActivityOptions} [options] Options for setting the activity
-   * @returns {Promise<Presence>}
+   * @returns {Presence}
    * @example
    * // Set the client user's activity
    * client.user.setActivity('discord.js', { type: 'WATCHING' })
    *   .then(presence => console.log(`Activity set to ${presence.activities[0].name}`))
    *   .catch(console.error);
    */
   setActivity(name, options = {}) {
-    if (!name) return this.setPresence({ activity: null, shardID: options.shardID });
+    if (!name) return this.setPresence({ activities: null, shardID: options.shardID });
 
     const activity = Object.assign({}, options, typeof name === 'object' ? name : { name });
-    return this.setPresence({ activity, shardID: activity.shardID });
+    return this.setPresence({ activities: [activity], shardID: activity.shardID });
   }
 
   /**
    * Sets/removes the AFK flag for the client user.
    * @param {boolean} afk Whether or not the user is AFK
-   * @returns {Promise<Presence>}
+   * @param {number|number[]} [shardID] Shard Id(s) to have the AFK flag set on
+   * @returns {Presence}
    */
-  setAFK(afk) {
-    return this.setPresence({ afk });
+  setAFK(afk, shardID) {
+    return this.setPresence({ afk, shardID });
   }
 }