feat: cache almost done

mod.ts

@@ -1,2 +1,3 @@
 export * from "./packages/biscuit/mod.ts";
 export * from "./packages/discordeno/mod.ts";
+export * from "./packages/cache/mod.ts";

packages/biscuit/structures/Message.ts

@@ -365,7 +365,7 @@ export class Message implements Model {
         const message = await this.session.rest.runMethod<DiscordMessage>(
             this.session.rest,
             "GET",
-            Routes.CHANNEL_MESSAGE(this.channelId, this.message),
+            Routes.CHANNEL_MESSAGE(this.channelId, this.id),
         );
 
         if (!message?.id) return;

packages/biscuit/structures/channels.ts

@@ -130,8 +130,6 @@ export class TextChannel {
         if (data.last_pin_timestamp) {
             this.lastPinTimestamp = data.last_pin_timestamp;
         }
-
-        this.messages = new Map();
     }
 
     readonly session: Session;
@@ -143,9 +141,6 @@ export class TextChannel {
     rateLimitPerUser: number;
     nsfw: boolean;
 
-    /** Meant to be used with cache */
-    messages: Map<Snowflake, Message>;
-
     /**
      * Mixin
      */
@@ -538,10 +533,10 @@ export class DMChannel extends BaseChannel implements Model {
     }
 }
 
-TextChannel.applyTo(DMChannel);
-
 export interface DMChannel extends Omit<TextChannel, "type">, Omit<BaseChannel, "type"> {}
 
+TextChannel.applyTo(DMChannel);
+
 /** VoiceChannel */
 export class VoiceChannel extends BaseVoiceChannel {
     constructor(session: Session, data: DiscordChannel, guildId: Snowflake) {
@@ -661,12 +656,26 @@ export class ThreadChannel extends GuildChannel implements Model {
     }
 }
 
+export interface ThreadChannel extends Omit<GuildChannel, "type">, Omit<TextChannel, "type"> {}
+
 TextChannel.applyTo(ThreadChannel);
 
-export interface ThreadChannel extends Omit<GuildChannel, "type">, Omit<TextChannel, "type"> {}
+export class GuildTextChannel extends GuildChannel {
+    constructor(session: Session, data: DiscordChannel, guildId: Snowflake) {
+        super(session, data, guildId);
+        this.type = data.type as ChannelTypes.GuildText;
+    }
+
+    override type: ChannelTypes.GuildText;
+}
+
+export interface GuildTextChannel extends GuildChannel, TextChannel {}
+
+TextChannel.applyTo(GuildTextChannel);
 
 /** ChannelFactory */
 export type Channel =
+    | GuildTextChannel
     | TextChannel
     | VoiceChannel
     | DMChannel
@@ -674,12 +683,23 @@ export type Channel =
     | ThreadChannel
     | StageChannel;
 
+export type ChannelWithMessages =
+    | GuildTextChannel
+    | VoiceChannel
+    | DMChannel
+    | NewsChannel
+    | ThreadChannel;
+
+export type ChannelWithMessagesInGuild = Exclude<ChannelWithMessages, DMChannel>;
+
 export class ChannelFactory {
     static from(session: Session, channel: DiscordChannel): Channel {
         switch (channel.type) {
             case ChannelTypes.GuildPublicThread:
             case ChannelTypes.GuildPrivateThread:
                 return new ThreadChannel(session, channel, channel.guild_id!);
+            case ChannelTypes.GuildText:
+                return new GuildTextChannel(session, channel, channel.guild_id!);
             case ChannelTypes.GuildNews:
                 return new NewsChannel(session, channel, channel.guild_id!);
             case ChannelTypes.DM:

packages/cache/mod.ts

@@ -1,4 +1,5 @@
 import type {
+    ChannelTypes,
     SymCache,
     Session,
     Snowflake,
@@ -6,19 +7,62 @@ import type {
     DiscordEmoji,
     DiscordUser,
     DiscordChannel,
+    DiscordMemberWithUser,
 } from "./deps.ts";
 
 import {
+    ChannelFactory,
     Guild,
     User,
     DMChannel,
     GuildEmoji,
+    GuildTextChannel,
+    Member,
+    Message,
+    VoiceChannel,
+    ThreadChannel,
+    NewsChannel,
 } from "./deps.ts";
 
 export const cache_sym = Symbol("@cache");
 
+export interface CachedMessage extends Omit<Message, "author"> {
+    authorId: Snowflake;
+    author?: User;
+}
+
+export interface CachedMember extends Omit<Member, "user"> {
+    userId: Snowflake;
+    user?: User;
+}
+
+export interface CachedGuild extends Omit<Guild, "members" | "channels"> {
+    channels: Map<Snowflake, CachedGuildChannel>;
+    members: Map<Snowflake, CachedMember>;
+}
+
+export interface CachedGuildChannel extends Omit<GuildTextChannel, "type"> {
+    type: ChannelTypes;
+    messages: Map<Snowflake, CachedMessage>;
+}
+
+export interface CachedGuildChannel extends Omit<VoiceChannel, "type"> {
+    type: ChannelTypes;
+    messages: Map<Snowflake, CachedMessage>;
+}
+
+export interface CachedGuildChannel extends Omit<NewsChannel, "type"> {
+    type: ChannelTypes;
+    messages: Map<Snowflake, CachedMessage>;
+}
+
+export interface CachedGuildChannel extends Omit<ThreadChannel, "type"> {
+    type: ChannelTypes
+    messages: Map<Snowflake, CachedMessage>;
+}
+
 export interface SessionCache extends SymCache {
-    guilds: StructCache<Guild>;
+    guilds: StructCache<CachedGuild>;
     users: StructCache<User>;
     dms: StructCache<DMChannel>;
     emojis: StructCache<GuildEmoji>;
@@ -27,7 +71,7 @@ export interface SessionCache extends SymCache {
 
 export default function (session: Session): SessionCache {
     return {
-        guilds: new StructCache<Guild>(session),
+        guilds: new StructCache<CachedGuild>(session),
         users: new StructCache<User>(session),
         dms: new StructCache<DMChannel>(session),
         emojis: new StructCache<GuildEmoji>(session),
@@ -59,6 +103,27 @@ export function DMChannelBootstrapper(cache: SessionCache, channel: DiscordChann
 }
 
 export function guildBootstrapper(guild: DiscordGuild, cache: SessionCache) {
-    // TODO: optimizee this garbage
+    const members = new Map(guild.members?.map((data) => {
-    cache.guilds.set(guild.id, new Guild(cache.session, guild));
+        const obj: CachedMember = Object.assign(new Member(cache.session, data as DiscordMemberWithUser, guild.id), {
+            userId: data.user!.id,
+            get user(): User | undefined {
+                return cache.users.get(this.userId);
+            }
+        });
+
+        return [data.user!.id, obj as CachedMember];
+    }));
+
+    const channels = new Map(guild.channels?.map((data) => {
+        const obj = Object.assign(ChannelFactory.from(cache.session, data), {
+            messages: new Map(),
+        });
+
+        return [data.id, obj as CachedGuildChannel];
+    }));
+
+    cache.guilds.set(guild.id, Object.assign(
+        new Guild(cache.session, guild),
+        { members, channels },
+    ));
 }