Prettified Code!

src/handlers/channels/CHANNEL_DELETE.ts

@@ -8,16 +8,10 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 export async function handleChannelDelete(data: DiscordGatewayPayload) {
   const payload = data.d as Channel;
 
-  const cachedChannel = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.id)
-  );
+  const cachedChannel = await cacheHandlers.get("channels", snowflakeToBigint(payload.id));
   if (!cachedChannel) return;
 
-  if (
-    cachedChannel.type === DiscordChannelTypes.GuildVoice &&
-    payload.guildId
-  ) {
+  if (cachedChannel.type === DiscordChannelTypes.GuildVoice && payload.guildId) {
     const guild = await cacheHandlers.get("guilds", cachedChannel.guildId);
 
     if (guild) {
@@ -47,10 +41,7 @@ export async function handleChannelDelete(data: DiscordGatewayPayload) {
   ) {
     await cacheHandlers.delete("channels", snowflakeToBigint(payload.id));
     cacheHandlers.forEach("messages", (message) => {
-      eventHandlers.debug?.(
-        "loop",
-        `Running forEach messages loop in CHANNEL_DELTE file.`
-      );
+      eventHandlers.debug?.("loop", `Running forEach messages loop in CHANNEL_DELTE file.`);
       if (message.channelId === snowflakeToBigint(payload.id)) {
         cacheHandlers.delete("messages", message.id);
       }

src/handlers/channels/CHANNEL_PINS_UPDATE.ts

@@ -7,15 +7,10 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 export async function handleChannelPinsUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as ChannelPinsUpdate;
 
-  const channel = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.channelId)
-  );
+  const channel = await cacheHandlers.get("channels", snowflakeToBigint(payload.channelId));
   if (!channel) return;
 
-  const guild = payload.guildId
-    ? await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId))
-    : undefined;
+  const guild = payload.guildId ? await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId)) : undefined;
 
   eventHandlers.channelPinsUpdate?.(channel, guild, payload.lastPinTimestamp);
 }

src/handlers/channels/CHANNEL_UPDATE.ts

@@ -7,10 +7,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleChannelUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as Channel;
-  const cachedChannel = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.id)
-  );
+  const cachedChannel = await cacheHandlers.get("channels", snowflakeToBigint(payload.id));
   if (!cachedChannel) return;
 
   const discordenoChannel = await structures.createDiscordenoChannel(payload);

src/handlers/channels/THREAD_DELETE.ts

@@ -7,18 +7,12 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 export async function handleThreadDelete(data: DiscordGatewayPayload) {
   const payload = data.d as Channel;
 
-  const cachedChannel = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.id)
-  );
+  const cachedChannel = await cacheHandlers.get("channels", snowflakeToBigint(payload.id));
   if (!cachedChannel) return;
 
   await cacheHandlers.delete("channels", snowflakeToBigint(payload.id));
   cacheHandlers.forEach("messages", (message) => {
-    eventHandlers.debug?.(
-      "loop",
-      `Running forEach messages loop in CHANNEL_DELTE file.`
-    );
+    eventHandlers.debug?.("loop", `Running forEach messages loop in CHANNEL_DELTE file.`);
     if (message.channelId === snowflakeToBigint(payload.id)) {
       cacheHandlers.delete("messages", message.id);
     }

src/handlers/channels/THREAD_LIST_SYNC.ts

@@ -12,28 +12,15 @@ export async function handleThreadListSync(data: DiscordGatewayPayload) {
 
   const discordenoChannels = await Promise.all(
     payload.threads.map(async (thread) => {
-      const discordenoChannel = await structures.createDiscordenoChannel(
-        thread,
-        snowflakeToBigint(payload.guildId)
-      );
+      const discordenoChannel = await structures.createDiscordenoChannel(thread, snowflakeToBigint(payload.guildId));
 
-      await cacheHandlers.set(
-        "channels",
-        discordenoChannel.id,
-        discordenoChannel
-      );
+      await cacheHandlers.set("channels", discordenoChannel.id, discordenoChannel);
 
       return discordenoChannel;
     })
   );
 
-  const threads = new Collection<bigint, DiscordenoChannel>(
-    discordenoChannels.map((t) => [t.id, t])
-  );
+  const threads = new Collection<bigint, DiscordenoChannel>(discordenoChannels.map((t) => [t.id, t]));
 
-  eventHandlers.threadListSync?.(
-    threads,
-    payload.members,
-    snowflakeToBigint(payload.guildId)
-  );
+  eventHandlers.threadListSync?.(threads, payload.members, snowflakeToBigint(payload.guildId));
 }

src/handlers/channels/THREAD_MEMBERS_UPDATE.ts

@@ -6,10 +6,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleThreadMembersUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as ThreadMembersUpdate;
-  const thread = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.id)
-  );
+  const thread = await cacheHandlers.get("channels", snowflakeToBigint(payload.id));
   if (!thread) return;
 
   thread.memberCount = payload.memberCount;

src/handlers/channels/THREAD_MEMBER_UPDATE.ts

@@ -6,10 +6,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleThreadMemberUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as ThreadMember;
-  const thread = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.id)
-  );
+  const thread = await cacheHandlers.get("channels", snowflakeToBigint(payload.id));
   if (!thread) return;
 
   thread.member = payload;

src/handlers/channels/THREAD_UPDATE.ts

@@ -7,10 +7,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleThreadUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as Channel;
-  const oldChannel = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.id)
-  );
+  const oldChannel = await cacheHandlers.get("channels", snowflakeToBigint(payload.id));
   if (!oldChannel) return;
 
   const discordenoChannel = await structures.createDiscordenoChannel(payload);

src/handlers/commands/APPLICATION_COMMAND_CREATE.ts

@@ -3,7 +3,5 @@ import type { DiscordGatewayPayload } from "../../types/gateway/gateway_payload.
 import type { ApplicationCommandCreateUpdateDelete } from "../../types/interactions/commands/application_command_create_update_delete.ts";
 
 export function handleApplicationCommandCreate(data: DiscordGatewayPayload) {
-  eventHandlers.applicationCommandCreate?.(
-    data.d as ApplicationCommandCreateUpdateDelete
-  );
+  eventHandlers.applicationCommandCreate?.(data.d as ApplicationCommandCreateUpdateDelete);
 }

src/handlers/commands/APPLICATION_COMMAND_DELETE.ts

@@ -3,7 +3,5 @@ import type { DiscordGatewayPayload } from "../../types/gateway/gateway_payload.
 import type { ApplicationCommandCreateUpdateDelete } from "../../types/interactions/commands/application_command_create_update_delete.ts";
 
 export function handleApplicationCommandDelete(data: DiscordGatewayPayload) {
-  eventHandlers.applicationCommandDelete?.(
-    data.d as ApplicationCommandCreateUpdateDelete
-  );
+  eventHandlers.applicationCommandDelete?.(data.d as ApplicationCommandCreateUpdateDelete);
 }

src/handlers/commands/APPLICATION_COMMAND_UPDATE.ts

@@ -3,7 +3,5 @@ import type { DiscordGatewayPayload } from "../../types/gateway/gateway_payload.
 import type { ApplicationCommandCreateUpdateDelete } from "../../types/interactions/commands/application_command_create_update_delete.ts";
 
 export function handleApplicationCommandUpdate(data: DiscordGatewayPayload) {
-  eventHandlers.applicationCommandUpdate?.(
-    data.d as ApplicationCommandCreateUpdateDelete
-  );
+  eventHandlers.applicationCommandUpdate?.(data.d as ApplicationCommandCreateUpdateDelete);
 }

src/handlers/emojis/GUILD_EMOJIS_UPDATE.ts

@@ -7,16 +7,11 @@ import { Collection } from "../../util/collection.ts";
 
 export async function handleGuildEmojisUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as GuildEmojisUpdate;
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
   const cachedEmojis = guild.emojis;
-  guild.emojis = new Collection(
-    payload.emojis.map((emoji) => [snowflakeToBigint(emoji.id!), emoji])
-  );
+  guild.emojis = new Collection(payload.emojis.map((emoji) => [snowflakeToBigint(emoji.id!), emoji]));
 
   await cacheHandlers.set("guilds", guild.id, guild);
 

src/handlers/guilds/GUILD_BAN_ADD.ts

@@ -6,15 +6,9 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleGuildBanAdd(data: DiscordGatewayPayload) {
   const payload = data.d as GuildBanAddRemove;
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
-  const member = await cacheHandlers.get(
-    "members",
-    snowflakeToBigint(payload.user.id)
-  );
+  const member = await cacheHandlers.get("members", snowflakeToBigint(payload.user.id));
   eventHandlers.guildBanAdd?.(guild, payload.user, member);
 }

src/handlers/guilds/GUILD_BAN_REMOVE.ts

@@ -6,15 +6,9 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleGuildBanRemove(data: DiscordGatewayPayload) {
   const payload = data.d as GuildBanAddRemove;
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
-  const member = await cacheHandlers.get(
-    "members",
-    snowflakeToBigint(payload.user.id)
-  );
+  const member = await cacheHandlers.get("members", snowflakeToBigint(payload.user.id));
   eventHandlers.guildBanRemove?.(guild, payload.user, member);
 }

src/handlers/guilds/GUILD_CREATE.ts

@@ -6,10 +6,7 @@ import type { Guild } from "../../types/guilds/guild.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
 import { ws } from "../../ws/ws.ts";
 
-export async function handleGuildCreate(
-  data: DiscordGatewayPayload,
-  shardId: number
-) {
+export async function handleGuildCreate(data: DiscordGatewayPayload, shardId: number) {
   const payload = data.d as Guild;
   // When shards resume they emit GUILD_CREATE again.
   if (await cacheHandlers.has("guilds", snowflakeToBigint(payload.id))) return;

src/handlers/guilds/GUILD_DELETE.ts

@@ -5,16 +5,10 @@ import type { UnavailableGuild } from "../../types/guilds/unavailable_guild.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
 import { ws } from "../../ws/ws.ts";
 
-export async function handleGuildDelete(
-  data: DiscordGatewayPayload,
-  shardId: number
-) {
+export async function handleGuildDelete(data: DiscordGatewayPayload, shardId: number) {
   const payload = data.d as UnavailableGuild;
 
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.id)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.id));
   if (!guild) return;
 
   await cacheHandlers.delete("guilds", guild.id);
@@ -30,30 +24,21 @@ export async function handleGuildDelete(
   }
 
   cacheHandlers.forEach("messages", (message) => {
-    eventHandlers.debug?.(
-      "loop",
-      `1. Running forEach messages loop in CHANNEL_DELTE file.`
-    );
+    eventHandlers.debug?.("loop", `1. Running forEach messages loop in CHANNEL_DELTE file.`);
     if (message.guildId === guild.id) {
       cacheHandlers.delete("messages", message.id);
     }
   });
 
   cacheHandlers.forEach("channels", (channel) => {
-    eventHandlers.debug?.(
-      "loop",
-      `2. Running forEach channels loop in CHANNEL_DELTE file.`
-    );
+    eventHandlers.debug?.("loop", `2. Running forEach channels loop in CHANNEL_DELTE file.`);
     if (channel.guildId === guild.id) {
       cacheHandlers.delete("channels", channel.id);
     }
   });
 
   cacheHandlers.forEach("members", (member) => {
-    eventHandlers.debug?.(
-      "loop",
-      `3. Running forEach members loop in CHANNEL_DELTE file.`
-    );
+    eventHandlers.debug?.("loop", `3. Running forEach members loop in CHANNEL_DELTE file.`);
     if (!member.guilds.has(guild.id)) return;
 
     member.guilds.delete(guild.id);

src/handlers/guilds/GUILD_INTEGRATIONS_UPDATE.ts

@@ -4,15 +4,10 @@ import type { DiscordGatewayPayload } from "../../types/gateway/gateway_payload.
 import type { GuildIntegrationsUpdate } from "../../types/integrations/guild_integrations_update.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
 
-export async function handleGuildIntegrationsUpdate(
-  data: DiscordGatewayPayload
-) {
+export async function handleGuildIntegrationsUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as GuildIntegrationsUpdate;
 
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
   eventHandlers.guildIntegrationsUpdate?.(guild);

src/handlers/guilds/GUILD_UPDATE.ts

@@ -6,25 +6,12 @@ import type { DiscordGatewayPayload } from "../../types/gateway/gateway_payload.
 import type { Guild } from "../../types/guilds/guild.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
 
-export async function handleGuildUpdate(
-  data: DiscordGatewayPayload,
-  shardId: number
-) {
+export async function handleGuildUpdate(data: DiscordGatewayPayload, shardId: number) {
   const payload = data.d as Guild;
-  const oldGuild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.id)
-  );
+  const oldGuild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.id));
   if (!oldGuild) return;
 
-  const keysToSkip = [
-    "id",
-    "roles",
-    "guildHashes",
-    "guildId",
-    "maxMembers",
-    "emojis",
-  ];
+  const keysToSkip = ["id", "roles", "guildHashes", "guildId", "maxMembers", "emojis"];
 
   const newGuild = await structures.createDiscordenoGuild(payload, shardId);
 

src/handlers/interactions/INTERACTION_CREATE.ts

@@ -9,10 +9,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 export async function handleInteractionCreate(data: DiscordGatewayPayload) {
   const payload = data.d as Interaction;
   const discordenoMember = payload.guildId
-    ? await structures.createDiscordenoMember(
-        payload.member as GuildMemberWithUser,
-        snowflakeToBigint(payload.guildId)
-      )
+    ? await structures.createDiscordenoMember(payload.member as GuildMemberWithUser, snowflakeToBigint(payload.guildId))
     : undefined;
   if (discordenoMember) {
     await cacheHandlers.set("members", discordenoMember.id, discordenoMember);

src/handlers/members/GUILD_MEMBERS_CHUNK.ts

@@ -12,10 +12,7 @@ export async function handleGuildMembersChunk(data: DiscordGatewayPayload) {
 
   const members = await Promise.all(
     payload.members.map(async (member) => {
-      const discordenoMember = await structures.createDiscordenoMember(
-        member,
-        guildId
-      );
+      const discordenoMember = await structures.createDiscordenoMember(member, guildId);
       await cacheHandlers.set("members", discordenoMember.id, discordenoMember);
 
       return discordenoMember;
@@ -34,9 +31,7 @@ export async function handleGuildMembersChunk(data: DiscordGatewayPayload) {
         return resolve(new Collection(members.map((m) => [m.id, m])));
       }
 
-      return resolve(
-        await cacheHandlers.filter("members", (m) => m.guilds.has(guildId))
-      );
+      return resolve(await cacheHandlers.filter("members", (m) => m.guilds.has(guildId)));
     }
   }
 }

src/handlers/members/GUILD_MEMBER_ADD.ts

@@ -7,17 +7,11 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleGuildMemberAdd(data: DiscordGatewayPayload) {
   const payload = data.d as GuildMemberAdd;
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
   guild.memberCount++;
-  const discordenoMember = await structures.createDiscordenoMember(
-    payload,
-    guild.id
-  );
+  const discordenoMember = await structures.createDiscordenoMember(payload, guild.id);
   await cacheHandlers.set("members", discordenoMember.id, discordenoMember);
 
   eventHandlers.guildMemberAdd?.(guild, discordenoMember);

src/handlers/members/GUILD_MEMBER_REMOVE.ts

@@ -6,17 +6,11 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleGuildMemberRemove(data: DiscordGatewayPayload) {
   const payload = data.d as GuildMemberRemove;
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
   guild.memberCount--;
-  const member = await cacheHandlers.get(
-    "members",
-    snowflakeToBigint(payload.user.id)
-  );
+  const member = await cacheHandlers.get("members", snowflakeToBigint(payload.user.id));
   eventHandlers.guildMemberRemove?.(guild, payload.user, member);
 
   member?.guilds.delete(guild.id);

src/handlers/members/GUILD_MEMBER_UPDATE.ts

@@ -7,16 +7,10 @@ import { bigintToSnowflake, snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleGuildMemberUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as GuildMemberUpdate;
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
-  const cachedMember = await cacheHandlers.get(
-    "members",
-    snowflakeToBigint(payload.user.id)
-  );
+  const cachedMember = await cacheHandlers.get("members", snowflakeToBigint(payload.user.id));
   const guildMember = cachedMember?.guilds.get(guild.id);
 
   const newMemberData = {
@@ -27,20 +21,12 @@ export async function handleGuildMemberUpdate(data: DiscordGatewayPayload) {
     mute: guildMember?.mute || false,
     roles: payload.roles,
   };
-  const discordenoMember = await structures.createDiscordenoMember(
-    newMemberData,
-    guild.id
-  );
+  const discordenoMember = await structures.createDiscordenoMember(newMemberData, guild.id);
   await cacheHandlers.set("members", discordenoMember.id, discordenoMember);
 
   if (guildMember) {
     if (guildMember.nick !== payload.nick) {
-      eventHandlers.nicknameUpdate?.(
-        guild,
-        discordenoMember,
-        payload.nick!,
-        guildMember.nick ?? undefined
-      );
+      eventHandlers.nicknameUpdate?.(guild, discordenoMember, payload.nick!, guildMember.nick ?? undefined);
     }
 
     if (payload.pending === false && guildMember.pending === true) {
@@ -50,26 +36,16 @@ export async function handleGuildMemberUpdate(data: DiscordGatewayPayload) {
     const roleIds = guildMember.roles || [];
 
     roleIds.forEach((id) => {
-      eventHandlers.debug?.(
-        "loop",
-        `1. Running forEach loop in GUILD_MEMBER_UPDATE file.`
-      );
+      eventHandlers.debug?.("loop", `1. Running forEach loop in GUILD_MEMBER_UPDATE file.`);
       if (!payload.roles.includes(bigintToSnowflake(id))) {
         eventHandlers.roleLost?.(guild, discordenoMember, id);
       }
     });
 
     payload.roles.forEach((id) => {
-      eventHandlers.debug?.(
-        "loop",
-        `2. Running forEach loop in GUILD_MEMBER_UPDATE file.`
-      );
+      eventHandlers.debug?.("loop", `2. Running forEach loop in GUILD_MEMBER_UPDATE file.`);
       if (!roleIds.includes(snowflakeToBigint(id))) {
-        eventHandlers.roleGained?.(
-          guild,
-          discordenoMember,
-          snowflakeToBigint(id)
-        );
+        eventHandlers.roleGained?.(guild, discordenoMember, snowflakeToBigint(id));
       }
     });
   }

src/handlers/messages/MESSAGE_CREATE.ts

@@ -8,15 +8,10 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleMessageCreate(data: DiscordGatewayPayload) {
   const payload = data.d as Message;
-  const channel = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.channelId)
-  );
+  const channel = await cacheHandlers.get("channels", snowflakeToBigint(payload.channelId));
   if (channel) channel.lastMessageId = snowflakeToBigint(payload.id);
 
-  const guild = payload.guildId
-    ? await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId))
-    : undefined;
+  const guild = payload.guildId ? await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId)) : undefined;
 
   if (payload.member && guild) {
     // If in a guild cache the author as a member
@@ -37,11 +32,7 @@ export async function handleMessageCreate(data: DiscordGatewayPayload) {
             guild.id
           );
 
-          return cacheHandlers.set(
-            "members",
-            snowflakeToBigint(mention.id),
-            discordenoMember
-          );
+          return cacheHandlers.set("members", snowflakeToBigint(mention.id), discordenoMember);
         }
       })
     );

src/handlers/messages/MESSAGE_DELETE.ts

@@ -6,10 +6,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleMessageDelete(data: DiscordGatewayPayload) {
   const payload = data.d as MessageDelete;
-  const channel = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.channelId)
-  );
+  const channel = await cacheHandlers.get("channels", snowflakeToBigint(payload.channelId));
   if (!channel) return;
 
   eventHandlers.messageDelete?.(

src/handlers/messages/MESSAGE_DELETE_BULK.ts

@@ -6,18 +6,12 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleMessageDeleteBulk(data: DiscordGatewayPayload) {
   const payload = data.d as MessageDeleteBulk;
-  const channel = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.channelId)
-  );
+  const channel = await cacheHandlers.get("channels", snowflakeToBigint(payload.channelId));
   if (!channel) return;
 
   return Promise.all(
     payload.ids.map(async (id) => {
-      eventHandlers.messageDelete?.(
-        { id, channel },
-        await cacheHandlers.get("messages", snowflakeToBigint(id))
-      );
+      eventHandlers.messageDelete?.({ id, channel }, await cacheHandlers.get("messages", snowflakeToBigint(id)));
       await cacheHandlers.delete("messages", snowflakeToBigint(id));
     })
   );

src/handlers/messages/MESSAGE_REACTION_ADD.ts

@@ -7,16 +7,11 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleMessageReactionAdd(data: DiscordGatewayPayload) {
   const payload = data.d as MessageReactionAdd;
-  const message = await cacheHandlers.get(
-    "messages",
-    snowflakeToBigint(payload.messageId)
-  );
+  const message = await cacheHandlers.get("messages", snowflakeToBigint(payload.messageId));
 
   if (message) {
     const reactionExisted = message.reactions?.find(
-      (reaction) =>
-        reaction.emoji.id === payload.emoji.id &&
-        reaction.emoji.name === payload.emoji.name
+      (reaction) => reaction.emoji.id === payload.emoji.id && reaction.emoji.name === payload.emoji.name
     );
 
     if (reactionExisted) reactionExisted.count++;
@@ -26,28 +21,16 @@ export async function handleMessageReactionAdd(data: DiscordGatewayPayload) {
         me: snowflakeToBigint(payload.userId) === botId,
         emoji: { ...payload.emoji, id: payload.emoji.id || undefined },
       };
-      message.reactions = message.reactions
-        ? [...message.reactions, newReaction]
-        : [newReaction];
+      message.reactions = message.reactions ? [...message.reactions, newReaction] : [newReaction];
     }
 
-    await cacheHandlers.set(
-      "messages",
-      snowflakeToBigint(payload.messageId),
-      message
-    );
+    await cacheHandlers.set("messages", snowflakeToBigint(payload.messageId), message);
   }
 
   if (payload.member && payload.guildId) {
-    const guild = await cacheHandlers.get(
-      "guilds",
-      snowflakeToBigint(payload.guildId)
-    );
+    const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
     if (guild) {
-      const discordenoMember = await structures.createDiscordenoMember(
-        payload.member,
-        guild.id
-      );
+      const discordenoMember = await structures.createDiscordenoMember(payload.member, guild.id);
       await cacheHandlers.set("members", discordenoMember.id, discordenoMember);
     }
   }

src/handlers/messages/MESSAGE_REACTION_REMOVE.ts

@@ -6,17 +6,13 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleMessageReactionRemove(data: DiscordGatewayPayload) {
   const payload = data.d as MessageReactionRemove;
-  const message = await cacheHandlers.get(
-    "messages",
-    snowflakeToBigint(payload.messageId)
-  );
+  const message = await cacheHandlers.get("messages", snowflakeToBigint(payload.messageId));
 
   if (message) {
     const reaction = message.reactions?.find(
       (reaction) =>
         // MUST USE == because discord sends null and we use undefined
-        reaction.emoji.id == payload.emoji.id &&
-        reaction.emoji.name === payload.emoji.name
+        reaction.emoji.id == payload.emoji.id && reaction.emoji.name === payload.emoji.name
     );
 
     if (reaction) {

src/handlers/messages/MESSAGE_REACTION_REMOVE_ALL.ts

@@ -4,23 +4,14 @@ import type { DiscordGatewayPayload } from "../../types/gateway/gateway_payload.
 import type { MessageReactionRemoveAll } from "../../types/messages/message_reaction_remove_all.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
 
-export async function handleMessageReactionRemoveAll(
-  data: DiscordGatewayPayload
-) {
+export async function handleMessageReactionRemoveAll(data: DiscordGatewayPayload) {
   const payload = data.d as MessageReactionRemoveAll;
-  const message = await cacheHandlers.get(
-    "messages",
-    snowflakeToBigint(payload.messageId)
-  );
+  const message = await cacheHandlers.get("messages", snowflakeToBigint(payload.messageId));
 
   if (message?.reactions) {
     message.reactions = undefined;
 
-    await cacheHandlers.set(
-      "messages",
-      snowflakeToBigint(payload.messageId),
-      message
-    );
+    await cacheHandlers.set("messages", snowflakeToBigint(payload.messageId), message);
   }
 
   eventHandlers.reactionRemoveAll?.(payload, message);

src/handlers/messages/MESSAGE_REACTION_REMOVE_EMOJI.ts

@@ -4,24 +4,16 @@ import type { DiscordGatewayPayload } from "../../types/gateway/gateway_payload.
 import type { MessageReactionRemoveEmoji } from "../../types/messages/message_reaction_remove_emoji.ts";
 import { snowflakeToBigint } from "../../util/bigint.ts";
 
-export async function handleMessageReactionRemoveEmoji(
-  data: DiscordGatewayPayload
-) {
+export async function handleMessageReactionRemoveEmoji(data: DiscordGatewayPayload) {
   const payload = data.d as MessageReactionRemoveEmoji;
-  const message = await cacheHandlers.get(
-    "messages",
-    snowflakeToBigint(payload.messageId)
-  );
+  const message = await cacheHandlers.get("messages", snowflakeToBigint(payload.messageId));
 
   if (message?.reactions) {
     message.reactions = message.reactions.filter(
       (reaction) =>
         !(
           // MUST USE == because discord sends null and we use undefined
-          (
-            reaction.emoji.id == payload.emoji.id &&
-            reaction.emoji.name === payload.emoji.name
-          )
+          (reaction.emoji.id == payload.emoji.id && reaction.emoji.name === payload.emoji.name)
         )
     );
 

src/handlers/messages/MESSAGE_UPDATE.ts

@@ -7,16 +7,10 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleMessageUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as Message;
-  const channel = await cacheHandlers.get(
-    "channels",
-    snowflakeToBigint(payload.channelId)
-  );
+  const channel = await cacheHandlers.get("channels", snowflakeToBigint(payload.channelId));
   if (!channel) return;
 
-  const oldMessage = await cacheHandlers.get(
-    "messages",
-    snowflakeToBigint(payload.id)
-  );
+  const oldMessage = await cacheHandlers.get("messages", snowflakeToBigint(payload.id));
   if (!oldMessage) return;
 
   // Messages with embeds can trigger update but they wont have edited_timestamp

src/handlers/misc/PRESENCE_UPDATE.ts

@@ -7,15 +7,8 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 export async function handlePresenceUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as PresenceUpdate;
 
-  const oldPresence = await cacheHandlers.get(
-    "presences",
-    snowflakeToBigint(payload.user.id)
-  );
-  await cacheHandlers.set(
-    "presences",
-    snowflakeToBigint(payload.user.id),
-    payload
-  );
+  const oldPresence = await cacheHandlers.get("presences", snowflakeToBigint(payload.user.id));
+  await cacheHandlers.set("presences", snowflakeToBigint(payload.user.id), payload);
 
   eventHandlers.presenceUpdate?.(payload, oldPresence);
 }

src/handlers/misc/READY.ts

@@ -22,9 +22,7 @@ export function handleReady(data: DiscordGatewayPayload, shardId: number) {
   // Set ready to false just to go sure
   shard.ready = false;
   // All guilds are unavailable at first
-  shard.unavailableGuildIds = new Set(
-    payload.guilds.map((g) => snowflakeToBigint(g.id))
-  );
+  shard.unavailableGuildIds = new Set(payload.guilds.map((g) => snowflakeToBigint(g.id)));
   // Set the last available to now
   shard.lastAvailable = Date.now();
 

src/handlers/misc/USER_UPDATE.ts

@@ -7,10 +7,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 export async function handleUserUpdate(data: DiscordGatewayPayload) {
   const userData = data.d as User;
 
-  const member = await cacheHandlers.get(
-    "members",
-    snowflakeToBigint(userData.id)
-  );
+  const member = await cacheHandlers.get("members", snowflakeToBigint(userData.id));
   if (!member) return;
 
   Object.entries(userData).forEach(([key, value]) => {

src/handlers/roles/GUILD_ROLE_CREATE.ts

@@ -7,10 +7,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleGuildRoleCreate(data: DiscordGatewayPayload) {
   const payload = data.d as GuildRoleCreate;
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
   const role = await structures.createDiscordenoRole({

src/handlers/roles/GUILD_ROLE_DELETE.ts

@@ -6,10 +6,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleGuildRoleDelete(data: DiscordGatewayPayload) {
   const payload = data.d as GuildRoleDelete;
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
   const roleId = snowflakeToBigint(payload.roleId);
@@ -21,18 +18,12 @@ export async function handleGuildRoleDelete(data: DiscordGatewayPayload) {
 
   // For bots without GUILD_MEMBERS member.roles is never updated breaking permissions checking.
   cacheHandlers.forEach("members", (member) => {
-    eventHandlers.debug?.(
-      "loop",
-      `1. Running forEach members loop in GUILD_ROLE_DELETE file.`
-    );
+    eventHandlers.debug?.("loop", `1. Running forEach members loop in GUILD_ROLE_DELETE file.`);
     // Not in the relevant guild so just skip.
     if (!member.guilds.has(guild.id)) return;
 
     member.guilds.forEach((g) => {
-      eventHandlers.debug?.(
-        "loop",
-        `2. Running forEach loop in CHANNEL_DELTE file.`
-      );
+      eventHandlers.debug?.("loop", `2. Running forEach loop in CHANNEL_DELTE file.`);
       // Member does not have this role
       if (!g.roles.includes(roleId)) return;
       // Remove this role from the members cache

src/handlers/roles/GUILD_ROLE_UPDATE.ts

@@ -7,10 +7,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export async function handleGuildRoleUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as GuildRoleUpdate;
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
   const cachedRole = guild.roles.get(snowflakeToBigint(payload.role.id));

src/handlers/voice/VOICE_SERVER_UPDATE.ts

@@ -7,10 +7,7 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 export async function handleVoiceServerUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as VoiceServerUpdate;
 
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
   eventHandlers.voiceServerUpdate?.(payload, guild);

src/handlers/voice/VOICE_STATE_UPDATE.ts

@@ -9,10 +9,7 @@ export async function handleVoiceStateUpdate(data: DiscordGatewayPayload) {
   const payload = data.d as VoiceState;
   if (!payload.guildId) return;
 
-  const guild = await cacheHandlers.get(
-    "guilds",
-    snowflakeToBigint(payload.guildId)
-  );
+  const guild = await cacheHandlers.get("guilds", snowflakeToBigint(payload.guildId));
   if (!guild) return;
 
   const member = payload.member
@@ -30,25 +27,15 @@ export async function handleVoiceStateUpdate(data: DiscordGatewayPayload) {
 
   await cacheHandlers.set("guilds", guild.id, guild);
 
-  if (
-    cachedState?.channelId !==
-    (payload.channelId ? snowflakeToBigint(payload.channelId) : null)
-  ) {
+  if (cachedState?.channelId !== (payload.channelId ? snowflakeToBigint(payload.channelId) : null)) {
     // Either joined or moved channels
     if (payload.channelId) {
       if (cachedState?.channelId) {
         // Was in a channel before
-        eventHandlers.voiceChannelSwitch?.(
-          member,
-          snowflakeToBigint(payload.channelId),
-          cachedState.channelId
-        );
+        eventHandlers.voiceChannelSwitch?.(member, snowflakeToBigint(payload.channelId), cachedState.channelId);
       } else {
         // Was not in a channel before so user just joined
-        eventHandlers.voiceChannelJoin?.(
-          member,
-          snowflakeToBigint(payload.channelId)
-        );
+        eventHandlers.voiceChannelJoin?.(member, snowflakeToBigint(payload.channelId));
       }
     } // Left the channel
     else if (cachedState?.channelId) {

src/handlers/webhooks/WEBHOOKS_UPDATE.ts

@@ -5,8 +5,5 @@ import { snowflakeToBigint } from "../../util/bigint.ts";
 
 export function handleWebhooksUpdate(data: DiscordGatewayPayload) {
   const options = data.d as WebhookUpdate;
-  eventHandlers.webhooksUpdate?.(
-    snowflakeToBigint(options.channelId),
-    snowflakeToBigint(options.guildId)
-  );
+  eventHandlers.webhooksUpdate?.(snowflakeToBigint(options.channelId), snowflakeToBigint(options.guildId));
 }