refactor: rename controllers to handlers and handlers to helpers (#660)

* refactor: rename controllers to handlers and handlers to helpers

* fmt

src/handlers/guilds/GUILD_BAN_ADD.ts

@@ -0,0 +1,12 @@
+import { eventHandlers } from "../../bot.ts";
+import { DiscordPayload, GuildBanPayload } from "../../types/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildBanAdd(data: DiscordPayload) {
+  const payload = data.d as GuildBanPayload;
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  const member = await cacheHandlers.get("members", payload.user.id);
+  eventHandlers.guildBanAdd?.(guild, payload.user, member);
+}

src/handlers/guilds/GUILD_BAN_REMOVE.ts

@@ -0,0 +1,12 @@
+import { eventHandlers } from "../../bot.ts";
+import { DiscordPayload, GuildBanPayload } from "../../types/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildBanRemove(data: DiscordPayload) {
+  const payload = data.d as GuildBanPayload;
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  const member = await cacheHandlers.get("members", payload.user.id);
+  eventHandlers.guildBanRemove?.(guild, payload.user, member);
+}

src/handlers/guilds/GUILD_CREATE.ts

@@ -0,0 +1,32 @@
+import { eventHandlers } from "../../bot.ts";
+import { CreateGuildPayload, DiscordPayload } from "../../types/mod.ts";
+import { cache } from "../../util/cache.ts";
+import { basicShards } from "../../ws/shard.ts";
+import { structures } from "../../structures/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildCreate(
+  data: DiscordPayload,
+  shardID: number,
+) {
+  const payload = data.d as CreateGuildPayload;
+  // When shards resume they emit GUILD_CREATE again.
+  if (await cacheHandlers.has("guilds", payload.id)) return;
+
+  const guildStruct = await structures.createGuildStruct(
+    data.d as CreateGuildPayload,
+    shardID,
+  );
+  await cacheHandlers.set("guilds", guildStruct.id, guildStruct);
+
+  const shard = basicShards.get(shardID);
+
+  if (shard?.unavailableGuildIDs.has(payload.id)) {
+    await cacheHandlers.delete("unavailableGuilds", payload.id);
+
+    shard.unavailableGuildIDs.delete(payload.id);
+  }
+
+  if (!cache.isReady) return eventHandlers.guildLoaded?.(guildStruct);
+  eventHandlers.guildCreate?.(guildStruct);
+}

src/handlers/guilds/GUILD_DELETE.ts

@@ -0,0 +1,49 @@
+import { eventHandlers } from "../../bot.ts";
+import { DiscordPayload, GuildDeletePayload } from "../../types/mod.ts";
+import { basicShards } from "../../ws/shard.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildDelete(
+  data: DiscordPayload,
+  shardID: number,
+) {
+  const payload = data.d as GuildDeletePayload;
+  cacheHandlers.forEach("messages", (message) => {
+    if (message.guildID === payload.id) {
+      cacheHandlers.delete("messages", message.id);
+    }
+  });
+
+  cacheHandlers.forEach("channels", (channel) => {
+    if (channel.guildID === payload.id) {
+      cacheHandlers.delete("channels", channel.id);
+    }
+  });
+
+  cacheHandlers.forEach("members", async (member) => {
+    if (!member.guilds.has(payload.id)) return;
+
+    member.guilds.delete(payload.id);
+
+    if (!member.guilds.size) {
+      await cacheHandlers.delete("members", member.id);
+      return;
+    }
+
+    await cacheHandlers.set("members", member.id, member);
+  });
+
+  if (payload.unavailable) {
+    const shard = basicShards.get(shardID);
+    if (shard) shard.unavailableGuildIDs.add(payload.id);
+
+    return cacheHandlers.set("unavailableGuilds", payload.id, Date.now());
+  }
+
+  const guild = await cacheHandlers.get("guilds", payload.id);
+  if (!guild) return;
+
+  await cacheHandlers.delete("guilds", payload.id);
+
+  eventHandlers.guildDelete?.(guild);
+}

src/handlers/guilds/GUILD_EMOJIS_UPDATE.ts

@@ -0,0 +1,23 @@
+import { eventHandlers } from "../../bot.ts";
+import { DiscordPayload, GuildEmojisUpdatePayload } from "../../types/mod.ts";
+import { Collection } from "../../util/collection.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildEmojisUpdate(data: DiscordPayload) {
+  const payload = data.d as GuildEmojisUpdatePayload;
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  const cachedEmojis = guild.emojis;
+  guild.emojis = new Collection(
+    payload.emojis.map((emoji) => [emoji.id ?? emoji.name, emoji]),
+  );
+
+  cacheHandlers.set("guilds", payload.guild_id, guild);
+
+  eventHandlers.guildEmojisUpdate?.(
+    guild,
+    guild.emojis,
+    cachedEmojis,
+  );
+}

src/handlers/guilds/GUILD_INTEGRATIONS_UPDATE.ts

@@ -0,0 +1,17 @@
+import { eventHandlers } from "../../bot.ts";
+import {
+  DiscordGuildIntegrationsUpdateEvent,
+  DiscordPayload,
+} from "../../types/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildIntegrationsUpdate(
+  data: DiscordPayload,
+) {
+  const payload = data.d as DiscordGuildIntegrationsUpdateEvent;
+
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  eventHandlers.guildIntegrationsUpdate?.(guild);
+}

src/handlers/guilds/GUILD_MEMBERS_CHUNK.ts

@@ -0,0 +1,44 @@
+import { DiscordPayload, GuildMemberChunkPayload } from "../../types/mod.ts";
+import { cache } from "../../util/cache.ts";
+import { Collection } from "../../util/collection.ts";
+import { structures } from "../../structures/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildMembersChunk(data: DiscordPayload) {
+  const payload = data.d as GuildMemberChunkPayload;
+
+  const members = await Promise.all(
+    payload.members.map(async (member) => {
+      const memberStruct = await structures.createMemberStruct(
+        member,
+        payload.guild_id,
+      );
+      await cacheHandlers.set("members", memberStruct.id, memberStruct);
+
+      return memberStruct;
+    }),
+  );
+
+  // Check if its necessary to resolve the fetchmembers promise for this chunk or if more chunks will be coming
+  if (
+    payload.nonce
+  ) {
+    const resolve = cache.fetchAllMembersProcessingRequests.get(payload.nonce);
+    if (!resolve) return;
+
+    if (payload.chunk_index + 1 === payload.chunk_count) {
+      cache.fetchAllMembersProcessingRequests.delete(payload.nonce);
+      // Only 1 chunk most likely is all members or users only request a small amount of users
+      if (payload.chunk_count === 1) {
+        return resolve(new Collection(members.map((m) => [m.id, m])));
+      }
+
+      return resolve(
+        await cacheHandlers.filter(
+          "members",
+          (m) => m.guilds.has(payload.guild_id),
+        ),
+      );
+    }
+  }
+}

src/handlers/guilds/GUILD_MEMBER_ADD.ts

@@ -0,0 +1,19 @@
+import { eventHandlers } from "../../bot.ts";
+import { DiscordPayload, GuildMemberAddPayload } from "../../types/mod.ts";
+import { structures } from "../../structures/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildMemberAdd(data: DiscordPayload) {
+  const payload = data.d as GuildMemberAddPayload;
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  guild.memberCount++;
+  const memberStruct = await structures.createMemberStruct(
+    payload,
+    payload.guild_id,
+  );
+  await cacheHandlers.set("members", memberStruct.id, memberStruct);
+
+  eventHandlers.guildMemberAdd?.(guild, memberStruct);
+}

src/handlers/guilds/GUILD_MEMBER_REMOVE.ts

@@ -0,0 +1,18 @@
+import { eventHandlers } from "../../bot.ts";
+import { DiscordPayload, GuildBanPayload } from "../../types/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildMemberRemove(data: DiscordPayload) {
+  const payload = data.d as GuildBanPayload;
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  guild.memberCount--;
+  const member = await cacheHandlers.get("members", payload.user.id);
+  eventHandlers.guildMemberRemove?.(guild, payload.user, member);
+
+  member?.guilds.delete(guild.id);
+  if (member && !member.guilds.size) {
+    await cacheHandlers.delete("members", member.id);
+  }
+}

src/handlers/guilds/GUILD_MEMBER_UPDATE.ts

@@ -0,0 +1,59 @@
+import { eventHandlers } from "../../bot.ts";
+import { DiscordPayload, GuildMemberUpdatePayload } from "../../types/mod.ts";
+import { structures } from "../../structures/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildMemberUpdate(data: DiscordPayload) {
+  const payload = data.d as GuildMemberUpdatePayload;
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  const cachedMember = await cacheHandlers.get("members", payload.user.id);
+  const guildMember = cachedMember?.guilds.get(payload.guild_id);
+
+  const newMemberData = {
+    ...payload,
+    // deno-lint-ignore camelcase
+    premium_since: payload.premium_since || undefined,
+    // deno-lint-ignore camelcase
+    joined_at: new Date(guildMember?.joinedAt || Date.now())
+      .toISOString(),
+    deaf: guildMember?.deaf || false,
+    mute: guildMember?.mute || false,
+    roles: payload.roles,
+  };
+  const memberStruct = await structures.createMemberStruct(
+    newMemberData,
+    payload.guild_id,
+  );
+  await cacheHandlers.set("members", memberStruct.id, memberStruct);
+
+  if (guildMember?.nick !== payload.nick) {
+    eventHandlers.nicknameUpdate?.(
+      guild,
+      memberStruct,
+      payload.nick,
+      guildMember?.nick,
+    );
+  }
+
+  if (payload.pending === false && guildMember?.pending === true) {
+    eventHandlers.membershipScreeningPassed?.(guild, memberStruct);
+  }
+
+  const roleIDs = guildMember?.roles || [];
+
+  roleIDs.forEach((id) => {
+    if (!payload.roles.includes(id)) {
+      eventHandlers.roleLost?.(guild, memberStruct, id);
+    }
+  });
+
+  payload.roles.forEach((id) => {
+    if (!roleIDs.includes(id)) {
+      eventHandlers.roleGained?.(guild, memberStruct, id);
+    }
+  });
+
+  eventHandlers.guildMemberUpdate?.(guild, memberStruct, cachedMember);
+}

src/handlers/guilds/GUILD_ROLE_CREATE.ts

@@ -0,0 +1,20 @@
+import { eventHandlers } from "../../bot.ts";
+import {
+  DiscordPayload,
+  GuildRoleDeletePayload,
+  GuildRolePayload,
+} from "../../types/mod.ts";
+import { structures } from "../../structures/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildRoleCreate(data: DiscordPayload) {
+  const payload = data.d as GuildRolePayload;
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  const role = await structures.createRoleStruct(payload.role);
+  guild.roles = guild.roles.set(payload.role.id, role);
+  await cacheHandlers.set("guilds", payload.guild_id, guild);
+
+  eventHandlers.roleCreate?.(guild, role);
+}

src/handlers/guilds/GUILD_ROLE_DELETE.ts

@@ -0,0 +1,28 @@
+import { eventHandlers } from "../../bot.ts";
+import { DiscordPayload, GuildRoleDeletePayload } from "../../types/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildRoleDelete(data: DiscordPayload) {
+  const payload = data.d as GuildRoleDeletePayload;
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  const cachedRole = guild.roles.get(payload.role_id)!;
+  guild.roles.delete(payload.role_id);
+
+  if (cachedRole) eventHandlers.roleDelete?.(guild, cachedRole);
+
+  // For bots without GUILD_MEMBERS member.roles is never updated breaking permissions checking.
+  cacheHandlers.forEach("members", (member) => {
+    // Not in the relevant guild so just skip.
+    if (!member.guilds.has(guild.id)) return;
+
+    member.guilds.forEach((g) => {
+      // Member does not have this role
+      if (!g.roles.includes(payload.role_id)) return;
+      // Remove this role from the members cache
+      g.roles = g.roles.filter((id) => id !== payload.role_id);
+      cacheHandlers.set("members", member.id, member);
+    });
+  });
+}

src/handlers/guilds/GUILD_ROLE_UPDATE.ts

@@ -0,0 +1,23 @@
+import { eventHandlers } from "../../bot.ts";
+import {
+  DiscordPayload,
+  GuildRoleDeletePayload,
+  GuildRolePayload,
+} from "../../types/mod.ts";
+import { structures } from "../../structures/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildRoleUpdate(data: DiscordPayload) {
+  const payload = data.d as GuildRolePayload;
+  const guild = await cacheHandlers.get("guilds", payload.guild_id);
+  if (!guild) return;
+
+  const cachedRole = guild.roles.get(payload.role.id);
+  if (!cachedRole) return;
+
+  const role = await structures.createRoleStruct(payload.role);
+  guild.roles.set(payload.role.id, role);
+  await cacheHandlers.set("guilds", guild.id, guild);
+
+  eventHandlers.roleUpdate?.(guild, role, cachedRole);
+}

src/handlers/guilds/GUILD_UPDATE.ts

@@ -0,0 +1,48 @@
+import { eventHandlers } from "../../bot.ts";
+import {
+  DiscordPayload,
+  GuildUpdateChange,
+  UpdateGuildPayload,
+} from "../../types/mod.ts";
+import { cacheHandlers } from "../../cache.ts";
+
+export async function handleGuildUpdate(data: DiscordPayload) {
+  const payload = data.d as UpdateGuildPayload;
+  const cachedGuild = await cacheHandlers.get("guilds", payload.id);
+  if (!cachedGuild) return;
+
+  const keysToSkip = [
+    "roles",
+    "guild_hashes",
+    "guild_id",
+    "max_members",
+    "emojis",
+  ];
+
+  const changes = Object.entries(payload)
+    .map(([key, value]) => {
+      if (keysToSkip.includes(key)) return;
+
+      // @ts-ignore index signature
+      const cachedValue = cachedGuild[key];
+      if (cachedValue !== value) {
+        // Guild create sends undefined and update sends false.
+        if (!cachedValue && !value) return;
+
+        if (Array.isArray(cachedValue) && Array.isArray(value)) {
+          const different = (cachedValue.length !== value.length) ||
+            cachedValue.find((val) => !value.includes(val)) ||
+            value.find((val) => !cachedValue.includes(val));
+          if (!different) return;
+        }
+
+        // @ts-ignore index signature
+        cachedGuild[key] = value;
+        return { key, oldValue: cachedValue, value };
+      }
+    }).filter((change) => change) as GuildUpdateChange[];
+
+  await cacheHandlers.set("guilds", payload.id, cachedGuild);
+
+  eventHandlers.guildUpdate?.(cachedGuild, changes);
+}