discord-sb.js 1.0.0

package/src/structures/GuildBan.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const Base = require('./Base');
+
+/**
+ * Represents a ban in a guild on Discord.
+ * @extends {Base}
+ */
+class GuildBan extends Base {
+  constructor(client, data, guild) {
+    super(client);
+
+    /**
+     * The guild in which the ban is
+     * @type {Guild}
+     */
+    this.guild = guild;
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    if ('user' in data) {
+      /**
+       * The user this ban applies to
+       * @type {User}
+       */
+      this.user = this.client.users._add(data.user, true);
+    }
+
+    if ('reason' in data) {
+      /**
+       * The reason for the ban
+       * @type {?string}
+       */
+      this.reason = data.reason;
+    }
+  }
+
+  /**
+   * Whether this GuildBan is partial. If the reason is not provided the value is null
+   * @type {boolean}
+   * @readonly
+   */
+  get partial() {
+    return !('reason' in this);
+  }
+
+  /**
+   * Fetches this GuildBan.
+   * @param {boolean} [force=true] Whether to skip the cache check and request the API
+   * @returns {Promise<GuildBan>}
+   */
+  fetch(force = true) {
+    return this.guild.bans.fetch({ user: this.user, cache: true, force });
+  }
+}
+
+module.exports = GuildBan;

package/src/structures/GuildBoost.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const Base = require('./Base');
+
+/**
+ * Represents a guild boost in a guild on Discord.
+ * @extends {Base}
+ */
+class GuildBoost extends Base {
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+
+  _patch(data) {
+    if ('id' in data) {
+      /**
+       * The id of the guild boost
+       * @type {Snowflake}
+       */
+      this.id = data.id;
+    }
+    if ('subscription_id' in data) {
+      /**
+       * The id of the subscription
+       * @type {Snowflake}
+       */
+      this.subscriptionId = data.subscription_id;
+    }
+    if (typeof data.premium_guild_subscription === 'object' && data.premium_guild_subscription !== null) {
+      /**
+       * The premium guild subscription id
+       * @type {?Snowflake}
+       */
+      this.premiumGuildSubscriptionId = data.premium_guild_subscription.id;
+      /**
+       * Guild id
+       * @type {?Snowflake}
+       */
+      this.guildId = data.premium_guild_subscription.guild_id;
+      /**
+       * Ended ???
+       * @type {?boolean}
+       */
+      this.ended = data.premium_guild_subscription.ended;
+    }
+    if ('canceled' in data) {
+      /**
+       * Whether the subscription is canceled
+       * @type {boolean}
+       */
+      this.canceled = data.canceled;
+    }
+    if ('cooldown_ends_at' in data) {
+      /**
+       * The cooldown end date
+       * @type {Date}
+       */
+      this.cooldownEndsAt = new Date(data.cooldown_ends_at);
+    }
+  }
+  /**
+   * The guild of the boost
+   * @type {?Guild}
+   * @readonly
+   */
+  get guilld() {
+    return this.client.guilds.cache.get(this.guildId);
+  }
+
+  /**
+   * Cancel the boost
+   * @returns {Promise<GuildBoost>}
+   */
+  async unsubscribe() {
+    // https://discord.com/api/v9/guilds/:id/premium/subscriptions/:id
+    if (!this.guildId) throw new Error('BOOST_UNUSED');
+    if (!this.premiumGuildSubscriptionId) throw new Error('BOOST_UNCACHED');
+    await this.client.api.guilds(this.guildId).premium.subscriptions(this.premiumGuildSubscriptionId).delete();
+    this.guildId = null;
+    this.premiumGuildSubscriptionId = null;
+    this.ended = null;
+    return this;
+  }
+
+  /**
+   * Use the boost
+   * @param {GuildResolvable} guild The guild to use the boost on
+   * @returns {Promise<GuildBoost>}
+   */
+  async subscribe(guild) {
+    // https://discord.com/api/v9/guilds/:id/premium/subscriptions
+    if (this.guildId || this.premiumGuildSubscriptionId) throw new Error('BOOST_USED');
+    const id = this.client.guilds.resolveId(guild);
+    if (!id) throw new Error('UNKNOWN_GUILD');
+    const d = await this.client.api.guilds(id).premium.subscriptions.put({
+      data: {
+        user_premium_guild_subscription_slot_ids: [this.id],
+      },
+    });
+    this._patch({
+      premium_guild_subscription: d,
+    });
+    return this;
+  }
+}
+
+module.exports = GuildBoost;

package/src/structures/GuildChannel.js

@@ -0,0 +1,470 @@
+'use strict';
+
+const { Channel } = require('./Channel');
+const { Error } = require('../errors');
+const PermissionOverwriteManager = require('../managers/PermissionOverwriteManager');
+const { VoiceBasedChannelTypes } = require('../util/Constants');
+const Permissions = require('../util/Permissions');
+const Util = require('../util/Util');
+
+/**
+ * Represents a guild channel from any of the following:
+ * - {@link TextChannel}
+ * - {@link VoiceChannel}
+ * - {@link CategoryChannel}
+ * - {@link NewsChannel}
+ * - {@link StoreChannel}
+ * - {@link StageChannel}
+ * - {@link ForumChannel}
+ * - {@link MediaChannel}
+ * @extends {Channel}
+ * @abstract
+ */
+class GuildChannel extends Channel {
+  constructor(guild, data, client, immediatePatch = true) {
+    super(guild?.client ?? client, data, false);
+
+    /**
+     * The guild the channel is in
+     * @type {Guild}
+     */
+    this.guild = guild;
+
+    /**
+     * The id of the guild the channel is in
+     * @type {Snowflake}
+     */
+    this.guildId = guild?.id ?? data.guild_id;
+
+    this.parentId = this.parentId ?? null;
+    /**
+     * A manager of permission overwrites that belong to this channel
+     * @type {PermissionOverwriteManager}
+     */
+    this.permissionOverwrites = new PermissionOverwriteManager(this);
+
+    if (data && immediatePatch) this._patch(data);
+  }
+
+  _patch(data) {
+    super._patch(data);
+
+    if ('name' in data) {
+      /**
+       * The name of the guild channel
+       * @type {string}
+       */
+      this.name = data.name;
+    }
+
+    if ('position' in data) {
+      /**
+       * The raw position of the channel from Discord
+       * @type {number}
+       */
+      this.rawPosition = data.position;
+    }
+
+    if ('guild_id' in data) {
+      this.guildId = data.guild_id;
+    }
+
+    if ('parent_id' in data) {
+      /**
+       * The id of the category parent of this channel
+       * @type {?Snowflake}
+       */
+      this.parentId = data.parent_id;
+    }
+
+    if ('permission_overwrites' in data) {
+      this.permissionOverwrites.cache.clear();
+      for (const overwrite of data.permission_overwrites) {
+        this.permissionOverwrites._add(overwrite);
+      }
+    }
+  }
+
+  _clone() {
+    const clone = super._clone();
+    clone.permissionOverwrites = new PermissionOverwriteManager(clone, this.permissionOverwrites.cache.values());
+    return clone;
+  }
+
+  /**
+   * The category parent of this channel
+   * @type {?CategoryChannel}
+   * @readonly
+   */
+  get parent() {
+    return this.guild.channels.resolve(this.parentId);
+  }
+
+  /**
+   * If the permissionOverwrites match the parent channel, null if no parent
+   * @type {?boolean}
+   * @readonly
+   */
+  get permissionsLocked() {
+    if (!this.parent) return null;
+
+    // Get all overwrites
+    const overwriteIds = new Set([
+      ...this.permissionOverwrites.cache.keys(),
+      ...this.parent.permissionOverwrites.cache.keys(),
+    ]);
+
+    // Compare all overwrites
+    return [...overwriteIds].every(key => {
+      const channelVal = this.permissionOverwrites.cache.get(key);
+      const parentVal = this.parent.permissionOverwrites.cache.get(key);
+
+      // Handle empty overwrite
+      if (
+        (!channelVal &&
+          parentVal.deny.bitfield === Permissions.defaultBit &&
+          parentVal.allow.bitfield === Permissions.defaultBit) ||
+        (!parentVal &&
+          channelVal.deny.bitfield === Permissions.defaultBit &&
+          channelVal.allow.bitfield === Permissions.defaultBit)
+      ) {
+        return true;
+      }
+
+      // Compare overwrites
+      return (
+        typeof channelVal !== 'undefined' &&
+        typeof parentVal !== 'undefined' &&
+        channelVal.deny.bitfield === parentVal.deny.bitfield &&
+        channelVal.allow.bitfield === parentVal.allow.bitfield
+      );
+    });
+  }
+
+  /**
+   * The position of the channel
+   * @type {number}
+   * @readonly
+   */
+  get position() {
+    const selfIsCategory = this.type === 'GUILD_CATEGORY';
+    const types = Util.getSortableGroupTypes(this.type);
+
+    let count = 0;
+    for (const channel of this.guild.channels.cache.values()) {
+      if (!types.includes(channel.type)) continue;
+      if (!selfIsCategory && channel.parentId !== this.parentId) continue;
+      if (this.rawPosition === channel.rawPosition) {
+        if (BigInt(channel.id) < BigInt(this.id)) count++;
+      } else if (this.rawPosition > channel.rawPosition) {
+        count++;
+      }
+    }
+
+    return count;
+  }
+
+  /**
+   * Gets the overall set of permissions for a member or role in this channel, taking into account channel overwrites.
+   * @param {GuildMemberResolvable|RoleResolvable} memberOrRole The member or role to obtain the overall permissions for
+   * @param {boolean} [checkAdmin=true] Whether having `ADMINISTRATOR` will return all permissions
+   * @returns {?Readonly<Permissions>}
+   */
+  permissionsFor(memberOrRole, checkAdmin = true) {
+    const member = this.guild.members.resolve(memberOrRole);
+    if (member) return this.memberPermissions(member, checkAdmin);
+    const role = this.guild.roles.resolve(memberOrRole);
+    return role && this.rolePermissions(role, checkAdmin);
+  }
+
+  overwritesFor(member, verified = false, roles = null) {
+    if (!verified) member = this.guild.members.resolve(member);
+    if (!member) return [];
+
+    roles ??= member.roles.cache;
+    const roleOverwrites = [];
+    let memberOverwrites;
+    let everyoneOverwrites;
+
+    for (const overwrite of this.permissionOverwrites.cache.values()) {
+      if (overwrite.id === this.guild.id) {
+        everyoneOverwrites = overwrite;
+      } else if (roles.has(overwrite.id)) {
+        roleOverwrites.push(overwrite);
+      } else if (overwrite.id === member.id) {
+        memberOverwrites = overwrite;
+      }
+    }
+
+    return {
+      everyone: everyoneOverwrites,
+      roles: roleOverwrites,
+      member: memberOverwrites,
+    };
+  }
+
+  /**
+   * Gets the overall set of permissions for a member in this channel, taking into account channel overwrites.
+   * @param {GuildMember} member The member to obtain the overall permissions for
+   * @param {boolean} checkAdmin=true Whether having `ADMINISTRATOR` will return all permissions
+   * @returns {Readonly<Permissions>}
+   * @private
+   */
+  memberPermissions(member, checkAdmin) {
+    if (checkAdmin && member.id === this.guild.ownerId) return new Permissions(Permissions.ALL).freeze();
+
+    const roles = member.roles.cache;
+    const permissions = new Permissions(roles.map(role => role.permissions));
+
+    if (checkAdmin && permissions.has(Permissions.FLAGS.ADMINISTRATOR)) {
+      return new Permissions(Permissions.ALL).freeze();
+    }
+
+    const overwrites = this.overwritesFor(member, true, roles);
+
+    return permissions
+      .remove(overwrites.everyone?.deny ?? Permissions.defaultBit)
+      .add(overwrites.everyone?.allow ?? Permissions.defaultBit)
+      .remove(overwrites.roles.length > 0 ? overwrites.roles.map(role => role.deny) : Permissions.defaultBit)
+      .add(overwrites.roles.length > 0 ? overwrites.roles.map(role => role.allow) : Permissions.defaultBit)
+      .remove(overwrites.member?.deny ?? Permissions.defaultBit)
+      .add(overwrites.member?.allow ?? Permissions.defaultBit)
+      .freeze();
+  }
+
+  /**
+   * Gets the overall set of permissions for a role in this channel, taking into account channel overwrites.
+   * @param {Role} role The role to obtain the overall permissions for
+   * @param {boolean} checkAdmin Whether having `ADMINISTRATOR` will return all permissions
+   * @returns {Readonly<Permissions>}
+   * @private
+   */
+  rolePermissions(role, checkAdmin) {
+    if (checkAdmin && role.permissions.has(Permissions.FLAGS.ADMINISTRATOR)) {
+      return new Permissions(Permissions.ALL).freeze();
+    }
+
+    const basePermissions = new Permissions([role.permissions, role.guild.roles.everyone.permissions]);
+    const everyoneOverwrites = this.permissionOverwrites.cache.get(this.guild.id);
+    const roleOverwrites = this.permissionOverwrites.cache.get(role.id);
+
+    return basePermissions
+      .remove(everyoneOverwrites?.deny ?? Permissions.defaultBit)
+      .add(everyoneOverwrites?.allow ?? Permissions.defaultBit)
+      .remove(roleOverwrites?.deny ?? Permissions.defaultBit)
+      .add(roleOverwrites?.allow ?? Permissions.defaultBit)
+      .freeze();
+  }
+
+  /**
+   * Locks in the permission overwrites from the parent channel.
+   * @returns {Promise<GuildChannel>}
+   */
+  async lockPermissions() {
+    if (!this.parent) throw new Error('GUILD_CHANNEL_ORPHAN');
+    const permissionOverwrites = this.parent.permissionOverwrites.cache.map(overwrite => overwrite.toJSON());
+    return this.edit({ permissionOverwrites });
+  }
+
+  /**
+   * A collection of cached members of this channel, mapped by their ids.
+   * Members that can view this channel, if the channel is text-based.
+   * Members in the channel, if the channel is voice-based.
+   * @type {Collection<Snowflake, GuildMember>}
+   * @readonly
+   */
+  get members() {
+    return this.guild.members.cache.filter(m => this.permissionsFor(m).has(Permissions.FLAGS.VIEW_CHANNEL, false));
+  }
+
+  /**
+   * Edits the channel.
+   * @param {ChannelData} data The new data for the channel
+   * @param {string} [reason] Reason for editing this channel
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * // Edit a channel
+   * channel.edit({ name: 'new-channel' })
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  edit(data, reason) {
+    return this.guild.channels.edit(this, data, reason);
+  }
+
+  /**
+   * Sets a new name for the guild channel.
+   * @param {string} name The new name for the guild channel
+   * @param {string} [reason] Reason for changing the guild channel's name
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * // Set a new channel name
+   * channel.setName('not_general')
+   *   .then(newChannel => console.log(`Channel's new name is ${newChannel.name}`))
+   *   .catch(console.error);
+   */
+  setName(name, reason) {
+    return this.edit({ name }, reason);
+  }
+
+  /**
+   * Options used to set the parent of a channel.
+   * @typedef {Object} SetParentOptions
+   * @property {boolean} [lockPermissions=true] Whether to lock the permissions to what the parent's permissions are
+   * @property {string} [reason] The reason for modifying the parent of the channel
+   */
+
+  /**
+   * Sets the parent of this channel.
+   * @param {?CategoryChannelResolvable} channel The category channel to set as the parent
+   * @param {SetParentOptions} [options={}] The options for setting the parent
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * // Add a parent to a channel
+   * message.channel.setParent('355908108431917066', { lockPermissions: false })
+   *   .then(channel => console.log(`New parent of ${message.channel.name}: ${channel.name}`))
+   *   .catch(console.error);
+   */
+  setParent(channel, { lockPermissions = true, reason } = {}) {
+    return this.edit(
+      {
+        parent: channel ?? null,
+        lockPermissions,
+      },
+      reason,
+    );
+  }
+
+  /**
+   * Options used to set the position of a channel.
+   * @typedef {Object} SetChannelPositionOptions
+   * @property {boolean} [relative=false] Whether or not to change the position relative to its current value
+   * @property {string} [reason] The reason for changing the position
+   */
+
+  /**
+   * Sets a new position for the guild channel.
+   * @param {number} position The new position for the guild channel
+   * @param {SetChannelPositionOptions} [options] Options for setting position
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * // Set a new channel position
+   * channel.setPosition(2)
+   *   .then(newChannel => console.log(`Channel's new position is ${newChannel.position}`))
+   *   .catch(console.error);
+   */
+  setPosition(position, options = {}) {
+    return this.guild.channels.setPosition(this, position, options);
+  }
+
+  /**
+   * Options used to clone a guild channel.
+   * @typedef {GuildChannelCreateOptions} GuildChannelCloneOptions
+   * @property {string} [name=this.name] Name of the new channel
+   */
+
+  /**
+   * Clones this channel.
+   * @param {GuildChannelCloneOptions} [options] The options for cloning this channel
+   * @returns {Promise<GuildChannel>}
+   */
+  clone(options = {}) {
+    return this.guild.channels.create(options.name ?? this.name, {
+      permissionOverwrites: this.permissionOverwrites.cache,
+      topic: this.topic,
+      type: this.type,
+      nsfw: this.nsfw,
+      parent: this.parent,
+      bitrate: this.bitrate,
+      userLimit: this.userLimit,
+      rateLimitPerUser: this.rateLimitPerUser,
+      position: this.rawPosition,
+      reason: null,
+      ...options,
+    });
+  }
+
+  /**
+   * Checks if this channel has the same type, topic, position, name, overwrites, and id as another channel.
+   * In most cases, a simple `channel.id === channel2.id` will do, and is much faster too.
+   * @param {GuildChannel} channel Channel to compare with
+   * @returns {boolean}
+   */
+  equals(channel) {
+    let equal =
+      channel &&
+      this.id === channel.id &&
+      this.type === channel.type &&
+      this.topic === channel.topic &&
+      this.position === channel.position &&
+      this.name === channel.name;
+
+    if (equal) {
+      if (this.permissionOverwrites && channel.permissionOverwrites) {
+        equal = this.permissionOverwrites.cache.equals(channel.permissionOverwrites.cache);
+      } else {
+        equal = !this.permissionOverwrites && !channel.permissionOverwrites;
+      }
+    }
+
+    return equal;
+  }
+
+  /**
+   * Whether the channel is deletable by the client user
+   * @type {boolean}
+   * @readonly
+   */
+  get deletable() {
+    return this.manageable && this.guild.rulesChannelId !== this.id && this.guild.publicUpdatesChannelId !== this.id;
+  }
+
+  /**
+   * Whether the channel is manageable by the client user
+   * @type {boolean}
+   * @readonly
+   */
+  get manageable() {
+    if (this.client.user.id === this.guild.ownerId) return true;
+    const permissions = this.permissionsFor(this.client.user);
+    if (!permissions) return false;
+
+    // This flag allows managing even if timed out
+    if (permissions.has(Permissions.FLAGS.ADMINISTRATOR, false)) return true;
+    if (this.guild.members.me.communicationDisabledUntilTimestamp > Date.now()) return false;
+
+    const bitfield = VoiceBasedChannelTypes.includes(this.type)
+      ? Permissions.FLAGS.MANAGE_CHANNELS | Permissions.FLAGS.CONNECT
+      : Permissions.FLAGS.VIEW_CHANNEL | Permissions.FLAGS.MANAGE_CHANNELS;
+    return permissions.has(bitfield, false);
+  }
+
+  /**
+   * Whether the channel is viewable by the client user
+   * @type {boolean}
+   * @readonly
+   */
+  get viewable() {
+    if (this.client.user.id === this.guild.ownerId) return true;
+    const permissions = this.permissionsFor(this.client.user);
+    if (!permissions) return false;
+    return permissions.has(Permissions.FLAGS.VIEW_CHANNEL, false);
+  }
+
+  /**
+   * Deletes this channel.
+   * @param {string} [reason] Reason for deleting this channel
+   * @returns {Promise<GuildChannel>}
+   * @example
+   * // Delete the channel
+   * channel.delete('making room for new channels')
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async delete(reason) {
+    await this.guild.channels.delete(this.id, reason);
+    return this;
+  }
+}
+
+module.exports = GuildChannel;