disgroove 1.3.1 → 1.3.3-dev.1

package/lib/Client.ts

@@ -0,0 +1,616 @@
+import {
+  type DefaultMessageNotificationLevel,
+  type ExplicitContentFilterLevel,
+  GatewayIntents,
+  type OAuth2Scopes,
+  type PrivacyLevel,
+  StatusTypes,
+  type SystemChannelFlags,
+  type VerificationLevel,
+  GatewayOPCodes,
+  ChannelTypes,
+} from "./constants";
+import { Util } from "./utils";
+import { Endpoints, REST } from "./rest";
+import {
+  Application,
+  AutoModerationRule,
+  Channel,
+  Guild,
+  GuildMember,
+  GuildScheduledEvent,
+  Integration,
+  Interaction,
+  Invite,
+  Message,
+  StageInstance,
+  User,
+  VoiceState,
+  ClientApplication,
+  Emoji,
+  Sticker,
+  Role,
+  UnavailableGuild,
+  Entitlement,
+} from "./structures";
+import type {
+  Activity,
+  JSONAuditLogEntry,
+  AutoModerationActionExecutionEventFields,
+  JSONAutoModerationRule,
+  JSONChannel,
+  ChannelPinsUpdateEventFields,
+  JSONGuildApplicationCommandPermissions,
+  GuildBanAddEventFields,
+  GuildBanRemoveEventFields,
+  GuildMemberRemoveEventFields,
+  GuildMemberUpdateEventFields,
+  GuildMembersChunkEventFields,
+  JSONGuildScheduledEvent,
+  IntegrationDeleteEventFields,
+  InviteCreateEventFields,
+  InviteDeleteEventFields,
+  MessageDeleteBulkEventFields,
+  MessageDeleteEventFields,
+  MessageReactionAddEventFields,
+  MessageReactionRemoveAllEventFields,
+  MessageReactionRemoveEmojiEventFields,
+  MessageReactionRemoveEventFields,
+  PresenceUpdateEventFields,
+  JSONRole,
+  JSONStageInstance,
+  JSONStickerPack,
+  ThreadListSyncEventFields,
+  JSONThreadMember,
+  ThreadMembersUpdateEventFields,
+  TypingStartEventFields,
+  JSONVoiceRegion,
+  VoiceServerUpdateEventFields,
+  RawApplication,
+  RawChannel,
+  RawGuild,
+  RawInvite,
+  RawStageInstance,
+  RawStickerPack,
+  RawUser,
+  RawVoiceRegion,
+  JSONEntitlement,
+  JSONUnavailableGuild,
+} from "./types";
+import EventEmitter from "node:events";
+import { Shard, ShardsManager } from "./gateway";
+
+export interface ClientEvents {
+  hello: [];
+  ready: [];
+  resumed: [];
+  reconnect: [];
+  invalidSession: [];
+  applicationCommandPermissionsUpdate: [
+    applicationCommandPermissions: JSONGuildApplicationCommandPermissions
+  ];
+  autoModerationRuleCreate: [autoModerationRule: AutoModerationRule];
+  autoModerationRuleUpdate: [autoModerationRule: AutoModerationRule];
+  autoModerationRuleDelete: [autoModerationRule: JSONAutoModerationRule];
+  autoModerationActionExecution: [
+    autoModerationExecution: AutoModerationActionExecutionEventFields
+  ];
+  channelCreate: [channel: Channel];
+  channelUpdate: [channel: Channel];
+  channelDelete: [channel: JSONChannel];
+  channelPinsUpdate: [pins: ChannelPinsUpdateEventFields];
+  threadCreate: [thread: Channel];
+  threadUpdate: [thread: Channel];
+  threadDelete: [thread: JSONChannel];
+  threadListSync: [sync: ThreadListSyncEventFields];
+  threadMemberUpdate: [
+    threadMember: JSONThreadMember & {
+      guildId: string;
+    }
+  ];
+  threadMembersUpdate: [thread: ThreadMembersUpdateEventFields];
+  entitlementCreate: [entitlement: Entitlement];
+  entitlementUpdate: [entitlement: Entitlement];
+  entitlementDelete: [entitlement: JSONEntitlement];
+  guildCreate: [guild: Guild | UnavailableGuild];
+  guildUpdate: [guild: Guild];
+  guildDelete: [guild: JSONUnavailableGuild];
+  guildAuditLogEntryCreate: [auditLogEntry: JSONAuditLogEntry];
+  guildBanAdd: [ban: GuildBanAddEventFields];
+  guildBanRemove: [ban: GuildBanRemoveEventFields];
+  guildEmojisUpdate: [emojis: Array<Emoji>, guildId: string];
+  guildStickersUpdate: [stickers: Array<Sticker>, guildId: string];
+  guildIntegrationsUpdate: [guildId: string];
+  guildMemberAdd: [guildMember: GuildMember];
+  guildMemberRemove: [guildMember: GuildMemberRemoveEventFields];
+  guildMemberUpdate: [guildMember: GuildMemberUpdateEventFields];
+  guildMembersChunk: [request: GuildMembersChunkEventFields];
+  guildRoleCreate: [role: Role, guildId: string];
+  guildRoleUpdate: [role: Role, guildId: string];
+  guildRoleDelete: [roleId: string, guildId: string];
+  guildScheduledEventCreate: [guildScheduledEvent: GuildScheduledEvent];
+  guildScheduledEventUpdate: [guildScheduledEvent: GuildScheduledEvent];
+  guildScheduledEventDelete: [guildScheduledEvent: JSONGuildScheduledEvent];
+  guildScheduledEventUserAdd: [
+    userId: string,
+    guildScheduledEventId: string,
+    guildId: string
+  ];
+  guildScheduledEventUserRemove: [
+    userId: string,
+    guildScheduledEventId: string,
+    guildId: string
+  ];
+  integrationCreate: [integration: Integration];
+  integrationUpdate: [integration: Integration];
+  integrationDelete: [integration: IntegrationDeleteEventFields];
+  interactionCreate: [interaction: Interaction];
+  inviteCreate: [invite: InviteCreateEventFields];
+  inviteDelete: [invite: InviteDeleteEventFields];
+  messageCreate: [message: Message];
+  messageUpdate: [
+    message:
+      | Message
+      | {
+          id: string;
+          channelId: string;
+        }
+  ];
+  messageDelete: [message: MessageDeleteEventFields];
+  messageDeleteBulk: [bulk: MessageDeleteBulkEventFields];
+  messageReactionAdd: [reaction: MessageReactionAddEventFields];
+  messageReactionRemove: [reaction: MessageReactionRemoveEventFields];
+  messageReactionRemoveAll: [reaction: MessageReactionRemoveAllEventFields];
+  messageReactionRemoveEmoji: [reaction: MessageReactionRemoveEmojiEventFields];
+  presenceUpdate: [presence: PresenceUpdateEventFields];
+  stageInstanceCreate: [stageInstance: StageInstance];
+  stageInstanceUpdate: [stageInstance: StageInstance];
+  stageInstanceDelete: [stageInstance: JSONStageInstance];
+  typingStart: [typing: TypingStartEventFields];
+  userUpdate: [user: User];
+  voiceStateUpdate: [voiceState: VoiceState];
+  voiceServerUpdate: [voiceServer: VoiceServerUpdateEventFields];
+  webhooksUpdate: [channelId: string, guildId: string];
+}
+
+export interface ClientOptions {
+  intents?: number | Array<number>;
+  shardsCount?: number | "auto";
+  auth?: "Bot" | "Bearer";
+}
+
+export class Client extends EventEmitter {
+  token: string;
+  intents: GatewayIntents | number;
+  shardsCount: number | "auto";
+  auth: "Bot" | "Bearer";
+  shards: ShardsManager;
+  rest: REST;
+  util: Util;
+  user!: User;
+  application!: ClientApplication;
+  guildSharding: Record<string, number>;
+
+  constructor(token: string, options?: ClientOptions) {
+    super();
+
+    this.token = token;
+    this.intents =
+      options?.intents !== undefined
+        ? Array.isArray(options.intents)
+          ? options.intents.reduce((sum, num) => sum + num, 0)
+          : options.intents
+        : GatewayIntents.AllNonPrivileged;
+    this.shardsCount = options?.shardsCount ?? "auto";
+    this.auth = options?.auth ?? "Bot";
+    this.shards = new ShardsManager();
+    this.rest = new REST(token, this.auth);
+    this.util = new Util();
+    this.guildSharding = {};
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#create-guild */
+  async createGuild(options: {
+    name: string;
+    region?: string | null;
+    icon?: string;
+    verificationLevel?: VerificationLevel;
+    defaultMessageNotifications?: DefaultMessageNotificationLevel;
+    explicitContentFilter?: ExplicitContentFilterLevel;
+    roles?: Array<
+      Partial<Omit<JSONRole, "id" | "position" | "tags" | "flags" | "managed">>
+    >;
+    channels?: Array<{
+      name: string;
+      type: ChannelTypes;
+      id?: number;
+      parentId?: number;
+    }>;
+    afkChannelId?: string;
+    afkTimeout?: number;
+    systemChannelId?: string;
+    systemChannelFlags?: SystemChannelFlags;
+  }): Promise<Guild> {
+    return new Guild(
+      await this.rest.post<RawGuild>(Endpoints.guilds(), {
+        json: {
+          name: options.name,
+          region: options.region,
+          icon: options.icon,
+          verification_level: options.verificationLevel,
+          default_message_notifications: options.defaultMessageNotifications,
+          explicit_content_filter: options.explicitContentFilter,
+          roles: options.roles?.map((role) => this.util.roleToRaw(role)),
+          channels: options.channels?.map((channel) => ({
+            id: channel.id,
+            type: channel.name,
+            parent_id: channel.parentId,
+            name: channel.name,
+          })),
+          afk_channel_id: options.afkChannelId,
+          afk_timeout: options.afkTimeout,
+          system_channel_id: options.systemChannelId,
+          system_channel_flags: options.systemChannelFlags,
+        },
+      }),
+      this
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/guild-template#create-guild-from-guild-template */
+  async createGuildFromTemplate(
+    code: string,
+    options: {
+      name: string;
+      icon?: string;
+    }
+  ): Promise<Guild> {
+    return new Guild(
+      await this.rest.post<RawGuild>(Endpoints.template(code), {
+        json: {
+          name: options.name,
+          icon: options.icon,
+        },
+      }),
+      this
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/stage-instance#create-stage-instance */
+  async createStageInstance(
+    options: {
+      channelId: string;
+      topic: string;
+      privacyLevel?: PrivacyLevel;
+      sendStartNotifications?: boolean;
+      guildScheduledEventId?: string;
+    },
+    reason?: string
+  ): Promise<StageInstance> {
+    return new StageInstance(
+      await this.rest.post<RawStageInstance>(Endpoints.stageInstances(), {
+        json: {
+          channel_id: options.channelId,
+          topic: options.topic,
+          privacy_level: options.privacyLevel,
+          send_start_notifications: options.sendStartNotifications,
+          guild_scheduled_event_id: options.guildScheduledEventId,
+        },
+        reason,
+      }),
+      this
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/application#get-current-application */
+  async getApplication(): Promise<Application> {
+    return new Application(
+      await this.rest.get<RawApplication>(Endpoints.applicationCurrentUser()),
+      this
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/channel#get-channel */
+  async getChannel(channelId: string): Promise<Channel> {
+    return new Channel(
+      await this.rest.get<RawChannel>(Endpoints.channel(channelId)),
+      this
+    );
+  }
+
+  /** https://discord.com/developers/docs/topics/gateway#get-gateway */
+  async getGateway(): Promise<{ url: string }> {
+    return this.rest.get<{ url: string }>(Endpoints.gateway());
+  }
+
+  /** https://discord.com/developers/docs/topics/gateway#get-gateway-bot */
+  async getGatewayBot(): Promise<{
+    url: string;
+    shards: number;
+    sessionStartLimit: {
+      total: number;
+      remaining: number;
+      resetAfter: number;
+      maxConcurrency: number;
+    };
+  }> {
+    return this.rest
+      .get<{
+        url: string;
+        shards: number;
+        session_start_limit: {
+          total: number;
+          remaining: number;
+          reset_after: number;
+          max_concurrency: number;
+        };
+      }>(Endpoints.gatewayBot())
+      .then((response) => ({
+        url: response.url,
+        shards: response.shards,
+        sessionStartLimit: {
+          total: response.session_start_limit.total,
+          remaining: response.session_start_limit.remaining,
+          resetAfter: response.session_start_limit.reset_after,
+          maxConcurrency: response.session_start_limit.max_concurrency,
+        },
+      }));
+  }
+
+  /** https://discord.com/developers/docs/resources/guild#get-guild */
+  async getGuild(
+    guildId: string,
+    options?: {
+      withCounts?: boolean;
+    }
+  ): Promise<Guild> {
+    return new Guild(
+      await this.rest.get<RawGuild>(Endpoints.guild(guildId), {
+        query: {
+          with_counts: options?.withCounts,
+        },
+      }),
+      this
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/user#get-current-user-guilds */
+  async getGuilds(options?: {
+    before?: string;
+    after?: string;
+    limit?: number;
+    withCounts?: boolean;
+  }): Promise<Array<Guild>> {
+    return this.rest
+      .get<Array<RawGuild>>(Endpoints.userGuilds(), {
+        query: {
+          before: options?.before,
+          after: options?.after,
+          limit: options?.limit,
+          with_counts: options?.withCounts,
+        },
+      })
+      .then((response) => response.map((data) => new Guild(data, this)));
+  }
+
+  /** https://discord.com/developers/docs/resources/invite#get-invite */
+  async getInvite(
+    code: string,
+    options?: {
+      withCounts?: boolean;
+      withExpiration?: boolean;
+      guildScheduledEventId?: string;
+    }
+  ): Promise<Invite> {
+    return new Invite(
+      await this.rest.get<RawInvite>(Endpoints.invite(code), {
+        query: {
+          with_counts: options?.withCounts,
+          with_expiration: options?.withExpiration,
+          guild_scheduled_event_id: options?.guildScheduledEventId,
+        },
+      }),
+      this
+    );
+  }
+
+  /** https://discord.com/developers/docs/topics/oauth2#get-current-bot-application-information */
+  async getOAuth2Application(): Promise<Application> {
+    return new Application(
+      await this.rest.get<RawApplication>(Endpoints.oauth2CurrentApplication()),
+      this
+    );
+  }
+
+  /** https://discord.com/developers/docs/topics/oauth2#get-current-authorization-information */
+  async getOAuth2Authorization(): Promise<{
+    application: Application;
+    scopes: Array<OAuth2Scopes>;
+    expires: string;
+    user?: User;
+  }> {
+    return this.rest
+      .get<{
+        application: RawApplication;
+        scopes: Array<OAuth2Scopes>;
+        expires: string;
+        user?: RawUser;
+      }>(Endpoints.oauth2Authorization())
+      .then((response) => ({
+        application: new Application(response.application, this),
+        scopes: response.scopes,
+        expires: response.expires,
+        user:
+          response.user !== undefined
+            ? new User(response.user, this)
+            : undefined,
+      }));
+  }
+
+  /** https://discord.com/developers/docs/resources/stage-instance#get-stage-instance */
+  async getStageInstance(channelId: string): Promise<StageInstance> {
+    return new StageInstance(
+      await this.rest.get<RawStageInstance>(Endpoints.stageInstance(channelId)),
+      this
+    );
+  }
+
+  /** https://discord.com/developers/docs/resources/sticker#list-sticker-packs */
+  async getStickerPacks(): Promise<{
+    stickerPacks: Array<JSONStickerPack>;
+  }> {
+    return this.rest
+      .get<{
+        sticker_packs: Array<RawStickerPack>;
+      }>(Endpoints.stickerPacks())
+      .then((response) => ({
+        stickerPacks: response.sticker_packs.map((stickerPack) => ({
+          id: stickerPack.id,
+          stickers: stickerPack.stickers.map((sticker) => ({
+            id: sticker.id,
+            packId: sticker.pack_id,
+            name: sticker.name,
+            description: sticker.description,
+            tags: sticker.tags,
+            asset: sticker.asset,
+            type: sticker.type,
+            formatType: sticker.format_type,
+            available: sticker.available,
+            guildId: sticker.guild_id,
+            user:
+              sticker.user !== undefined
+                ? new User(sticker.user, this).toJSON()
+                : undefined,
+            sortValue: sticker.sort_value,
+          })),
+          name: stickerPack.name,
+          skuId: stickerPack.sku_id,
+          coverStickerId: stickerPack.cover_sticker_id,
+          description: stickerPack.description,
+          bannerAssetId: stickerPack.banner_asset_id,
+        })),
+      }));
+  }
+
+  /** https://discord.com/developers/docs/resources/user#get-user */
+  async getUser(userId?: string): Promise<User> {
+    return new User(await this.rest.get<RawUser>(Endpoints.user(userId)), this);
+  }
+
+  /** https://discord.com/developers/docs/resources/voice#list-voice-regions */
+  async getVoiceRegions(): Promise<Array<JSONVoiceRegion>> {
+    return this.rest
+      .get<Array<RawVoiceRegion>>(Endpoints.voiceRegions())
+      .then((response) =>
+        response.map((data) => ({
+          id: data.id,
+          name: data.name,
+          optimal: data.optimal,
+          deprecated: data.deprecated,
+          custom: data.custom,
+        }))
+      );
+  }
+
+  /** https://discord.com/developers/docs/topics/gateway-events#update-voice-state */
+  joinVoiceChannel(
+    guildId: string,
+    channelId: string,
+    options?: {
+      selfMute?: boolean;
+      selfDeaf?: boolean;
+    }
+  ): void {
+    this.shards.get(this.guildSharding[guildId])?.ws.send(
+      JSON.stringify({
+        op: GatewayOPCodes.VoiceStateUpdate,
+        d: {
+          guild_id: guildId,
+          channel_id: channelId,
+          self_mute: !!options?.selfMute,
+          self_deaf: !!options?.selfDeaf,
+        },
+      })
+    );
+  }
+
+  /** https://discord.com/developers/docs/topics/gateway-events#update-voice-state */
+  leaveVoiceChannel(guildId: string): void {
+    this.shards.get(this.guildSharding[guildId])?.ws.send(
+      JSON.stringify({
+        op: GatewayOPCodes.VoiceStateUpdate,
+        d: {
+          guild_id: guildId,
+          channel_id: null,
+          self_mute: false,
+          self_deaf: false,
+        },
+      })
+    );
+  }
+
+  /** https://discord.com/developers/docs/topics/gateway-events#update-presence */
+  setPresence(options: {
+    activity?: Pick<Activity, "name" | "type" | "url" | "state">;
+    status?: StatusTypes;
+    afk?: boolean;
+  }): void {
+    for (const [id, shard] of this.shards) shard.setPresence(options);
+  }
+
+  /** https://discord.com/developers/docs/topics/gateway#connections */
+  async connect(): Promise<void> {
+    this.shardsCount =
+      this.shardsCount === "auto"
+        ? (await this.getGatewayBot()).shards
+        : this.shardsCount;
+
+    for (let i = 0; i < this.shardsCount; i++)
+      this.shards.set(i, new Shard(i, this));
+
+    this.shards.connect();
+  }
+
+  disconnect(): void {
+    this.shards.disconnect();
+  }
+}
+
+export declare interface Client extends EventEmitter {
+  addListener<K extends keyof ClientEvents>(
+    eventName: K,
+    listener: (...args: ClientEvents[K]) => void
+  ): this;
+  emit<K extends keyof ClientEvents>(
+    eventName: K,
+    ...args: ClientEvents[K]
+  ): boolean;
+  listenerCount(eventName: keyof ClientEvents): number;
+  listeners(eventName: keyof ClientEvents): Array<Function>;
+  off<K extends keyof ClientEvents>(
+    eventName: K,
+    listener: (...args: ClientEvents[K]) => void
+  ): this;
+  on<K extends keyof ClientEvents>(
+    eventName: K,
+    listener: (...args: ClientEvents[K]) => void
+  ): this;
+  once<K extends keyof ClientEvents>(
+    eventName: K,
+    listener: (...args: ClientEvents[K]) => void
+  ): this;
+  prependListener<K extends keyof ClientEvents>(
+    eventName: K,
+    listener: (...args: ClientEvents[K]) => void
+  ): this;
+  prependOnceListener<K extends keyof ClientEvents>(
+    eventName: K,
+    listener: (...args: ClientEvents[K]) => void
+  ): this;
+  rawListeners(eventName: keyof ClientEvents): Array<Function>;
+  removeAllListeners(event?: keyof ClientEvents): this;
+  removeListener<K extends keyof ClientEvents>(
+    eventName: K,
+    listener: (...args: ClientEvents[K]) => void
+  ): this;
+}