fix: remove structure automatic caching (#517)

* fix: remove structure automatic caching

* Update src/api/controllers/interactions.ts

* Update src/api/controllers/interactions.ts

* Update src/api/controllers/interactions.ts

* memb -> member

* rename shit

* Update src/api/controllers/misc.ts

Co-authored-by: ITOH <72305210+itohatweb@users.noreply.github.com>

* idk

* Update src/api/handlers/guild.ts

Co-authored-by: ITOH <72305210+itohatweb@users.noreply.github.com>

* fmt

Co-authored-by: ITOH <72305210+itohatweb@users.noreply.github.com>

src/api/controllers/channels.ts

@@ -11,10 +11,11 @@ export async function handleInternalChannelCreate(data: DiscordPayload) {
   if (data.t !== "CHANNEL_CREATE") return;
 
   const payload = data.d as ChannelCreatePayload;
-  const channel = await structures.createChannel(payload);
-  await cacheHandlers.set("channels", channel.id, channel);
+  const channelStruct = await structures.createChannel(payload);
 
-  eventHandlers.channelCreate?.(channel);
+  await cacheHandlers.set("channels", channelStruct.id, channelStruct);
+
+  eventHandlers.channelCreate?.(channelStruct);
 }
 
 export async function handleInternalChannelDelete(data: DiscordPayload) {
@@ -57,10 +58,11 @@ export async function handleInternalChannelUpdate(data: DiscordPayload) {
 
   const payload = data.d as ChannelCreatePayload;
   const cachedChannel = await cacheHandlers.get("channels", payload.id);
-  const channel = await structures.createChannel(payload);
-  await cacheHandlers.set("channels", channel.id, channel);
+  const channelStruct = await structures.createChannel(payload);
+
+  await cacheHandlers.set("channels", channelStruct.id, channelStruct);
 
   if (!cachedChannel) return;
 
-  eventHandlers.channelUpdate?.(channel, cachedChannel);
+  eventHandlers.channelUpdate?.(channelStruct, cachedChannel);
 }

src/api/controllers/guilds.ts

@@ -21,19 +21,19 @@ export async function handleInternalGuildCreate(
   // When shards resume they emit GUILD_CREATE again.
   if (await cacheHandlers.has("guilds", payload.id)) return;
 
-  const guild = await structures.createGuild(
+  const guildStruct = await structures.createGuild(
     data.d as CreateGuildPayload,
     shardID,
   );
 
-  await cacheHandlers.set("guilds", guild.id, guild);
+  await cacheHandlers.set("guilds", guildStruct.id, guildStruct);
 
   if (await cacheHandlers.has("unavailableGuilds", payload.id)) {
     await cacheHandlers.delete("unavailableGuilds", payload.id);
   }
 
-  if (!cache.isReady) return eventHandlers.guildLoaded?.(guild);
-  eventHandlers.guildCreate?.(guild);
+  if (!cache.isReady) return eventHandlers.guildLoaded?.(guildStruct);
+  eventHandlers.guildCreate?.(guildStruct);
 }
 
 export async function handleInternalGuildDelete(data: DiscordPayload) {

src/api/controllers/interactions.ts

@@ -5,15 +5,22 @@ import {
   InteractionCommandPayload,
 } from "../../types/mod.ts";
 import { structures } from "../structures/mod.ts";
+import { cacheHandlers } from "./cache.ts";
 
 export async function handleInternalInteractionCreate(data: DiscordPayload) {
   if (data.t !== "INTERACTION_CREATE") return;
 
   const payload = data.d as InteractionCommandPayload;
+  const memberStruct = await structures.createMember(
+    payload.member,
+    payload.guild_id,
+  );
+  await cacheHandlers.set("members", memberStruct.id, memberStruct);
+
   eventHandlers.interactionCreate?.(
     {
       ...payload,
-      member: await structures.createMember(payload.member, payload.guild_id),
+      member: memberStruct,
     },
   );
 }

src/api/controllers/members.ts

@@ -19,12 +19,13 @@ export async function handleInternalGuildMemberAdd(data: DiscordPayload) {
   if (!guild) return;
 
   guild.memberCount++;
-  const member = await structures.createMember(
+  const memberStruct = await structures.createMember(
     payload,
     payload.guild_id,
   );
+  await cacheHandlers.set("members", memberStruct.id, memberStruct);
 
-  eventHandlers.guildMemberAdd?.(guild, member);
+  eventHandlers.guildMemberAdd?.(guild, memberStruct);
 }
 
 export async function handleInternalGuildMemberRemove(data: DiscordPayload) {
@@ -65,41 +66,40 @@ export async function handleInternalGuildMemberUpdate(data: DiscordPayload) {
     mute: guildMember?.mute || false,
     roles: payload.roles,
   };
-  const member = await structures.createMember(
+  const memberStruct = await structures.createMember(
     newMemberData,
     payload.guild_id,
   );
-
-  await cacheHandlers.set("members", member.id, member);
+  await cacheHandlers.set("members", memberStruct.id, memberStruct);
 
   if (guildMember?.nick !== payload.nick) {
     eventHandlers.nicknameUpdate?.(
       guild,
-      member,
+      memberStruct,
       payload.nick,
       guildMember?.nick,
     );
   }
 
   if (payload.pending === false && guildMember?.pending === true) {
-    eventHandlers.membershipScreeningPassed?.(guild, member);
+    eventHandlers.membershipScreeningPassed?.(guild, memberStruct);
   }
 
   const roleIDs = guildMember?.roles || [];
 
   roleIDs.forEach((id) => {
     if (!payload.roles.includes(id)) {
-      eventHandlers.roleLost?.(guild, member, id);
+      eventHandlers.roleLost?.(guild, memberStruct, id);
     }
   });
 
   payload.roles.forEach((id) => {
     if (!roleIDs.includes(id)) {
-      eventHandlers.roleGained?.(guild, member, id);
+      eventHandlers.roleGained?.(guild, memberStruct, id);
     }
   });
 
-  eventHandlers.guildMemberUpdate?.(guild, member, cachedMember);
+  eventHandlers.guildMemberUpdate?.(guild, memberStruct, cachedMember);
 }
 
 export async function handleInternalGuildMembersChunk(data: DiscordPayload) {
@@ -108,9 +108,16 @@ export async function handleInternalGuildMembersChunk(data: DiscordPayload) {
   const payload = data.d as GuildMemberChunkPayload;
 
   const members = await Promise.all(
-    payload.members.map((member) =>
-      structures.createMember(member, payload.guild_id)
-    ),
+    payload.members.map(async (member) => {
+      const memberStruct = await structures.createMember(
+        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

src/api/controllers/messages.ts

@@ -21,21 +21,25 @@ export async function handleInternalMessageCreate(data: DiscordPayload) {
 
   if (payload.member && guild) {
     // If in a guild cache the author as a member
-    await structures.createMember(
+    const memberStruct = await structures.createMember(
       { ...payload.member, user: payload.author },
       guild.id,
     );
+
+    await cacheHandlers.set("members", memberStruct.id, memberStruct);
   }
 
-  payload.mentions.forEach((mention) => {
+  await Promise.all(payload.mentions.map(async (mention) => {
     // Cache the member if its a valid member
     if (mention.member && guild) {
-      structures.createMember(
+      const memberStruct = await structures.createMember(
         { ...mention.member, user: mention },
         guild.id,
       );
+
+      return cacheHandlers.set("members", memberStruct.id, memberStruct);
     }
-  });
+  }));
 
   const message = await structures.createMessage(payload);
   // Cache the message

src/api/controllers/misc.ts

@@ -53,7 +53,18 @@ export async function handleInternalReady(
         // All the members that came in on guild creates should now be processed 1 by 1
         for (const [guildID, members] of initialMemberLoadQueue.entries()) {
           await Promise.all(
-            members.map((member) => structures.createMember(member, guildID)),
+            members.map(async (member) => {
+              const memberStruct = await structures.createMember(
+                member,
+                guildID,
+              );
+
+              return cacheHandlers.set(
+                "members",
+                memberStruct.id,
+                memberStruct,
+              );
+            }),
           );
         }
       }

src/api/controllers/reactions.ts

@@ -39,7 +39,11 @@ export async function handleInternalMessageReactionAdd(data: DiscordPayload) {
   if (payload.member && payload.guild_id) {
     const guild = await cacheHandlers.get("guilds", payload.guild_id);
     if (guild) {
-      await structures.createMember(payload.member, guild.id);
+      const memberStruct = await structures.createMember(
+        payload.member,
+        guild.id,
+      );
+      await cacheHandlers.set("members", memberStruct.id, memberStruct);
     }
   }
 
@@ -91,10 +95,11 @@ export async function handleInternalMessageReactionRemove(
   if (payload.member && payload.guild_id) {
     const guild = await cacheHandlers.get("guilds", payload.guild_id);
     if (guild) {
-      await structures.createMember(
+      const memberStruct = await structures.createMember(
         payload.member,
         guild.id,
       );
+      await cacheHandlers.set("members", memberStruct.id, memberStruct);
     }
   }
 

src/api/handlers/guild.ts

@@ -137,7 +137,11 @@ export async function createGuildChannel(
       type: options?.type || ChannelTypes.GUILD_TEXT,
     })) as ChannelCreatePayload;
 
-  return structures.createChannel(result);
+  const channelStruct = await structures.createChannel(result);
+
+  await cacheHandlers.set("channels", channelStruct.id, channelStruct);
+
+  return channelStruct;
 }
 
 /** Delete a channel in your server. Bot needs MANAGE_CHANNEL permissions in the server. */
@@ -183,11 +187,12 @@ export async function getChannels(guildID: string, addToCache = true) {
   ) as ChannelCreatePayload[];
 
   return Promise.all(result.map(async (res) => {
-    const channel = await structures.createChannel(res, guildID);
+    const channelStruct = await structures.createChannel(res, guildID);
     if (addToCache) {
-      await cacheHandlers.set("channels", channel.id, channel);
+      await cacheHandlers.set("channels", channelStruct.id, channelStruct);
     }
-    return channel;
+
+    return channelStruct;
   }));
 }
 
@@ -200,10 +205,12 @@ export async function getChannel(channelID: string, addToCache = true) {
     endpoints.CHANNEL_BASE(channelID),
   ) as ChannelCreatePayload;
 
-  const channel = await structures.createChannel(result, result.guild_id);
-  if (addToCache) await cacheHandlers.set("channels", channel.id, channel);
+  const channelStruct = await structures.createChannel(result, result.guild_id);
+  if (addToCache) {
+    await cacheHandlers.set("channels", channelStruct.id, channelStruct);
+  }
 
-  return channel;
+  return channelStruct;
 }
 
 /** Modify the positions of channels on the guild. Requires MANAGE_CHANNELS permisison. */
@@ -287,7 +294,11 @@ export async function getMember(
     endpoints.GUILD_MEMBER(guildID, id),
   ) as MemberCreatePayload;
 
-  return structures.createMember(data, guildID);
+  const memberStruct = await structures.createMember(data, guildID);
+
+  await cacheHandlers.set("members", memberStruct.id, memberStruct);
+
+  return memberStruct;
 }
 
 /** Returns guild member objects for the specified user by their nickname/username.
@@ -620,7 +631,13 @@ export async function getMembers(
     ) as MemberCreatePayload[];
 
     const memberStructures = await Promise.all(
-      result.map((member) => structures.createMember(member, guildID)),
+      result.map(async (member) => {
+        const memberStruct = await structures.createMember(member, guildID);
+
+        await cacheHandlers.set("members", memberStruct.id, memberStruct);
+
+        return memberStruct;
+      }),
     ) as Member[];
 
     if (!memberStructures.length) break;

src/api/handlers/member.ts

@@ -133,12 +133,12 @@ export async function sendDirectMessage(
     ) as DMChannelCreatePayload;
     // Channel create event will have added this channel to the cache
     await cacheHandlers.delete("channels", dmChannelData.id);
-    const channel = await structures.createChannel(
+    const channelStruct = await structures.createChannel(
       dmChannelData as unknown as ChannelCreatePayload,
     );
     // Recreate the channel and add it undert he users id
-    await cacheHandlers.set("channels", memberID, channel);
-    dmChannel = channel;
+    await cacheHandlers.set("channels", memberID, channelStruct);
+    dmChannel = channelStruct;
   }
 
   // If it does exist try sending a message to this user

src/api/structures/channel.ts

@@ -7,7 +7,6 @@ import {
 import { cache } from "../../util/cache.ts";
 import { Collection } from "../../util/collection.ts";
 import { createNewProp } from "../../util/utils.ts";
-import { cacheHandlers } from "../controllers/cache.ts";
 import { sendMessage } from "../handlers/channel.ts";
 import { Guild } from "./guild.ts";
 import { Message } from "./message.ts";
@@ -27,6 +26,7 @@ const baseChannel: Partial<Channel> = {
   },
 };
 
+// deno-lint-ignore require-await
 export async function createChannel(
   data: ChannelCreatePayload,
   guildID?: string,
@@ -63,7 +63,6 @@ export async function createChannel(
     nsfw: createNewProp(nsfw),
   });
 
-  await cacheHandlers.set("channels", data.id, channel);
   return channel as Channel;
 }
 

src/api/structures/guild.ts

@@ -1,7 +1,6 @@
 import { botID } from "../../bot.ts";
 import {
   BanOptions,
-  ChannelCreatePayload,
   CreateGuildPayload,
   Emoji,
   GetAuditLogsOptions,
@@ -12,12 +11,12 @@ import {
   ImageSize,
   MemberCreatePayload,
   Presence,
-  RoleData,
   VoiceState,
 } from "../../types/mod.ts";
 import { cache } from "../../util/cache.ts";
 import { Collection } from "../../util/collection.ts";
 import { createNewProp } from "../../util/utils.ts";
+import { cacheHandlers } from "../controllers/cache.ts";
 import {
   ban,
   deleteServer,
@@ -142,16 +141,15 @@ export async function createGuild(data: CreateGuildPayload, shardID: number) {
     ...rest
   } = data;
 
-  const roles = (await Promise.all(
-    data.roles.map((r: RoleData) => structures.createRole(r)),
-  )) as Role[];
-
-  await Promise.all(
-    channels.map((c: ChannelCreatePayload) =>
-      structures.createChannel(c, data.id)
-    ),
+  const roles = await Promise.all(
+    data.roles.map((role) => structures.createRole(role)),
   );
 
+  await Promise.all(channels.map(async (channel) => {
+    const channelStruct = await structures.createChannel(channel);
+    return cacheHandlers.set("channels", channelStruct.id, channelStruct);
+  }));
+
   const restProps: Record<string, ReturnType<typeof createNewProp>> = {};
   for (const key of Object.keys(rest)) {
     // @ts-ignore index signature

src/api/structures/member.ts

@@ -124,8 +124,6 @@ export async function createMember(data: MemberCreatePayload, guildID: string) {
     mute: mute,
   });
 
-  await cacheHandlers.set("members", member.id, member);
-
   return member as Member;
 }