@kodelyth/discord 2026.5.39 → 2026.5.42

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.test.ts

@@ -0,0 +1,260 @@
+import { Routes } from "discord-api-types/v10";
+import { describe, expect, it } from "vitest";
+import {
+  createApplicationCommand,
+  createChannelWebhook,
+  createChannelMessage,
+  createInteractionCallback,
+  createGuildBan,
+  createGuildScheduledEvent,
+  createOwnMessageReaction,
+  createThread,
+  createUserDmChannel,
+  deleteChannelMessage,
+  deleteOwnMessageReaction,
+  deleteWebhookMessage,
+  editApplicationCommand,
+  editWebhookMessage,
+  getCurrentUser,
+  getChannelMessage,
+  getUser,
+  getWebhookMessage,
+  createWebhookMessage,
+  listMessageReactionUsers,
+  listApplicationCommands,
+  listChannelMessages,
+  listGuildChannels,
+  overwriteApplicationCommands,
+  pinChannelMessage,
+  searchGuildMessages,
+  sendChannelTyping,
+} from "./api.js";
+import { createFakeRestClient } from "./test-builders.test-support.js";
+
+describe("Discord REST API helpers", () => {
+  it("routes message helpers through the typed REST client", async () => {
+    const rest = createFakeRestClient([
+      [{ id: "m1" }],
+      { id: "m2" },
+      { id: "m3" },
+      { id: "t1" },
+      undefined,
+      undefined,
+      undefined,
+    ]);
+    const query = { limit: 2 };
+
+    await expect(listChannelMessages(rest, "c1", query)).resolves.toEqual([{ id: "m1" }]);
+    await expect(getChannelMessage(rest, "c1", "m2")).resolves.toEqual({ id: "m2" });
+    await expect(createChannelMessage(rest, "c1", { body: { content: "hello" } })).resolves.toEqual(
+      { id: "m3" },
+    );
+    await expect(createThread(rest, "c1", { body: { name: "thread" } }, "m2")).resolves.toEqual({
+      id: "t1",
+    });
+    await sendChannelTyping(rest, "c1");
+    await pinChannelMessage(rest, "c1", "m2");
+    await deleteChannelMessage(rest, "c1", "m2");
+
+    expect(rest.calls).toEqual([
+      { method: "GET", path: Routes.channelMessages("c1"), query },
+      { method: "GET", path: Routes.channelMessage("c1", "m2") },
+      {
+        method: "POST",
+        path: Routes.channelMessages("c1"),
+        data: { body: { content: "hello" } },
+      },
+      {
+        method: "POST",
+        path: Routes.threads("c1", "m2"),
+        data: { body: { name: "thread" } },
+      },
+      { method: "POST", path: Routes.channelTyping("c1") },
+      { method: "PUT", path: Routes.channelPin("c1", "m2") },
+      { method: "DELETE", path: Routes.channelMessage("c1", "m2") },
+    ]);
+  });
+
+  it("routes guild helpers through the typed REST client", async () => {
+    const rest = createFakeRestClient([[{ id: "c1" }], { id: "event1" }, undefined]);
+    const body = {
+      name: "standup",
+      scheduled_start_time: "2026-04-29T10:00:00.000Z",
+      privacy_level: 2,
+      entity_type: 3,
+      entity_metadata: { location: "voice" },
+    } as const;
+
+    await expect(listGuildChannels(rest, "g1")).resolves.toEqual([{ id: "c1" }]);
+    await expect(createGuildScheduledEvent(rest, "g1", body)).resolves.toEqual({ id: "event1" });
+    await createGuildBan(rest, "g1", "u1", { body: { delete_message_seconds: 0 } });
+
+    expect(rest.calls).toEqual([
+      { method: "GET", path: Routes.guildChannels("g1") },
+      {
+        method: "POST",
+        path: Routes.guildScheduledEvents("g1"),
+        data: { body },
+      },
+      {
+        method: "PUT",
+        path: Routes.guildBan("g1", "u1"),
+        data: { body: { delete_message_seconds: 0 } },
+      },
+    ]);
+  });
+
+  it("routes command helpers through the typed REST client", async () => {
+    const rest = createFakeRestClient([
+      [{ id: "cmd1" }],
+      { id: "cmd2" },
+      { id: "cmd3" },
+      undefined,
+    ]);
+
+    await expect(listApplicationCommands(rest, "app1")).resolves.toEqual([{ id: "cmd1" }]);
+    await expect(createApplicationCommand(rest, "app1", { name: "ping" })).resolves.toEqual({
+      id: "cmd2",
+    });
+    await expect(
+      editApplicationCommand(rest, "app1", "cmd2", { description: "Pong" }),
+    ).resolves.toEqual({ id: "cmd3" });
+    await overwriteApplicationCommands(rest, "app1", [{ name: "ping" }]);
+
+    expect(rest.calls).toEqual([
+      { method: "GET", path: Routes.applicationCommands("app1") },
+      {
+        method: "POST",
+        path: Routes.applicationCommands("app1"),
+        data: { body: { name: "ping" } },
+      },
+      {
+        method: "PATCH",
+        path: Routes.applicationCommand("app1", "cmd2"),
+        data: { body: { description: "Pong" } },
+      },
+      {
+        method: "PUT",
+        path: Routes.applicationCommands("app1"),
+        data: { body: [{ name: "ping" }] },
+      },
+    ]);
+  });
+
+  it("routes user helpers through the typed REST client", async () => {
+    const rest = createFakeRestClient([{ id: "me" }, { id: "u1" }, { id: "dm1" }]);
+
+    await expect(getCurrentUser(rest)).resolves.toEqual({ id: "me" });
+    await expect(getUser(rest, "u1")).resolves.toEqual({ id: "u1" });
+    await expect(createUserDmChannel(rest, "u1")).resolves.toEqual({ id: "dm1" });
+
+    expect(rest.calls).toEqual([
+      { method: "GET", path: Routes.user("@me") },
+      { method: "GET", path: Routes.user("u1") },
+      {
+        method: "POST",
+        path: Routes.userChannels(),
+        data: { body: { recipient_id: "u1" } },
+      },
+    ]);
+  });
+
+  it("routes reaction helpers through the typed REST client", async () => {
+    const rest = createFakeRestClient([undefined, [{ id: "u1" }], undefined]);
+    const query = { limit: 10 };
+
+    await createOwnMessageReaction(rest, "c1", "m1", "%F0%9F%91%8D");
+    await expect(
+      listMessageReactionUsers(rest, "c1", "m1", "%F0%9F%91%8D", query),
+    ).resolves.toEqual([{ id: "u1" }]);
+    await deleteOwnMessageReaction(rest, "c1", "m1", "%F0%9F%91%8D");
+
+    expect(rest.calls).toEqual([
+      {
+        method: "PUT",
+        path: Routes.channelMessageOwnReaction("c1", "m1", "%F0%9F%91%8D"),
+      },
+      {
+        method: "GET",
+        path: Routes.channelMessageReaction("c1", "m1", "%F0%9F%91%8D"),
+        query,
+      },
+      {
+        method: "DELETE",
+        path: Routes.channelMessageOwnReaction("c1", "m1", "%F0%9F%91%8D"),
+      },
+    ]);
+  });
+
+  it("routes webhook helper through the typed REST client", async () => {
+    const rest = createFakeRestClient([{ id: "wh1", token: "token1" }]);
+
+    await expect(createChannelWebhook(rest, "c1", { body: { name: "Klaw" } })).resolves.toEqual({
+      id: "wh1",
+      token: "token1",
+    });
+
+    expect(rest.calls).toEqual([
+      {
+        method: "POST",
+        path: Routes.channelWebhooks("c1"),
+        data: { body: { name: "Klaw" } },
+      },
+    ]);
+  });
+
+  it("routes interaction webhook helpers through the typed REST client", async () => {
+    const rest = createFakeRestClient([
+      { ok: true },
+      { id: "m1" },
+      { id: "m2" },
+      { id: "m3" },
+      undefined,
+    ]);
+    const query = { wait: "true" };
+
+    await expect(createInteractionCallback(rest, "i1", "itoken", { type: 5 })).resolves.toEqual({
+      ok: true,
+    });
+    await expect(
+      createWebhookMessage(rest, "app1", "wtoken", { body: { content: "hello" } }, query),
+    ).resolves.toEqual({ id: "m1" });
+    await expect(getWebhookMessage(rest, "app1", "wtoken", "m1")).resolves.toEqual({ id: "m2" });
+    await expect(
+      editWebhookMessage(rest, "app1", "wtoken", "m1", { body: { content: "updated" } }),
+    ).resolves.toEqual({ id: "m3" });
+    await deleteWebhookMessage(rest, "app1", "wtoken", "m1");
+
+    expect(rest.calls).toEqual([
+      {
+        method: "POST",
+        path: Routes.interactionCallback("i1", "itoken"),
+        data: { body: { type: 5 } },
+      },
+      {
+        method: "POST",
+        path: Routes.webhook("app1", "wtoken"),
+        data: { body: { content: "hello" } },
+        query,
+      },
+      { method: "GET", path: Routes.webhookMessage("app1", "wtoken", "m1") },
+      {
+        method: "PATCH",
+        path: Routes.webhookMessage("app1", "wtoken", "m1"),
+        data: { body: { content: "updated" } },
+      },
+      { method: "DELETE", path: Routes.webhookMessage("app1", "wtoken", "m1") },
+    ]);
+  });
+
+  it("keeps unsupported Discord search route isolated", async () => {
+    const rest = createFakeRestClient([{ messages: [] }]);
+    const params = new URLSearchParams({ content: "hello" });
+
+    await expect(searchGuildMessages(rest, "g1", params)).resolves.toEqual({ messages: [] });
+
+    expect(rest.calls).toEqual([
+      { method: "GET", path: "/guilds/g1/messages/search?content=hello" },
+    ]);
+  });
+});

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;
+  };
+}