@gakr-gakr/discord 0.1.0

package/src/send.message-request.ts

@@ -0,0 +1,112 @@
+import { MessageFlags, type APIEmbed } from "discord-api-types/v10";
+import {
+  Embed,
+  serializePayload,
+  type MessagePayloadFile,
+  type MessagePayloadObject,
+  type TopLevelComponents,
+} from "./internal/discord.js";
+
+export const SUPPRESS_EMBEDS_FLAG = MessageFlags.SuppressEmbeds;
+export const SUPPRESS_NOTIFICATIONS_FLAG = MessageFlags.SuppressNotifications;
+
+export type DiscordSendComponentFactory = (text: string) => TopLevelComponents[];
+export type DiscordSendComponents = TopLevelComponents[] | DiscordSendComponentFactory;
+export type DiscordSendEmbeds = Array<APIEmbed | Embed>;
+
+export function resolveDiscordSendComponents(params: {
+  components?: DiscordSendComponents;
+  text: string;
+  isFirst: boolean;
+}): TopLevelComponents[] | undefined {
+  if (!params.components || !params.isFirst) {
+    return undefined;
+  }
+  return typeof params.components === "function"
+    ? params.components(params.text)
+    : params.components;
+}
+
+function normalizeDiscordEmbeds(embeds?: DiscordSendEmbeds): Embed[] | undefined {
+  if (!embeds?.length) {
+    return undefined;
+  }
+  return embeds.map((embed) => (embed instanceof Embed ? embed : new Embed(embed)));
+}
+
+export function resolveDiscordSendEmbeds(params: {
+  embeds?: DiscordSendEmbeds;
+  isFirst: boolean;
+}): Embed[] | undefined {
+  if (!params.embeds || !params.isFirst) {
+    return undefined;
+  }
+  return normalizeDiscordEmbeds(params.embeds);
+}
+
+export function buildDiscordMessagePayload(params: {
+  text: string;
+  components?: TopLevelComponents[];
+  embeds?: Embed[];
+  flags?: number;
+  files?: MessagePayloadFile[];
+}): MessagePayloadObject {
+  const payload: MessagePayloadObject = {};
+  const hasV2 = hasV2Components(params.components);
+  const trimmed = params.text.trim();
+  if (!hasV2 && trimmed) {
+    payload.content = params.text;
+  }
+  if (params.components?.length) {
+    payload.components = params.components;
+  }
+  if (!hasV2 && params.embeds?.length) {
+    payload.embeds = params.embeds;
+  }
+  if (params.flags !== undefined) {
+    payload.flags = params.flags;
+  }
+  if (params.files?.length) {
+    payload.files = params.files;
+  }
+  return payload;
+}
+
+export function resolveDiscordMessageFlags(params: {
+  silent?: boolean;
+  suppressEmbeds?: boolean;
+}): number | undefined {
+  let flags = 0;
+  if (params.suppressEmbeds) {
+    flags |= SUPPRESS_EMBEDS_FLAG;
+  }
+  if (params.silent) {
+    flags |= SUPPRESS_NOTIFICATIONS_FLAG;
+  }
+  return flags || undefined;
+}
+
+export function buildDiscordMessageRequest(params: {
+  text: string;
+  components?: TopLevelComponents[];
+  embeds?: Embed[];
+  files?: MessagePayloadFile[];
+  flags?: number;
+  replyTo?: string;
+}) {
+  const payload = buildDiscordMessagePayload(params);
+  return stripUndefinedFields({
+    ...serializePayload(payload),
+    ...(params.replyTo
+      ? { message_reference: { message_id: params.replyTo, fail_if_not_exists: false } }
+      : {}),
+  });
+}
+
+export function stripUndefinedFields<T extends object>(value: T): T {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)) as T;
+}
+
+function hasV2Components(components?: TopLevelComponents[]): boolean {
+  return Boolean(components?.some((component) => "isV2" in component && component.isV2));
+}

package/src/send.messages.ts

@@ -0,0 +1,229 @@
+import type { APIChannel, APIMessage } from "discord-api-types/v10";
+import { ChannelType } from "discord-api-types/v10";
+import {
+  createChannelMessage,
+  createThread,
+  deleteChannelMessage,
+  editChannelMessage,
+  getChannel,
+  getChannelMessage,
+  listChannelArchivedThreads,
+  listGuildActiveThreads,
+  listChannelMessages,
+  listChannelPins,
+  pinChannelMessage,
+  searchGuildMessages,
+  unpinChannelMessage,
+} from "./internal/discord.js";
+import { resolveDiscordRest } from "./send.shared.js";
+import type {
+  DiscordMessageEdit,
+  DiscordMessageQuery,
+  DiscordReactOpts,
+  DiscordSearchQuery,
+  DiscordThreadCreate,
+  DiscordThreadList,
+} from "./send.types.js";
+
+function formatDiscordThreadInitialMessageError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export class DiscordThreadInitialMessageError extends Error {
+  readonly initialMessageError: string;
+  readonly thread: APIChannel;
+
+  constructor(thread: APIChannel, error: unknown) {
+    const initialMessageError = formatDiscordThreadInitialMessageError(error);
+    super(
+      `Discord thread was created, but sending the initial message failed: ${initialMessageError}`,
+    );
+    this.name = "DiscordThreadInitialMessageError";
+    this.initialMessageError = initialMessageError;
+    this.thread = thread;
+  }
+}
+
+export async function readMessagesDiscord(
+  channelId: string,
+  query: DiscordMessageQuery | undefined,
+  opts: DiscordReactOpts,
+): Promise<APIMessage[]> {
+  const messageQuery = query ?? {};
+  const rest = resolveDiscordRest(opts);
+  const limit =
+    typeof messageQuery.limit === "number" && Number.isFinite(messageQuery.limit)
+      ? Math.min(Math.max(Math.floor(messageQuery.limit), 1), 100)
+      : undefined;
+  const params: Record<string, string | number> = {};
+  if (limit) {
+    params.limit = limit;
+  }
+  if (messageQuery.before) {
+    params.before = messageQuery.before;
+  }
+  if (messageQuery.after) {
+    params.after = messageQuery.after;
+  }
+  if (messageQuery.around) {
+    params.around = messageQuery.around;
+  }
+  return await listChannelMessages(rest, channelId, params);
+}
+
+export async function fetchMessageDiscord(
+  channelId: string,
+  messageId: string,
+  opts: DiscordReactOpts,
+): Promise<APIMessage> {
+  const rest = resolveDiscordRest(opts);
+  return await getChannelMessage(rest, channelId, messageId);
+}
+
+export async function editMessageDiscord(
+  channelId: string,
+  messageId: string,
+  payload: DiscordMessageEdit,
+  opts: DiscordReactOpts,
+): Promise<APIMessage> {
+  const rest = resolveDiscordRest(opts);
+  return await editChannelMessage(rest, channelId, messageId, {
+    body: {
+      content: payload.content,
+      ...(payload.flags !== undefined ? { flags: payload.flags } : {}),
+    },
+  });
+}
+
+export async function deleteMessageDiscord(
+  channelId: string,
+  messageId: string,
+  opts: DiscordReactOpts,
+) {
+  const rest = resolveDiscordRest(opts);
+  await deleteChannelMessage(rest, channelId, messageId);
+  return { ok: true };
+}
+
+export async function pinMessageDiscord(
+  channelId: string,
+  messageId: string,
+  opts: DiscordReactOpts,
+) {
+  const rest = resolveDiscordRest(opts);
+  await pinChannelMessage(rest, channelId, messageId);
+  return { ok: true };
+}
+
+export async function unpinMessageDiscord(
+  channelId: string,
+  messageId: string,
+  opts: DiscordReactOpts,
+) {
+  const rest = resolveDiscordRest(opts);
+  await unpinChannelMessage(rest, channelId, messageId);
+  return { ok: true };
+}
+
+export async function listPinsDiscord(
+  channelId: string,
+  opts: DiscordReactOpts,
+): Promise<APIMessage[]> {
+  const rest = resolveDiscordRest(opts);
+  return await listChannelPins(rest, channelId);
+}
+
+export async function createThreadDiscord(
+  channelId: string,
+  payload: DiscordThreadCreate,
+  opts: DiscordReactOpts,
+) {
+  const rest = resolveDiscordRest(opts);
+  const body: Record<string, unknown> = { name: payload.name };
+  if (payload.autoArchiveMinutes) {
+    body.auto_archive_duration = payload.autoArchiveMinutes;
+  }
+  if (!payload.messageId && payload.type !== undefined) {
+    body.type = payload.type;
+  }
+  let channelType: ChannelType | undefined;
+  if (!payload.messageId) {
+    // Only detect channel kind for route-less thread creation.
+    // If this lookup fails, keep prior behavior and let Discord validate.
+    try {
+      const channel = await getChannel(rest, channelId);
+      channelType = channel?.type;
+    } catch {
+      channelType = undefined;
+    }
+  }
+  const isForumLike =
+    channelType === ChannelType.GuildForum || channelType === ChannelType.GuildMedia;
+  if (isForumLike) {
+    const starterContent = payload.content?.trim() ? payload.content : payload.name;
+    body.message = { content: starterContent };
+    if (payload.appliedTags?.length) {
+      body.applied_tags = payload.appliedTags;
+    }
+  }
+  // When creating a standalone thread (no messageId) in a non-forum channel,
+  // default to public thread (type 11). Discord defaults to private (type 12)
+  // which is unexpected for most users. (#14147)
+  if (!payload.messageId && !isForumLike && body.type === undefined) {
+    body.type = ChannelType.PublicThread;
+  }
+  const thread = await createThread(rest, channelId, { body }, payload.messageId);
+
+  // For non-forum channels, send the initial message separately after thread creation.
+  // Forum channels handle this via the `message` field in the request body.
+  if (!isForumLike && payload.content?.trim() && "id" in thread) {
+    try {
+      await createChannelMessage(rest, thread.id, {
+        body: { content: payload.content },
+      });
+    } catch (error) {
+      throw new DiscordThreadInitialMessageError(thread, error);
+    }
+  }
+
+  return thread;
+}
+
+export async function listThreadsDiscord(payload: DiscordThreadList, opts: DiscordReactOpts) {
+  const rest = resolveDiscordRest(opts);
+  if (payload.includeArchived) {
+    if (!payload.channelId) {
+      throw new Error("channelId required to list archived threads");
+    }
+    const params: Record<string, string | number> = {};
+    if (payload.before) {
+      params.before = payload.before;
+    }
+    if (payload.limit) {
+      params.limit = payload.limit;
+    }
+    return await listChannelArchivedThreads(rest, payload.channelId, params);
+  }
+  return await listGuildActiveThreads(rest, payload.guildId);
+}
+
+export async function searchMessagesDiscord(query: DiscordSearchQuery, opts: DiscordReactOpts) {
+  const rest = resolveDiscordRest(opts);
+  const params = new URLSearchParams();
+  params.set("content", query.content);
+  if (query.channelIds?.length) {
+    for (const channelId of query.channelIds) {
+      params.append("channel_id", channelId);
+    }
+  }
+  if (query.authorIds?.length) {
+    for (const authorId of query.authorIds) {
+      params.append("author_id", authorId);
+    }
+  }
+  if (query.limit) {
+    const limit = Math.min(Math.max(Math.floor(query.limit), 1), 25);
+    params.set("limit", String(limit));
+  }
+  return await searchGuildMessages(rest, query.guildId, params);
+}