@gakr-gakr/discord 0.1.0

package/src/internal/api.interactions.ts

@@ -0,0 +1,53 @@
+import { Routes } from "discord-api-types/v10";
+import type { RequestQuery } from "./rest-scheduler.js";
+import type { RequestClient, RequestData } from "./rest.js";
+
+export async function createInteractionCallback(
+  rest: RequestClient,
+  interactionId: string,
+  token: string,
+  body: unknown,
+): Promise<unknown> {
+  return await rest.post(Routes.interactionCallback(interactionId, token), { body });
+}
+
+export async function editWebhookMessage(
+  rest: RequestClient,
+  applicationId: string,
+  token: string,
+  messageId: string,
+  data: RequestData,
+  query?: RequestQuery,
+): Promise<unknown> {
+  return query
+    ? await rest.patch(Routes.webhookMessage(applicationId, token, messageId), data, query)
+    : await rest.patch(Routes.webhookMessage(applicationId, token, messageId), data);
+}
+
+export async function deleteWebhookMessage(
+  rest: RequestClient,
+  applicationId: string,
+  token: string,
+  messageId: string,
+): Promise<unknown> {
+  return await rest.delete(Routes.webhookMessage(applicationId, token, messageId));
+}
+
+export async function getWebhookMessage(
+  rest: RequestClient,
+  applicationId: string,
+  token: string,
+  messageId: string,
+): Promise<unknown> {
+  return await rest.get(Routes.webhookMessage(applicationId, token, messageId));
+}
+
+export async function createWebhookMessage(
+  rest: RequestClient,
+  applicationId: string,
+  token: string,
+  data: RequestData,
+  query?: RequestQuery,
+): Promise<unknown> {
+  return await rest.post(Routes.webhook(applicationId, token), data, query);
+}

package/src/internal/api.messages.ts

@@ -0,0 +1,113 @@
+import { Routes, type APIChannel, type APIMessage } from "discord-api-types/v10";
+import type { RequestQuery } from "./rest-scheduler.js";
+import type { RequestClient, RequestData } from "./rest.js";
+
+export async function getChannel(rest: RequestClient, channelId: string): Promise<APIChannel> {
+  return (await rest.get(Routes.channel(channelId))) as APIChannel;
+}
+
+export async function editChannel(
+  rest: RequestClient,
+  channelId: string,
+  data: RequestData,
+): Promise<APIChannel> {
+  return (await rest.patch(Routes.channel(channelId), data)) as APIChannel;
+}
+
+export async function deleteChannel(rest: RequestClient, channelId: string): Promise<void> {
+  await rest.delete(Routes.channel(channelId));
+}
+
+export async function listChannelMessages(
+  rest: RequestClient,
+  channelId: string,
+  query?: RequestQuery,
+): Promise<APIMessage[]> {
+  return (await rest.get(Routes.channelMessages(channelId), query)) as APIMessage[];
+}
+
+export async function getChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+): Promise<APIMessage> {
+  return (await rest.get(Routes.channelMessage(channelId, messageId))) as APIMessage;
+}
+
+export async function createChannelMessage<T extends object = APIMessage>(
+  rest: RequestClient,
+  channelId: string,
+  data: RequestData,
+): Promise<T> {
+  return (await rest.post(Routes.channelMessages(channelId), data)) as T;
+}
+
+export async function editChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+  data: RequestData,
+): Promise<APIMessage> {
+  return (await rest.patch(Routes.channelMessage(channelId, messageId), data)) as APIMessage;
+}
+
+export async function deleteChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+): Promise<void> {
+  await rest.delete(Routes.channelMessage(channelId, messageId));
+}
+
+export async function pinChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+): Promise<void> {
+  await rest.put(Routes.channelPin(channelId, messageId));
+}
+
+export async function unpinChannelMessage(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+): Promise<void> {
+  await rest.delete(Routes.channelPin(channelId, messageId));
+}
+
+export async function listChannelPins(
+  rest: RequestClient,
+  channelId: string,
+): Promise<APIMessage[]> {
+  return (await rest.get(Routes.channelPins(channelId))) as APIMessage[];
+}
+
+export async function sendChannelTyping(rest: RequestClient, channelId: string): Promise<void> {
+  await rest.post(Routes.channelTyping(channelId));
+}
+
+export async function createThread<T extends object = APIChannel>(
+  rest: RequestClient,
+  channelId: string,
+  data: RequestData,
+  messageId?: string,
+): Promise<T> {
+  const route = messageId ? Routes.threads(channelId, messageId) : Routes.threads(channelId);
+  return (await rest.post(route, data)) as T;
+}
+
+export async function listChannelArchivedThreads(
+  rest: RequestClient,
+  channelId: string,
+  query?: RequestQuery,
+): Promise<unknown> {
+  return await rest.get(Routes.channelThreads(channelId, "public"), query);
+}
+
+export async function searchGuildMessages(
+  rest: RequestClient,
+  guildId: string,
+  params: URLSearchParams,
+): Promise<unknown> {
+  return await rest.get(`/guilds/${guildId}/messages/search?${params.toString()}`);
+}

package/src/internal/api.reactions.ts

@@ -0,0 +1,38 @@
+import { Routes } from "discord-api-types/v10";
+import type { RequestQuery } from "./rest-scheduler.js";
+import type { RequestClient } from "./rest.js";
+
+export async function createOwnMessageReaction(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+  encodedEmoji: string,
+): Promise<void> {
+  await rest.put(Routes.channelMessageOwnReaction(channelId, messageId, encodedEmoji));
+}
+
+export async function deleteOwnMessageReaction(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+  encodedEmoji: string,
+): Promise<void> {
+  await rest.delete(Routes.channelMessageOwnReaction(channelId, messageId, encodedEmoji));
+}
+
+export async function listMessageReactionUsers(
+  rest: RequestClient,
+  channelId: string,
+  messageId: string,
+  encodedEmoji: string,
+  query?: RequestQuery,
+): Promise<Array<{ id: string; username?: string; discriminator?: string }>> {
+  return (await rest.get(
+    Routes.channelMessageReaction(channelId, messageId, encodedEmoji),
+    query,
+  )) as Array<{
+    id: string;
+    username?: string;
+    discriminator?: string;
+  }>;
+}

package/src/internal/api.ts

@@ -0,0 +1,61 @@
+export {
+  createApplicationCommand,
+  deleteApplicationCommand,
+  editApplicationCommand,
+  listApplicationCommands,
+  overwriteApplicationCommands,
+  overwriteGuildApplicationCommands,
+} from "./api.commands.js";
+export {
+  addGuildMemberRole,
+  createGuildBan,
+  createGuildChannel,
+  createGuildEmoji,
+  createGuildScheduledEvent,
+  createGuildSticker,
+  deleteChannelPermission,
+  getGuild,
+  getGuildMember,
+  getGuildVoiceState,
+  listGuildActiveThreads,
+  listGuildChannels,
+  listGuildEmojis,
+  listGuildRoles,
+  listGuildScheduledEvents,
+  moveGuildChannels,
+  putChannelPermission,
+  removeGuildMember,
+  removeGuildMemberRole,
+  timeoutGuildMember,
+} from "./api.guild.js";
+export {
+  createInteractionCallback,
+  createWebhookMessage,
+  deleteWebhookMessage,
+  editWebhookMessage,
+  getWebhookMessage,
+} from "./api.interactions.js";
+export {
+  createChannelMessage,
+  createThread,
+  deleteChannel,
+  deleteChannelMessage,
+  editChannel,
+  editChannelMessage,
+  getChannel,
+  getChannelMessage,
+  listChannelArchivedThreads,
+  listChannelMessages,
+  listChannelPins,
+  pinChannelMessage,
+  searchGuildMessages,
+  sendChannelTyping,
+  unpinChannelMessage,
+} from "./api.messages.js";
+export {
+  createOwnMessageReaction,
+  deleteOwnMessageReaction,
+  listMessageReactionUsers,
+} from "./api.reactions.js";
+export { createUserDmChannel, getCurrentUser, getUser } from "./api.users.js";
+export { createChannelWebhook } from "./api.webhooks.js";

package/src/internal/api.users.ts

@@ -0,0 +1,19 @@
+import { Routes, type APIChannel, type APIUser } from "discord-api-types/v10";
+import type { RequestClient } from "./rest.js";
+
+export async function getCurrentUser(rest: RequestClient): Promise<APIUser> {
+  return (await rest.get(Routes.user("@me"))) as APIUser;
+}
+
+export async function getUser(rest: RequestClient, userId: string): Promise<APIUser> {
+  return (await rest.get(Routes.user(userId))) as APIUser;
+}
+
+export async function createUserDmChannel(
+  rest: RequestClient,
+  recipientId: string,
+): Promise<Pick<APIChannel, "id">> {
+  return (await rest.post(Routes.userChannels(), {
+    body: { recipient_id: recipientId },
+  })) as Pick<APIChannel, "id">;
+}

package/src/internal/api.webhooks.ts

@@ -0,0 +1,13 @@
+import { Routes } from "discord-api-types/v10";
+import type { RequestClient, RequestData } from "./rest.js";
+
+export async function createChannelWebhook(
+  rest: RequestClient,
+  channelId: string,
+  data: RequestData,
+): Promise<{ id?: string; token?: string }> {
+  return (await rest.post(Routes.channelWebhooks(channelId), data)) as {
+    id?: string;
+    token?: string;
+  };
+}

package/src/internal/client.ts

@@ -0,0 +1,310 @@
+import type { APIApplicationCommand, APIInteraction } from "discord-api-types/v10";
+import { DiscordCommandDeployer, type DeployCommandOptions } from "./command-deploy.js";
+import type { BaseCommand } from "./commands.js";
+import { BaseMessageInteractiveComponent, parseCustomId, type Modal } from "./components.js";
+import { DiscordEntityCache } from "./entity-cache.js";
+import { DiscordEventQueue, type DiscordEventQueueOptions } from "./event-queue.js";
+import { dispatchInteraction } from "./interaction-dispatch.js";
+import { RequestClient, type RequestClientOptions } from "./rest.js";
+import type { Guild, GuildMember, Message, User } from "./structures.js";
+
+export interface Route {
+  method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  path: `/${string}`;
+  handler(req: Request, ctx?: Context): Response | Promise<Response>;
+  protected?: boolean;
+  disabled?: boolean;
+}
+
+export interface Context {
+  waitUntil?(promise: Promise<unknown>): void;
+  env?: unknown;
+}
+
+export abstract class Plugin {
+  abstract readonly id: string;
+  registerClient?(client: Client): Promise<void> | void;
+  registerRoutes?(client: Client): Promise<void> | void;
+  onRequest?(req: Request, ctx: Context): Promise<Response | undefined> | Response | undefined;
+}
+
+export type AnyListener = {
+  type: string;
+  handle(data: unknown, client: Client): Promise<void> | void;
+};
+
+export interface ClientOptions {
+  baseUrl: string;
+  clientId: string;
+  deploySecret?: string;
+  publicKey: string | string[];
+  token: string;
+  requestOptions?: RequestClientOptions;
+  autoDeploy?: boolean;
+  disableDeployRoute?: boolean;
+  disableInteractionsRoute?: boolean;
+  disableEventsRoute?: boolean;
+  commandDeployHashStorePath?: string;
+  devGuilds?: string[];
+  eventQueue?: DiscordEventQueueOptions;
+  restCacheTtlMs?: number;
+}
+
+type OneOffComponentResult =
+  | { success: true; customId: string; message: Message; values?: string[] }
+  | { success: false; message: Message; reason: "timed out" };
+
+export class ComponentRegistry<
+  T extends { customId: string; customIdParser?: typeof parseCustomId; type?: number },
+> {
+  private entries = new Map<string, T[]>();
+  private oneOffComponents = new Map<
+    string,
+    { message: Message; resolve(result: OneOffComponentResult): void; timer: NodeJS.Timeout }
+  >();
+  private wildcardEntries: T[] = [];
+
+  register(entry: T): void {
+    const key = parseRegistryKey(entry.customId, entry.customIdParser);
+    if (key === "*") {
+      if (!this.wildcardEntries.includes(entry)) {
+        this.wildcardEntries.push(entry);
+      }
+      return;
+    }
+    const entries = this.entries.get(key) ?? [];
+    if (!entries.includes(entry)) {
+      entries.push(entry);
+      this.entries.set(key, entries);
+    }
+  }
+
+  resolve(customId: string, options?: { componentType?: number }): T | undefined {
+    for (const entries of this.entries.values()) {
+      const match = entries.find((entry) => {
+        if (options?.componentType !== undefined && entry.type !== options.componentType) {
+          return false;
+        }
+        const parser = entry.customIdParser ?? parseCustomId;
+        return parseRegistryKey(entry.customId, parser) === parseRegistryKey(customId, parser);
+      });
+      if (match) {
+        return match;
+      }
+    }
+    return this.wildcardEntries.find((entry) => {
+      if (options?.componentType !== undefined && entry.type !== options.componentType) {
+        return false;
+      }
+      return true;
+    });
+  }
+
+  waitForMessageComponent(message: Message, timeoutMs: number): Promise<OneOffComponentResult> {
+    const key = createOneOffComponentKey(message.id, message.channelId);
+    return new Promise((resolve) => {
+      const existing = this.oneOffComponents.get(key);
+      if (existing) {
+        clearTimeout(existing.timer);
+        existing.resolve({ success: false, message, reason: "timed out" });
+      }
+      const timer = setTimeout(
+        () => {
+          this.oneOffComponents.delete(key);
+          resolve({ success: false, message, reason: "timed out" });
+        },
+        Math.max(0, timeoutMs),
+      );
+      timer.unref?.();
+      this.oneOffComponents.set(key, {
+        message,
+        timer,
+        resolve,
+      });
+    });
+  }
+
+  resolveOneOffComponent(params: {
+    channelId?: string;
+    customId: string;
+    messageId?: string;
+    values?: string[];
+  }): boolean {
+    if (!params.messageId || !params.channelId) {
+      return false;
+    }
+    const entry = this.oneOffComponents.get(
+      createOneOffComponentKey(params.messageId, params.channelId),
+    );
+    if (!entry) {
+      return false;
+    }
+    clearTimeout(entry.timer);
+    this.oneOffComponents.delete(createOneOffComponentKey(params.messageId, params.channelId));
+    entry.resolve({
+      success: true,
+      customId: params.customId,
+      message: entry.message,
+      values: params.values,
+    });
+    return true;
+  }
+}
+
+function parseRegistryKey(customId: string, parser: typeof parseCustomId = parseCustomId): string {
+  return parser(customId).key;
+}
+
+function createOneOffComponentKey(messageId: string, channelId: string): string {
+  return `${messageId}:${channelId}`;
+}
+
+export class Client {
+  routes: Route[] = [];
+  plugins: Array<{ id: string; plugin: Plugin }> = [];
+  options: ClientOptions;
+  commands: BaseCommand[];
+  listeners: AnyListener[];
+  rest: RequestClient;
+  componentHandler = new ComponentRegistry<BaseMessageInteractiveComponent>();
+  private commandDeployer: DiscordCommandDeployer;
+  private entityCache: DiscordEntityCache;
+  private eventQueue?: DiscordEventQueue;
+  modalHandler = new ComponentRegistry<Modal>();
+  shardId?: number;
+  totalShards?: number;
+
+  constructor(
+    options: ClientOptions,
+    handlers: {
+      commands?: BaseCommand[];
+      listeners?: AnyListener[];
+      components?: BaseMessageInteractiveComponent[];
+      modals?: Modal[];
+    },
+    plugins: Plugin[] = [],
+  ) {
+    if (!options.clientId) {
+      throw new Error("Missing Discord application ID");
+    }
+    if (!options.token) {
+      throw new Error("Missing Discord bot token");
+    }
+    this.options = { ...options, baseUrl: options.baseUrl.replace(/\/+$/, "") };
+    this.commands = handlers.commands ?? [];
+    this.listeners = handlers.listeners ?? [];
+    this.rest = new RequestClient(options.token, options.requestOptions);
+    this.eventQueue = this.options.eventQueue
+      ? new DiscordEventQueue(this.options.eventQueue)
+      : undefined;
+    this.entityCache = new DiscordEntityCache({
+      client: this,
+      rest: () => this.rest,
+      ttlMs: this.options.restCacheTtlMs,
+    });
+    this.commandDeployer = new DiscordCommandDeployer({
+      clientId: this.options.clientId,
+      commands: this.commands,
+      devGuilds: this.options.devGuilds,
+      hashStorePath: this.options.commandDeployHashStorePath,
+      rest: () => this.rest,
+    });
+    for (const component of handlers.components ?? []) {
+      this.componentHandler.register(component);
+    }
+    for (const command of this.commands) {
+      for (const component of command.components ?? []) {
+        this.componentHandler.register(component);
+      }
+    }
+    for (const modal of handlers.modals ?? []) {
+      this.modalHandler.register(modal);
+    }
+    for (const plugin of plugins) {
+      void plugin.registerClient?.(this);
+      void plugin.registerRoutes?.(this);
+      this.plugins.push({ id: plugin.id, plugin });
+    }
+  }
+
+  getPlugin<T = Plugin>(id: string): T | undefined {
+    return this.plugins.find((entry) => entry.id === id)?.plugin as T | undefined;
+  }
+
+  registerListener(listener: AnyListener): AnyListener {
+    if (!this.listeners.includes(listener)) {
+      this.listeners.push(listener);
+    }
+    return listener;
+  }
+
+  unregisterListener(listener: AnyListener): boolean {
+    const index = this.listeners.indexOf(listener);
+    if (index < 0) {
+      return false;
+    }
+    this.listeners.splice(index, 1);
+    return true;
+  }
+
+  getRuntimeMetrics() {
+    return {
+      request: this.rest.getSchedulerMetrics(),
+      eventQueue: this.eventQueue?.getMetrics(),
+    };
+  }
+
+  async fetchUser(id: string): Promise<User> {
+    return await this.entityCache.fetchUser(id);
+  }
+
+  async fetchChannel(id: string) {
+    return await this.entityCache.fetchChannel(id);
+  }
+
+  async fetchGuild(id: string): Promise<Guild> {
+    return await this.entityCache.fetchGuild(id);
+  }
+
+  async fetchMember(guildId: string, userId: string): Promise<GuildMember> {
+    return await this.entityCache.fetchMember(guildId, userId);
+  }
+
+  async getDiscordCommands(): Promise<APIApplicationCommand[]> {
+    return await this.commandDeployer.getCommands();
+  }
+
+  async deployCommands(options: DeployCommandOptions = {}) {
+    return await this.commandDeployer.deploy(options);
+  }
+
+  async reconcileCommands() {
+    return await this.deployCommands({ mode: "reconcile" });
+  }
+
+  async handleInteraction(rawData: APIInteraction, _ctx?: Context): Promise<void> {
+    await dispatchInteraction(this, rawData);
+  }
+
+  async dispatchGatewayEvent(type: string, data: unknown): Promise<void> {
+    this.entityCache.invalidateForGatewayEvent(type, data);
+    const listeners = this.listeners.filter((entry) => entry.type === type);
+    if (!this.eventQueue) {
+      for (const listener of listeners) {
+        await listener.handle(data, this);
+      }
+      return;
+    }
+    await Promise.all(
+      listeners.map((listener) =>
+        this.eventQueue!.enqueue({
+          eventType: type,
+          listenerName: listener.constructor.name || "AnonymousListener",
+          run: async () => {
+            await listener.handle(data, this);
+          },
+        }),
+      ),
+    );
+  }
+}