🍻 feat: now we have members manager

Author: Helloyunho

core/src/rest/http_client.ts

@@ -17,7 +17,7 @@ export interface RequestOptions {
   bucket?: string;
   body?: unknown;
   headers?: Record<string, string>;
-  query?: Record<string, string>;
+  query?: Record<string, string | undefined>;
   reason?: string;
 }
 
@@ -176,7 +176,9 @@ export class HTTPClient implements HTTPClientOptions {
         }
       }
 
-      const query = new URLSearchParams(options?.query).toString();
+      const query = new URLSearchParams(
+        options?.query as Record<string, string>,
+      ).toString();
 
       const abortController = new AbortController();
       const timeoutID = setTimeout(() => {

framework/src/client/mod.ts

@@ -11,6 +11,7 @@ import { GuildsManager } from "../managers/guilds.ts";
 import { UsersManager } from "../managers/users.ts";
 import { RolesManager } from "../managers/roles.ts";
 import { EmojisManager } from "../managers/emojis.ts";
+import { MembersManager } from "../managers/members.ts";
 import { User } from "../structures/mod.ts";
 
 export interface ClientOptions extends APIManagerOptions {
@@ -27,6 +28,7 @@ export class Client extends EventEmitter<ClientEvents> {
   users = new UsersManager(this);
   roles = new RolesManager(this);
   emojis = new EmojisManager(this);
+  members = new MembersManager(this);
 
   constructor(token: string, options: ClientOptions = {}) {
     super();

framework/src/managers/base.ts

@@ -13,14 +13,16 @@ export class BaseManager<P, T> {
   _get(key: string): P | undefined {
     return this.cache.get(key);
   }
-  _fetch(_key: string, ..._: string[]): Promise<P | undefined> {
+  // deno-lint-ignore no-explicit-any
+  _fetch(_key: string, ..._: any[]): Promise<P | undefined> {
     throw new Error("Not implemented");
   }
 
   get(_key: string): T | undefined {
     throw new Error("Not implemented");
   }
-  fetch(_key: string, ..._: string[]): Promise<T | undefined> {
+  // deno-lint-ignore no-explicit-any
+  fetch(_key: string, ..._: any[]): Promise<T | undefined> {
     throw new Error("Not implemented");
   }
 
@@ -32,6 +34,10 @@ export class BaseManager<P, T> {
     return this.cache.delete(key);
   }
 
+  has(key: string): boolean {
+    return this.cache.has(key);
+  }
+
   async resolve(key: string): Promise<T | undefined> {
     return this.get(key) ?? await this.fetch(key);
   }

framework/src/managers/guildMembers.ts

@@ -0,0 +1,51 @@
+import type { GuildMemberPayload } from "../../../types/mod.ts";
+import type { Collection } from "../cache/mod.ts";
+import type { Client } from "../client/mod.ts";
+import { Member } from "../structures/guilds/member.ts";
+import { BaseManager } from "./base.ts";
+
+export class GuildMembersManager
+  extends BaseManager<GuildMemberPayload, Member> {
+  guildID: string;
+
+  constructor(
+    client: Client,
+    guildID: string,
+    cache: Collection<string, GuildMemberPayload>,
+  ) {
+    super(client);
+    this.guildID = guildID;
+    this.cache = cache;
+  }
+
+  get(id: string) {
+    const cached = this._get(id);
+    if (!cached) return;
+    return new Member(this.client, cached);
+  }
+
+  async fetch(id: string) {
+    try {
+      const payload = await this._fetch(id);
+      if (!payload) return;
+      return new Member(this.client, payload);
+    } catch (_err) {
+      return;
+    }
+  }
+
+  async _fetch(
+    id: string,
+  ): Promise<GuildMemberPayload | undefined> {
+    try {
+      const resp: GuildMemberPayload | undefined = await this.client.rest.get(
+        `/guilds/${this.guildID}/members/${id}`,
+      );
+      if (!resp) return;
+      this.set(id, resp);
+      return resp;
+    } catch (_err) {
+      return;
+    }
+  }
+}

framework/src/managers/guilds.ts

@@ -35,6 +35,7 @@ export class GuildsManager extends BaseManager<LightGuildPayload, Guild> {
       channels: undefined,
       roles: undefined,
       emojis: undefined,
+      members: undefined,
     };
     this.cache.set(key, lightGuild);
   }

framework/src/managers/members.ts

@@ -0,0 +1,74 @@
+import type { GuildMemberPayload } from "../../../types/mod.ts";
+import { Collection } from "../cache/mod.ts";
+import type { Client } from "../client/mod.ts";
+import { BaseManager } from "./base.ts";
+import { GuildMembersManager } from "./guildMembers.ts";
+
+export class MembersManager extends BaseManager<
+  Collection<string, GuildMemberPayload>,
+  GuildMembersManager
+> {
+  constructor(client: Client) {
+    super(client);
+  }
+
+  _fill(guildID: string, payloads: GuildMemberPayload[]) {
+    if (!this.has(guildID)) {
+      this.set(guildID, new Collection());
+    }
+    for (const payload of payloads) {
+      if (payload.user === undefined) continue;
+      this.get(guildID)!.set(payload.user.id, payload);
+    }
+  }
+
+  async _fetch(
+    guildID: string,
+    options?: {
+      limit?: number;
+      after?: string;
+    },
+  ): Promise<Collection<string, GuildMemberPayload> | undefined> {
+    try {
+      const resp: GuildMemberPayload[] | undefined = await this.client.rest.get(
+        `/guilds/${guildID}/members`,
+        {
+          query: options
+            ? { limit: options.limit?.toString(), after: options.after }
+            : {},
+        },
+      );
+      if (!resp) return;
+      this._fill(guildID, resp);
+      return this._get(guildID)!;
+    } catch (_err) {
+      return;
+    }
+  }
+
+  get(
+    id: string,
+  ) {
+    if (!this.has(id)) {
+      this.set(id, new Collection());
+    }
+    const cached = this._get(id)!;
+    return new GuildMembersManager(this.client, id, cached);
+  }
+
+  async fetch(
+    guildID: string,
+    options?: {
+      limit?: number;
+      after?: string;
+    },
+  ) {
+    try {
+      const collection = await this._fetch(guildID, options);
+      if (!collection) return;
+      return new GuildMembersManager(this.client, guildID, collection);
+    } catch (_err) {
+      return;
+    }
+  }
+}

framework/src/structures/guilds/guild.ts

@@ -13,12 +13,14 @@ import { LightGuildPayload } from "../../../types/guild.ts";
 import { Client } from "../../client/mod.ts";
 import { GuildChannelsManager } from "../../managers/guildChannels.ts";
 import { GuildEmojisManager } from "../../managers/guildEmojis.ts";
+import { GuildMembersManager } from "../../managers/guildMembers.ts";
 import { GuildRolesManager } from "../../managers/guildRoles.ts";
 import { UnavailableGuild } from "./unavaliable.ts";
 
 export class Guild extends UnavailableGuild {
   roles: GuildRolesManager;
   emojis: GuildEmojisManager;
+  members: GuildMembersManager;
   channels: GuildChannelsManager;
   constructor(client: Client, payload: LightGuildPayload) {
     // TODO: think about fill methods
@@ -39,6 +41,10 @@ export class Guild extends UnavailableGuild {
     if (payload.channels) {
       this.channels._fill(payload.channels);
     }
+    this.members = client.members.get(payload.id);
+    if (payload.members) {
+      client.members._fill(payload.id, payload.members);
+    }
   }
 
   get name(): string {
@@ -119,9 +125,6 @@ export class Guild extends UnavailableGuild {
   // get voiceStates(): string[] {
   //   return this.payload.voice_states;
   // }
-  // get members(): string[] {
-  //   return this.payload.members;
-  // }
   // get threads(): string[] {
   //   return this.payload.threads;
   // }

framework/src/structures/guilds/mod.ts

@@ -0,0 +1,4 @@
+export * from "./guild.ts";
+export * from "./member.ts";
+export * from "./role.ts";
+export * from "./unavaliable.ts";

framework/src/structures/mod.ts

@@ -1,3 +1,4 @@
 export * from "./channels/mod.ts";
 export * from "./messages/mod.ts";
 export * from "./users/mod.ts";
+export * from "./guilds/mod.ts";