disgroove 1.3.1 → 1.3.3-dev.1

package/lib/structures/ApplicationCommand.ts

@@ -0,0 +1,187 @@
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type {
+  JSONApplicationCommand,
+  JSONApplicationCommandOption,
+  JSONApplicationCommandPermission,
+  JSONGuildApplicationCommandPermissions,
+  RawApplicationCommand,
+  RawGuildApplicationCommandPermissions,
+} from "../types";
+import type { ApplicationCommandTypes, Locale } from "../constants";
+import { Base } from ".";
+
+/** https://discord.com/developers/docs/interactions/application-commands */
+export class ApplicationCommand extends Base {
+  protected override raw: RawApplicationCommand;
+  type?: ApplicationCommandTypes;
+  applicationId: string;
+  guildId?: string;
+  name: string;
+  nameLocalizations?: Partial<Record<Locale, string>> | null;
+  description: string;
+  descriptionLocalizations?: Partial<Record<Locale, string>> | null;
+  options?: Array<JSONApplicationCommandOption>;
+  defaultMemberPermissions: string | null;
+  dmPermission?: boolean;
+  defaultPermission?: boolean | null;
+  nsfw?: boolean;
+  version: string;
+
+  constructor(data: RawApplicationCommand, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.applicationId = data.application_id;
+    this.name = data.name;
+    this.description = data.description;
+    this.defaultMemberPermissions = data.default_member_permissions;
+    this.version = data.version;
+
+    this.patch(data);
+  }
+
+  protected override patch(data: RawApplicationCommand): void {
+    if (data.type !== undefined) this.type = data.type;
+    if (data.guild_id !== undefined) this.guildId = data.guild_id;
+    if (data.name_localizations !== undefined)
+      this.nameLocalizations = data.name_localizations;
+    if (data.description_localizations !== undefined)
+      this.descriptionLocalizations = data.description_localizations;
+    if (data.options !== undefined) this.options = data.options;
+    if (data.dm_permission !== undefined)
+      this.dmPermission = data.dm_permission;
+    if (data.default_permission !== undefined)
+      this.defaultPermission = data.default_permission;
+    if (data.nsfw !== undefined) this.nsfw = data.nsfw;
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#delete-guild-application-command */
+  delete(): void {
+    this.guildId !== undefined
+      ? this.client.rest.delete(
+          Endpoints.applicationGuildCommand(
+            this.applicationId,
+            this.guildId,
+            this.id
+          )
+        )
+      : this.client.rest.delete(
+          Endpoints.applicationCommand(this.applicationId, this.id)
+        );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#edit-global-application-command */
+  async edit(options: {
+    name?: string;
+    nameLocalizations?: Partial<Record<Locale, string>> | null;
+    description?: string;
+    descriptionLocalizations?: Partial<Record<Locale, string>> | null;
+    options?: Array<JSONApplicationCommandOption>;
+    defaultMemberPermissions?: string | null;
+    defaultPermission?: boolean | null;
+    dmPermission?: boolean;
+    nsfw?: boolean;
+  }): Promise<ApplicationCommand> {
+    return new ApplicationCommand(
+      this.guildId !== undefined
+        ? await this.client.rest.patch<RawApplicationCommand>(
+            Endpoints.applicationGuildCommand(this.id, this.guildId, this.id),
+            {
+              json: this.client.util.applicationCommandToRaw(options),
+            }
+          )
+        : await this.client.rest.patch<RawApplicationCommand>(
+            Endpoints.applicationCommand(this.applicationId, this.id),
+            {
+              json: this.client.util.applicationCommandToRaw(options),
+            }
+          ),
+      this.client
+    );
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#edit-application-command-permissions */
+  async editPermissions(options: {
+    permissions: Array<JSONApplicationCommandPermission>;
+  }): Promise<JSONGuildApplicationCommandPermissions> {
+    if (!this.guildId)
+      throw new Error(
+        "[disgroove] Cannot edit the permissions of a global application command"
+      );
+
+    return this.client.rest
+      .put<RawGuildApplicationCommandPermissions>(
+        Endpoints.applicationCommandPermissions(
+          this.applicationId,
+          this.guildId,
+          this.id
+        ),
+        {
+          json: {
+            permissions: options.permissions,
+          },
+        }
+      )
+      .then((response) => ({
+        id: response.id,
+        applicationId: response.application_id,
+        guildId: response.guild_id,
+        permissions: response.permissions.map((permission) => ({
+          id: permission.id,
+          type: permission.type,
+          permission: permission.permission,
+        })),
+      }));
+  }
+
+  /** https://discord.com/developers/docs/interactions/application-commands#get-application-command-permissions */
+  async getPermissions(): Promise<JSONGuildApplicationCommandPermissions> {
+    if (!this.guildId)
+      throw new Error(
+        "[disgroove] Cannot get the permissions of a global application command"
+      );
+
+    return this.client.rest
+      .get<RawGuildApplicationCommandPermissions>(
+        Endpoints.applicationCommandPermissions(
+          this.applicationId,
+          this.guildId,
+          this.id
+        )
+      )
+      .then((response) => ({
+        id: response.id,
+        applicationId: response.application_id,
+        guildId: response.guild_id,
+        permissions: response.permissions.map((permission) => ({
+          id: permission.id,
+          type: permission.type,
+          permission: permission.permission,
+        })),
+      }));
+  }
+
+  override toRaw(): RawApplicationCommand {
+    return this.raw;
+  }
+
+  override toJSON(): JSONApplicationCommand {
+    return {
+      ...super.toJSON(),
+      type: this.type,
+      applicationId: this.applicationId,
+      guildId: this.guildId,
+      name: this.name,
+      nameLocalizations: this.nameLocalizations,
+      description: this.description,
+      descriptionLocalizations: this.descriptionLocalizations,
+      options: this.options,
+      defaultMemberPermissions: this.defaultMemberPermissions,
+      dmPermission: this.dmPermission,
+      defaultPermission: this.defaultPermission,
+      nsfw: this.nsfw,
+      version: this.version,
+    };
+  }
+}

package/lib/structures/AuditLog.ts

@@ -0,0 +1,112 @@
+import {
+  ApplicationCommand,
+  AutoModerationRule,
+  Channel,
+  GuildScheduledEvent,
+  Integration,
+  User,
+  Webhook,
+} from ".";
+import type { Client } from "../Client";
+import type { JSONAuditLog, JSONAuditLogEntry, RawAuditLog } from "../types";
+
+/** https://discord.com/developers/docs/resources/audit-log */
+export class AuditLog {
+  private client: Client;
+  private raw: RawAuditLog;
+  applicationCommands: Array<ApplicationCommand>;
+  auditLogEntries: Array<JSONAuditLogEntry>;
+  autoModerationRules: Array<AutoModerationRule>;
+  guildScheduledEvents: Array<GuildScheduledEvent>;
+  integrations: Array<Integration>;
+  threads: Array<Channel>;
+  users: Array<User>;
+  webhooks: Array<Webhook>;
+
+  constructor(data: RawAuditLog, client: Client) {
+    this.client = client;
+    this.raw = data;
+    this.applicationCommands = data.application_commands.map(
+      (applicationCommand) =>
+        new ApplicationCommand(applicationCommand, this.client)
+    );
+    this.auditLogEntries = data.audit_log_entries.map((auditLogEntry) => ({
+      targetId: auditLogEntry.target_id,
+      changes: auditLogEntry.changes?.map((change) => ({
+        newValue: change.new_value,
+        oldValue: change.old_value,
+        key: change.key,
+      })),
+      userId: auditLogEntry.user_id,
+      id: auditLogEntry.id,
+      actionType: auditLogEntry.action_type,
+      options:
+        auditLogEntry.options !== undefined
+          ? {
+              applicationId: auditLogEntry.options.application_id,
+              autoModerationRuleName:
+                auditLogEntry.options.auto_moderation_rule_name,
+              autoModerationRuleTriggerType:
+                auditLogEntry.options.auto_moderation_rule_trigger_type,
+              channelId: auditLogEntry.options.channel_id,
+              count: auditLogEntry.options.count,
+              deleteMemberDays: auditLogEntry.options.delete_member_days,
+              id: auditLogEntry.options.id,
+              membersRemoved: auditLogEntry.options.members_removed,
+              messageId: auditLogEntry.options.message_id,
+              roleName: auditLogEntry.options.role_name,
+              type: auditLogEntry.options.type,
+              integrationType: auditLogEntry.options.integration_type,
+            }
+          : undefined,
+      reason: auditLogEntry.reason,
+    }));
+    this.autoModerationRules = data.auto_moderation_rules.map(
+      (autoModerationRule) =>
+        new AutoModerationRule(autoModerationRule, this.client)
+    );
+    this.guildScheduledEvents = data.guild_scheduled_events.map(
+      (guildScheduledEvent) =>
+        new GuildScheduledEvent(guildScheduledEvent, this.client)
+    );
+    this.integrations = data.integrations.map(
+      (integration) => new Integration(integration, this.client)
+    );
+    this.threads = data.threads.map(
+      (thread) => new Channel(thread, this.client)
+    );
+    this.users = data.users.map((user) => new User(user, this.client));
+    this.webhooks = data.webhooks.map(
+      (webhook) => new Webhook(webhook, this.client)
+    );
+  }
+
+  toString(): string {
+    return `[${this.constructor.name}]`;
+  }
+
+  toRaw(): RawAuditLog {
+    return this.raw;
+  }
+
+  toJSON(): JSONAuditLog {
+    return {
+      applicationCommands: this.applicationCommands.map((applicationCommand) =>
+        applicationCommand.toJSON()
+      ),
+      auditLogEntries: this.auditLogEntries,
+      autoModerationRules: this.autoModerationRules.map((autoModerationRule) =>
+        autoModerationRule.toJSON()
+      ),
+      guildScheduledEvents: this.guildScheduledEvents.map(
+        (guildScheduledEvent) => guildScheduledEvent.toJSON()
+      ),
+      integrations: this.integrations.map((integration) =>
+        integration.toJSON()
+      ),
+      threads: this.threads.map((thread) => thread.toJSON()),
+      users: this.users.map((user) => user.toJSON()),
+      webhooks: this.webhooks.map((webhook) => webhook.toJSON()),
+    };
+  }
+}

package/lib/structures/AutoModerationRule.ts

@@ -0,0 +1,127 @@
+import type { Client } from "../Client";
+import { Endpoints } from "../rest";
+import type {
+  JSONAutoModerationAction,
+  JSONAutoModerationRule,
+  JSONTriggerMetadata,
+  RawAutoModerationRule,
+} from "../types";
+import { Base } from ".";
+import type { EventTypes, TriggerTypes } from "../constants";
+
+/** https://discord.com/developers/docs/resources/auto-moderation */
+export class AutoModerationRule extends Base {
+  protected override raw: RawAutoModerationRule;
+  guildId: string;
+  name: string;
+  creatorId: string;
+  eventType: EventTypes;
+  triggerType: TriggerTypes;
+  triggerMetadata: JSONTriggerMetadata;
+  actions: Array<JSONAutoModerationAction>;
+  enabled: boolean;
+  exemptRoles: Array<string>;
+  exemptChannels: Array<string>;
+
+  constructor(data: RawAutoModerationRule, client: Client) {
+    super(data.id, client);
+
+    this.raw = data;
+    this.guildId = data.guild_id;
+    this.name = data.name;
+    this.creatorId = data.creator_id;
+    this.eventType = data.event_type;
+    this.triggerType = data.trigger_type;
+    this.triggerMetadata = {
+      keywordFilter: data.trigger_metadata.keyword_filter,
+      regexPatterns: data.trigger_metadata.regex_patterns,
+      presets: data.trigger_metadata.presets,
+      allowList: data.trigger_metadata.allow_list,
+      mentionTotalLimit: data.trigger_metadata.mention_total_limit,
+      mentionRaidProtection: data.trigger_metadata.mention_raid_protection,
+    };
+    this.actions = data.actions.map((action) => ({
+      type: action.type,
+      metadata: {
+        channelId: action.metadata.channel_id,
+        durationSeconds: action.metadata.duration_seconds,
+        customMessage: action.metadata.custom_message,
+      },
+    }));
+    this.enabled = data.enabled;
+    this.exemptRoles = data.exempt_roles;
+    this.exemptChannels = data.exempt_channels;
+  }
+
+  /** https://discord.com/developers/docs/resources/auto-moderation#delete-auto-moderation-rule */
+  delete(reason?: string): void {
+    this.client.rest.delete(
+      Endpoints.guildAutoModerationRule(this.guildId, this.id),
+      {
+        reason,
+      }
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/auto-moderation#modify-auto-moderation-rule */
+  async edit(
+    options: {
+      name?: string;
+      eventType?: EventTypes;
+      triggerType?: TriggerTypes;
+      triggerMetadata?: JSONTriggerMetadata;
+      actions?: Array<JSONAutoModerationAction>;
+      enabled?: boolean;
+      exemptRoles?: Array<string>;
+      exemptChannels?: Array<string>;
+    },
+    reason?: string
+  ): Promise<AutoModerationRule> {
+    return new AutoModerationRule(
+      await this.client.rest.patch<RawAutoModerationRule>(
+        Endpoints.guildAutoModerationRule(this.guildId, this.id),
+        {
+          json: {
+            name: options.name,
+            event_type: options.eventType,
+            trigger_type: options.triggerType,
+            trigger_metadata: options.triggerMetadata,
+            actions: options.actions?.map((action) => ({
+              type: action.type,
+              metadata: {
+                channelId: action.metadata.channelId,
+                durationSeconds: action.metadata.durationSeconds,
+                customMessage: action.metadata.customMessage,
+              },
+            })),
+            enabled: options.enabled,
+            exempt_roles: options.exemptRoles,
+            exempt_channels: options.exemptChannels,
+          },
+          reason,
+        }
+      ),
+      this.client
+    );
+  }
+
+  override toRaw(): RawAutoModerationRule {
+    return this.raw;
+  }
+
+  override toJSON(): JSONAutoModerationRule {
+    return {
+      ...super.toJSON(),
+      guildId: this.guildId,
+      name: this.name,
+      creatorId: this.creatorId,
+      eventType: this.eventType,
+      triggerType: this.triggerType,
+      triggerMetadata: this.triggerMetadata,
+      actions: this.actions,
+      enabled: this.enabled,
+      exemptRoles: this.exemptRoles,
+      exemptChannels: this.exemptChannels,
+    };
+  }
+}

package/lib/structures/Base.ts

@@ -0,0 +1,39 @@
+import type { Client } from "../Client";
+
+export abstract class Base {
+  protected client: Client;
+  protected raw: {
+    id: string;
+  };
+  id: string;
+
+  constructor(id: string, client: Client) {
+    this.client = client;
+    this.raw = {
+      id,
+    };
+    this.id = id;
+  }
+
+  protected patch(data: unknown): void {}
+
+  toString(): string {
+    return `[${this.constructor.name}]`;
+  }
+
+  toRaw(): {
+    id: string;
+  } {
+    return {
+      id: this.id,
+    };
+  }
+
+  toJSON(): {
+    id: string;
+  } {
+    return {
+      id: this.id,
+    };
+  }
+}