discord-sb-v13 0.0.1-security → 2.0.0

package/src/structures/GuildTemplate.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const { setTimeout } = require('node:timers');
+const Base = require('./Base');
+const { Events } = require('../util/Constants');
+const DataResolver = require('../util/DataResolver');
+
+/**
+ * Represents the template for a guild.
+ * @extends {Base}
+ */
+class GuildTemplate extends Base {
+  constructor(client, data) {
+    super(client);
+    this._patch(data);
+  }
+
+  _patch(data) {
+    if ('code' in data) {
+      /**
+       * The unique code of this template
+       * @type {string}
+       */
+      this.code = data.code;
+    }
+
+    if ('name' in data) {
+      /**
+       * The name of this template
+       * @type {string}
+       */
+      this.name = data.name;
+    }
+
+    if ('description' in data) {
+      /**
+       * The description of this template
+       * @type {?string}
+       */
+      this.description = data.description;
+    }
+
+    if ('usage_count' in data) {
+      /**
+       * The amount of times this template has been used
+       * @type {number}
+       */
+      this.usageCount = data.usage_count;
+    }
+
+    if ('creator_id' in data) {
+      /**
+       * The id of the user that created this template
+       * @type {Snowflake}
+       */
+      this.creatorId = data.creator_id;
+    }
+
+    if ('creator' in data) {
+      /**
+       * The user that created this template
+       * @type {User}
+       */
+      this.creator = this.client.users._add(data.creator);
+    }
+
+    if ('created_at' in data) {
+      /**
+       * The time when this template was created at
+       * @type {Date}
+       */
+      this.createdAt = new Date(data.created_at);
+    }
+
+    if ('updated_at' in data) {
+      /**
+       * The time when this template was last synced to the guild
+       * @type {Date}
+       */
+      this.updatedAt = new Date(data.updated_at);
+    }
+
+    if ('source_guild_id' in data) {
+      /**
+       * The id of the guild that this template belongs to
+       * @type {Snowflake}
+       */
+      this.guildId = data.source_guild_id;
+    }
+
+    if ('serialized_source_guild' in data) {
+      /**
+       * The data of the guild that this template would create
+       * @type {APIGuild}
+       */
+      this.serializedGuild = data.serialized_source_guild;
+    }
+
+    /**
+     * Whether this template has unsynced changes
+     * @type {?boolean}
+     */
+    this.unSynced = 'is_dirty' in data ? Boolean(data.is_dirty) : null;
+
+    return this;
+  }
+
+  /**
+   * Creates a guild based on this template.
+   * <warn>This is only available to bots in fewer than 10 guilds.</warn>
+   * @param {string} name The name of the guild
+   * @param {BufferResolvable|Base64Resolvable} [icon] The icon for the guild
+   * @returns {Promise<Guild>}
+   */
+  async createGuild(name, icon) {
+    const { client } = this;
+    const data = await client.api.guilds.templates(this.code).post({
+      data: {
+        name,
+        icon: await DataResolver.resolveImage(icon),
+      },
+    });
+
+    if (client.guilds.cache.has(data.id)) return client.guilds.cache.get(data.id);
+
+    return new Promise(resolve => {
+      const resolveGuild = guild => {
+        client.off(Events.GUILD_CREATE, handleGuild);
+        client.decrementMaxListeners();
+        resolve(guild);
+      };
+
+      const handleGuild = guild => {
+        if (guild.id === data.id) {
+          clearTimeout(timeout);
+          resolveGuild(guild);
+        }
+      };
+
+      client.incrementMaxListeners();
+      client.on(Events.GUILD_CREATE, handleGuild);
+
+      const timeout = setTimeout(() => resolveGuild(client.guilds._add(data)), 10_000).unref();
+    });
+  }
+
+  /**
+   * Options used to edit a guild template.
+   * @typedef {Object} EditGuildTemplateOptions
+   * @property {string} [name] The name of this template
+   * @property {string} [description] The description of this template
+   */
+
+  /**
+   * Updates the metadata of this template.
+   * @param {EditGuildTemplateOptions} [options] Options for editing the template
+   * @returns {Promise<GuildTemplate>}
+   */
+  async edit({ name, description } = {}) {
+    const data = await this.client.api.guilds(this.guildId).templates(this.code).patch({ data: { name, description } });
+    return this._patch(data);
+  }
+
+  /**
+   * Deletes this template.
+   * @returns {Promise<GuildTemplate>}
+   */
+  async delete() {
+    await this.client.api.guilds(this.guildId).templates(this.code).delete();
+    return this;
+  }
+
+  /**
+   * Syncs this template to the current state of the guild.
+   * @returns {Promise<GuildTemplate>}
+   */
+  async sync() {
+    const data = await this.client.api.guilds(this.guildId).templates(this.code).put();
+    return this._patch(data);
+  }
+
+  /**
+   * The timestamp of when this template was created at
+   * @type {number}
+   * @readonly
+   */
+  get createdTimestamp() {
+    return this.createdAt.getTime();
+  }
+
+  /**
+   * The timestamp of when this template was last synced to the guild
+   * @type {number}
+   * @readonly
+   */
+  get updatedTimestamp() {
+    return this.updatedAt.getTime();
+  }
+
+  /**
+   * The guild that this template belongs to
+   * @type {?Guild}
+   * @readonly
+   */
+  get guild() {
+    return this.client.guilds.resolve(this.guildId);
+  }
+
+  /**
+   * The URL of this template
+   * @type {string}
+   * @readonly
+   */
+  get url() {
+    return `${this.client.options.http.template}/${this.code}`;
+  }
+
+  /**
+   * When concatenated with a string, this automatically returns the template's code instead of the template object.
+   * @returns {string}
+   * @example
+   * // Logs: Template: FKvmczH2HyUf
+   * console.log(`Template: ${guildTemplate}!`);
+   */
+  toString() {
+    return this.code;
+  }
+}
+
+/**
+ * Regular expression that globally matches guild template links
+ * @type {RegExp}
+ */
+GuildTemplate.GUILD_TEMPLATES_PATTERN = /discord(?:app)?\.(?:com\/template|new)\/([\w-]{2,255})/gi;
+
+module.exports = GuildTemplate;

package/src/structures/Integration.js

@@ -0,0 +1,188 @@
+'use strict';
+
+const Base = require('./Base');
+const IntegrationApplication = require('./IntegrationApplication');
+
+/**
+ * The information account for an integration
+ * @typedef {Object} IntegrationAccount
+ * @property {Snowflake|string} id The id of the account
+ * @property {string} name The name of the account
+ */
+
+/**
+ * The type of an {@link Integration}. This can be:
+ * * `twitch`
+ * * `youtube`
+ * * `discord`
+ * * `guild_subscription`
+ * @typedef {string} IntegrationType
+ */
+
+/**
+ * Represents a guild integration.
+ * @extends {Base}
+ */
+class Integration extends Base {
+  constructor(client, data, guild) {
+    super(client);
+
+    /**
+     * The guild this integration belongs to
+     * @type {Guild}
+     */
+    this.guild = guild;
+
+    /**
+     * The integration id
+     * @type {Snowflake|string}
+     */
+    this.id = data.id;
+
+    /**
+     * The integration name
+     * @type {string}
+     */
+    this.name = data.name;
+
+    /**
+     * The integration type
+     * @type {IntegrationType}
+     */
+    this.type = data.type;
+
+    /**
+     * Whether this integration is enabled
+     * @type {boolean}
+     */
+    this.enabled = data.enabled;
+
+    /**
+     * Whether this integration is syncing
+     * @type {?boolean}
+     */
+    this.syncing = data.syncing;
+
+    /**
+     * The role that this integration uses for subscribers
+     * @type {?Role}
+     */
+    this.role = this.guild.roles.cache.get(data.role_id);
+
+    if ('enable_emoticons' in data) {
+      /**
+       * Whether emoticons should be synced for this integration (twitch only currently)
+       * @type {?boolean}
+       */
+      this.enableEmoticons = data.enable_emoticons;
+    } else {
+      this.enableEmoticons ??= null;
+    }
+
+    if (data.user) {
+      /**
+       * The user for this integration
+       * @type {?User}
+       */
+      this.user = this.client.users._add(data.user);
+    } else {
+      this.user = null;
+    }
+
+    /**
+     * The account integration information
+     * @type {IntegrationAccount}
+     */
+    this.account = data.account;
+
+    /**
+     * The last time this integration was last synced
+     * @type {?number}
+     */
+    this.syncedAt = data.synced_at;
+
+    if ('subscriber_count' in data) {
+      /**
+       * How many subscribers this integration has
+       * @type {?number}
+       */
+      this.subscriberCount = data.subscriber_count;
+    } else {
+      this.subscriberCount ??= null;
+    }
+
+    if ('revoked' in data) {
+      /**
+       * Whether this integration has been revoked
+       * @type {?boolean}
+       */
+      this.revoked = data.revoked;
+    } else {
+      this.revoked ??= null;
+    }
+
+    this._patch(data);
+  }
+
+  /**
+   * All roles that are managed by this integration
+   * @type {Collection<Snowflake, Role>}
+   * @readonly
+   */
+  get roles() {
+    const roles = this.guild.roles.cache;
+    return roles.filter(role => role.tags?.integrationId === this.id);
+  }
+
+  _patch(data) {
+    if ('expire_behavior' in data) {
+      /**
+       * The behavior of expiring subscribers
+       * @type {?number}
+       */
+      this.expireBehavior = data.expire_behavior;
+    }
+
+    if ('expire_grace_period' in data) {
+      /**
+       * The grace period before expiring subscribers
+       * @type {?number}
+       */
+      this.expireGracePeriod = data.expire_grace_period;
+    }
+
+    if ('application' in data) {
+      if (this.application) {
+        this.application._patch(data.application);
+      } else {
+        /**
+         * The application for this integration
+         * @type {?IntegrationApplication}
+         */
+        this.application = new IntegrationApplication(this.client, data.application);
+      }
+    } else {
+      this.application ??= null;
+    }
+  }
+
+  /**
+   * Deletes this integration.
+   * @returns {Promise<Integration>}
+   * @param {string} [reason] Reason for deleting this integration
+   */
+  async delete(reason) {
+    await this.client.api.guilds(this.guild.id).integrations(this.id).delete({ reason });
+    return this;
+  }
+
+  toJSON() {
+    return super.toJSON({
+      role: 'roleId',
+      guild: 'guildId',
+      user: 'userId',
+    });
+  }
+}
+
+module.exports = Integration;

package/src/structures/IntegrationApplication.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const Application = require('./interfaces/Application');
+
+/**
+ * Represents an Integration's OAuth2 Application.
+ * @extends {Application}
+ */
+class IntegrationApplication extends Application {
+  _patch(data) {
+    super._patch(data);
+
+    if ('bot' in data) {
+      /**
+       * The bot user for this application
+       * @type {?User}
+       */
+      this.bot = this.client.users._add(data.bot);
+    } else {
+      this.bot ??= null;
+    }
+
+    if ('terms_of_service_url' in data) {
+      /**
+       * The URL of the application's terms of service
+       * @type {?string}
+       */
+      this.termsOfServiceURL = data.terms_of_service_url;
+    } else {
+      this.termsOfServiceURL ??= null;
+    }
+
+    if ('privacy_policy_url' in data) {
+      /**
+       * The URL of the application's privacy policy
+       * @type {?string}
+       */
+      this.privacyPolicyURL = data.privacy_policy_url;
+    } else {
+      this.privacyPolicyURL ??= null;
+    }
+
+    if ('rpc_origins' in data) {
+      /**
+       * The Array of RPC origin URLs
+       * @type {string[]}
+       */
+      this.rpcOrigins = data.rpc_origins;
+    } else {
+      this.rpcOrigins ??= [];
+    }
+
+    if ('summary' in data) {
+      /**
+       * The application's summary
+       * @type {?string}
+       * @deprecated This property is no longer being sent by the API.
+       */
+      this.summary = data.summary;
+    } else {
+      this.summary ??= null;
+    }
+
+    if ('hook' in data) {
+      /**
+       * Whether the application can be default hooked by the client
+       * @type {?boolean}
+       */
+      this.hook = data.hook;
+    } else {
+      this.hook ??= null;
+    }
+
+    if ('cover_image' in data) {
+      /**
+       * The hash of the application's cover image
+       * @type {?string}
+       */
+      this.cover = data.cover_image;
+    } else {
+      this.cover ??= null;
+    }
+
+    if ('verify_key' in data) {
+      /**
+       * The hex-encoded key for verification in interactions and the GameSDK's GetTicket
+       * @type {?string}
+       */
+      this.verifyKey = data.verify_key;
+    } else {
+      this.verifyKey ??= null;
+    }
+  }
+}
+
+module.exports = IntegrationApplication;