@ovencord/discord.js 14.16.3

package/src/managers/GuildInviteManager.ts

@@ -0,0 +1,236 @@
+import { Collection  } from '@ovencord/collection';
+import { Routes  } from 'discord-api-types/v10';
+import { DiscordjsError, ErrorCodes  } from '../errors/index.js';
+import { GuildInvite  } from '../structures/GuildInvite.js';
+import { resolveInviteCode  } from '../util/DataResolver.js';
+import { CachedManager  } from './CachedManager.js';
+
+/**
+ * Manages API methods for GuildInvites and stores their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class GuildInviteManager extends CachedManager {
+  public guild: any;
+  constructor(guild, iterable) {
+    super(guild.client, GuildInvite, iterable);
+
+    /**
+     * The guild this Manager belongs to
+     *
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * The cache of this Manager
+   *
+   * @type {Collection<string, GuildInvite>}
+   * @name GuildInviteManager#cache
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { id: data.code, extras: [this.guild] });
+  }
+
+  /**
+   * Data that resolves to give a `GuildInvite`. This can be:
+   *
+   * - An invite code
+   * - An invite URL
+   *
+   * @typedef {string} GuildInviteResolvable
+   */
+
+  /**
+   * A guild channel where an invite may be created on. This can be:
+   * - TextChannel
+   * - VoiceChannel
+   * - AnnouncementChannel
+   * - StageChannel
+   * - ForumChannel
+   * - MediaChannel
+   *
+   * @typedef {TextChannel|VoiceChannel|AnnouncementChannel|StageChannel|ForumChannel|MediaChannel}
+   * GuildInvitableChannel
+   */
+
+  /**
+   * Data that can be resolved to a guild channel where an invite may be created on. This can be:
+   * - GuildInvitableChannel
+   * - Snowflake
+   *
+   * @typedef {GuildInvitableChannel|Snowflake}
+   * GuildInvitableChannelResolvable
+   */
+
+  /**
+   * Resolves an `GuildInviteResolvable` to a `GuildInvite` object.
+   *
+   * @method resolve
+   * @memberof GuildInviteManager
+   * @instance
+   * @param {GuildInviteResolvable} invite The invite resolvable to resolve
+   * @returns {?GuildInvite}
+   */
+
+  /**
+   * Resolves an InviteResolvable to an invite code string.
+   *
+   * @method resolveId
+   * @memberof GuildInviteManager
+   * @instance
+   * @param {InviteResolvable} invite The invite resolvable to resolve
+   * @returns {?string}
+   */
+
+  /**
+   * Options used to fetch a single invite from a guild.
+   *
+   * @typedef {Object} FetchInviteOptions
+   * @property {InviteResolvable} code The invite to fetch
+   * @property {boolean} [cache=true] Whether or not to cache the fetched invite
+   * @property {boolean} [force=false] Whether to skip the cache check and request the API
+   */
+
+  /**
+   * Options used to fetch all invites from a guild.
+   *
+   * @typedef {Object} FetchInvitesOptions
+   * @property {GuildInvitableChannelResolvable} [channelId]
+   * The channel to fetch all invites from
+   * @property {boolean} [cache=true] Whether or not to cache the fetched invites
+   */
+
+  /**
+   * Fetches invite(s) from Discord.
+   *
+   * @param {GuildInviteResolvable|FetchInviteOptions|FetchInvitesOptions} [options]
+   * Options for fetching guild invite(s)
+   * @returns {Promise<GuildInvite|Collection<string, GuildInvite>>}
+   * @example
+   * // Fetch all invites from a guild
+   * guild.invites.fetch()
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Fetch all invites from a guild without caching
+   * guild.invites.fetch({ cache: false })
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Fetch all invites from a channel
+   * guild.invites.fetch({ channelId: '222197033908436994' })
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single invite
+   * guild.invites.fetch('bRCvFy9')
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single invite without checking cache
+   * guild.invites.fetch({ code: 'bRCvFy9', force: true })
+   *   .then(console.log)
+   *   .catch(console.error)
+   * @example
+   * // Fetch a single invite without caching
+   * guild.invites.fetch({ code: 'bRCvFy9', cache: false })
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async fetch(options) {
+    if (!options) return this._fetchMany();
+    if (typeof options === 'string') {
+      const code = resolveInviteCode(options);
+      if (!code) throw new DiscordjsError(ErrorCodes.InviteResolveCode);
+      return this._fetchSingle({ code, cache: true });
+    }
+
+    if (!options.code) {
+      if (options.channelId) {
+        const id = this.guild.channels.resolveId(options.channelId);
+        if (!id) throw new DiscordjsError(ErrorCodes.GuildChannelResolve);
+        return this._fetchChannelMany(id, options.cache);
+      }
+
+      if ('cache' in options) return this._fetchMany(options.cache);
+      throw new DiscordjsError(ErrorCodes.InviteResolveCode);
+    }
+
+    return this._fetchSingle({
+      ...options,
+      code: resolveInviteCode(options.code),
+    });
+  }
+
+  async _fetchSingle({ code, cache, force = false }) {
+    if (!force) {
+      const existing = this.cache.get(code);
+      if (existing) return existing;
+    }
+
+    const invites = await this._fetchMany(cache);
+    const invite = invites.get(code);
+    if (!invite) throw new DiscordjsError(ErrorCodes.InviteNotFound);
+    return invite;
+  }
+
+  async _fetchMany(cache) {
+    const data = await this.client.rest.get(Routes.guildInvites(this.guild.id));
+    return data.reduce((col, invite) => col.set(invite.code, this._add(invite, cache)), new Collection());
+  }
+
+  async _fetchChannelMany(channelId, cache) {
+    const data = await this.client.rest.get(Routes.channelInvites(channelId));
+    return data.reduce((col, invite) => col.set(invite.code, this._add(invite, cache)), new Collection());
+  }
+
+  /**
+   * Create an invite to the guild from the provided channel.
+   *
+   * @param {GuildInvitableChannelResolvable} channel The options for creating the invite from a channel.
+   * @param {InviteCreateOptions} [options={}] The options for creating the invite from a channel.
+   * @returns {Promise<GuildInvite>}
+   * @example
+   * // Create an invite to a selected channel
+   * guild.invites.create('599942732013764608')
+   *   .then(console.log)
+   *   .catch(console.error);
+   */
+  async create(
+    channel,
+    { temporary, maxAge, maxUses, unique, targetUser, targetApplication, targetType, reason } = {},
+  ) {
+    const id = this.guild.channels.resolveId(channel);
+    if (!id) throw new DiscordjsError(ErrorCodes.GuildChannelResolve);
+
+    const invite = await this.client.rest.post(Routes.channelInvites(id), {
+      body: {
+        temporary,
+        max_age: maxAge,
+        max_uses: maxUses,
+        unique,
+        target_user_id: this.client.users.resolveId(targetUser),
+        target_application_id: targetApplication?.id ?? targetApplication?.applicationId ?? targetApplication,
+        target_type: targetType,
+      },
+      reason,
+    });
+    return new GuildInvite(this.client, invite);
+  }
+
+  /**
+   * Deletes an invite.
+   *
+   * @param {InviteResolvable} invite The invite to delete
+   * @param {string} [reason] Reason for deleting the invite
+   * @returns {Promise<void>}
+   */
+  async delete(invite, reason) {
+    const code = resolveInviteCode(invite);
+
+    await this.client.rest.delete(Routes.invite(code), { reason });
+  }
+}

package/src/managers/GuildManager.ts

@@ -0,0 +1,265 @@
+import process from 'node:process';
+import { setTimeout, clearTimeout  } from 'node:timers';
+import { Collection  } from '@ovencord/collection';
+import { makeURLSearchParams  } from '@ovencord/rest';
+import { GatewayOpcodes, Routes, RouteBases  } from 'discord-api-types/v10';
+import { DiscordjsError, ErrorCodes  } from '../errors/index.js';
+import { ShardClientUtil  } from '../sharding/ShardClientUtil.js';
+import { Guild  } from '../structures/Guild.js';
+import { GuildChannel  } from '../structures/GuildChannel.js';
+import { GuildEmoji  } from '../structures/GuildEmoji.js';
+import { GuildInvite  } from '../structures/GuildInvite.js';
+import { GuildMember  } from '../structures/GuildMember.js';
+import { OAuth2Guild  } from '../structures/OAuth2Guild.js';
+import { Role  } from '../structures/Role.js';
+import { Events  } from '../util/Events.js';
+import { _transformAPIIncidentsData  } from '../util/Transformers.js';
+import { CachedManager  } from './CachedManager.js';
+
+let cacheWarningEmitted = false;
+
+/**
+ * Manages API methods for Guilds and stores their cache.
+ *
+ * @extends {CachedManager}
+ */
+export class GuildManager extends CachedManager {
+  public client: any;
+  constructor(client, iterable) {
+    super(client, Guild, iterable);
+    if (!cacheWarningEmitted && this._cache.constructor.name !== 'Collection') {
+      cacheWarningEmitted = true;
+      process.emitWarning(
+        `Overriding the cache handling for ${this.constructor.name} is unsupported and breaks functionality.`,
+        'UnsupportedCacheOverwriteWarning',
+      );
+    }
+  }
+
+  /**
+   * The cache of this Manager
+   *
+   * @type {Collection<Snowflake, Guild>}
+   * @name GuildManager#cache
+   */
+
+  /**
+   * Data that resolves to give a Guild object. This can be:
+   * - A Guild object
+   * - A GuildChannel object
+   * - A GuildEmoji object
+   * - A Role object
+   * - A Snowflake
+   * - An Invite object
+   *
+   * @typedef {Guild|GuildChannel|GuildMember|GuildEmoji|Role|Snowflake|Invite} GuildResolvable
+   */
+
+  /**
+   * Resolves a {@link GuildResolvable} to a {@link Guild} object.
+   *
+   * @method resolve
+   * @memberof GuildManager
+   * @instance
+   * @param {GuildResolvable} guild The guild resolvable to identify
+   * @returns {?Guild}
+   */
+  resolve(guild) {
+    if (
+      guild instanceof GuildChannel ||
+      guild instanceof GuildMember ||
+      guild instanceof GuildEmoji ||
+      guild instanceof Role ||
+      (guild instanceof GuildInvite && guild.guild)
+    ) {
+      return super.resolve(guild.guild);
+    }
+
+    return super.resolve(guild);
+  }
+
+  /**
+   * Resolves a {@link GuildResolvable} to a {@link Guild} id string.
+   *
+   * @method resolveId
+   * @memberof GuildManager
+   * @instance
+   * @param {GuildResolvable} guild The guild resolvable to identify
+   * @returns {?Snowflake}
+   */
+  resolveId(guild) {
+    if (
+      guild instanceof GuildChannel ||
+      guild instanceof GuildMember ||
+      guild instanceof GuildEmoji ||
+      guild instanceof Role ||
+      (guild instanceof GuildInvite && guild.guild)
+    ) {
+      return super.resolveId(guild.guild.id);
+    }
+
+    return super.resolveId(guild);
+  }
+
+  /**
+   * Options used to fetch a single guild.
+   *
+   * @typedef {BaseFetchOptions} FetchGuildOptions
+   * @property {GuildResolvable} guild The guild to fetch
+   * @property {boolean} [withCounts=true] Whether the approximate member and presence counts should be returned
+   */
+
+  /**
+   * Options used to fetch multiple guilds.
+   *
+   * @typedef {Object} FetchGuildsOptions
+   * @property {Snowflake} [before] Get guilds before this guild id
+   * @property {Snowflake} [after] Get guilds after this guild id
+   * @property {number} [limit] Maximum number of guilds to request (1-200)
+   */
+
+  /**
+   * Obtains one or multiple guilds from Discord, or the guild cache if it's already available.
+   *
+   * @param {GuildResolvable|FetchGuildOptions|FetchGuildsOptions} [options] The guild's id or options
+   * @returns {Promise<Guild|Collection<Snowflake, OAuth2Guild>>}
+   */
+  async fetch(options = {}) {
+    const id = this.resolveId(options) ?? this.resolveId(options.guild);
+
+    if (id) {
+      if (!options.force) {
+        const existing = this.cache.get(id);
+        if (existing) return existing;
+      }
+
+      const innerData = await this.client.rest.get(Routes.guild(id), {
+        query: makeURLSearchParams({ with_counts: options.withCounts ?? true }),
+      });
+      innerData.shardId = ShardClientUtil.shardIdForGuildId(id, await this.client.ws.fetchShardCount());
+      return this._add(innerData, options.cache);
+    }
+
+    const data = await this.client.rest.get(Routes.userGuilds(), { query: makeURLSearchParams(options) });
+    return data.reduce((coll, guild) => coll.set(guild.id, new OAuth2Guild(this.client, guild)), new Collection());
+  }
+
+  /**
+   * @typedef {Object} FetchSoundboardSoundsOptions
+   * @property {Snowflake[]} guildIds The ids of the guilds to fetch soundboard sounds for
+   * @property {number} [time=10_000] The timeout for receipt of the soundboard sounds
+   */
+
+  /**
+   * Fetches soundboard sounds for the specified guilds.
+   *
+   * @param {FetchSoundboardSoundsOptions} options The options for fetching soundboard sounds
+   * @returns {Promise<Collection<Snowflake, Collection<Snowflake, SoundboardSound>>>}
+   * @example
+   * // Fetch soundboard sounds for multiple guilds
+   * const soundboardSounds = await client.guilds.fetchSoundboardSounds({
+   *  guildIds: ['123456789012345678', '987654321098765432'],
+   * })
+   *
+   * console.log(soundboardSounds.get('123456789012345678'));
+   */
+  async fetchSoundboardSounds({ guildIds, time = 10_000 }) {
+    const shardCount = await this.client.ws.getShardCount();
+    const shardIds = Map.groupBy(guildIds, guildId => ShardClientUtil.shardIdForGuildId(guildId, shardCount));
+
+    for (const [shardId, shardGuildIds] of shardIds) {
+      this.client.ws.send(shardId, {
+        op: GatewayOpcodes.RequestSoundboardSounds,
+        // eslint-disable-next-line id-length
+        d: {
+          guild_ids: shardGuildIds,
+        },
+      });
+    }
+
+    return new Promise((resolve, reject) => {
+      const remainingGuildIds = new Set(guildIds);
+
+      const fetchedSoundboardSounds = new Collection();
+
+      const handler = (soundboardSounds, guild) => {
+        // eslint-disable-next-line no-use-before-define
+        timeout.refresh();
+
+        if (!remainingGuildIds.has(guild.id)) return;
+
+        fetchedSoundboardSounds.set(guild.id, soundboardSounds);
+
+        remainingGuildIds.delete(guild.id);
+
+        if (remainingGuildIds.size === 0) {
+          // eslint-disable-next-line no-use-before-define
+          clearTimeout(timeout);
+          this.client.removeListener(Events.SoundboardSounds, handler);
+          this.client.decrementMaxListeners();
+
+          resolve(fetchedSoundboardSounds);
+        }
+      };
+
+      const timeout = setTimeout(() => {
+        this.client.removeListener(Events.SoundboardSounds, handler);
+        this.client.decrementMaxListeners();
+        reject(new DiscordjsError(ErrorCodes.GuildSoundboardSoundsTimeout));
+      }, time).unref();
+
+      this.client.incrementMaxListeners();
+      this.client.on(Events.SoundboardSounds, handler);
+    });
+  }
+
+  /**
+   * Options used to set incident actions. Supplying `null` to any option will disable the action.
+   *
+   * @typedef {Object} IncidentActionsEditOptions
+   * @property {?DateResolvable} [invitesDisabledUntil] When invites should be enabled again
+   * @property {?DateResolvable} [dmsDisabledUntil] When direct messages should be enabled again
+   */
+
+  /**
+   * Sets the incident actions for a guild.
+   *
+   * @param {GuildResolvable} guild The guild
+   * @param {IncidentActionsEditOptions} incidentActions The incident actions to set
+   * @returns {Promise<IncidentActions>}
+   */
+  async setIncidentActions(guild, { invitesDisabledUntil, dmsDisabledUntil }) {
+    const guildId = this.resolveId(guild);
+
+    const data = await this.client.rest.put(Routes.guildIncidentActions(guildId), {
+      body: {
+        invites_disabled_until: invitesDisabledUntil && new Date(invitesDisabledUntil).toISOString(),
+        dms_disabled_until: dmsDisabledUntil && new Date(dmsDisabledUntil).toISOString(),
+      },
+    });
+
+    const parsedData = _transformAPIIncidentsData(data);
+    const resolvedGuild = this.resolve(guild);
+
+    if (resolvedGuild) {
+      resolvedGuild.incidentsData = parsedData;
+    }
+
+    return parsedData;
+  }
+
+  /**
+   * Returns a URL for the PNG widget of a guild.
+   *
+   * @param {GuildResolvable} guild The guild of the widget image
+   * @param {GuildWidgetStyle} [style] The style for the widget image
+   * @returns {string}
+   */
+  widgetImageURL(guild, style) {
+    const urlSearchParams = String(makeURLSearchParams({ style }));
+
+    return `${RouteBases.api}${Routes.guildWidgetImage(this.resolveId(guild))}${
+      urlSearchParams ? `?${urlSearchParams}` : ''
+    }`;
+  }
+}