@minesa-org/mini-interaction 0.4.12 → 0.4.16

package/dist/core/http/DiscordRestClient.d.ts

@@ -1,3 +1,7 @@
+import type { APIChannel } from 'discord-api-types/v10';
+import { DiscordSentMessage } from '../messages/DiscordSentMessage.js';
+import { type BaseDiscordMessageOptions, type DiscordReaction, type DiscordSendMessageOptions, type DiscordStartThreadOptions } from '../messages/message-payloads.js';
+import { DiscordWebhook } from '../webhooks/DiscordWebhook.js';
 type FetchLike = typeof fetch;
 export type DiscordRestClientOptions = {
     token: string;
@@ -18,5 +22,12 @@ export declare class DiscordRestClient {
     private createRequestError;
     createFollowup(interactionToken: string, body: unknown): Promise<unknown>;
     editOriginal(interactionToken: string, body: unknown): Promise<unknown>;
+    createFollowupMessage(interactionToken: string, options: BaseDiscordMessageOptions): Promise<DiscordSentMessage>;
+    editOriginalMessage(interactionToken: string, options: BaseDiscordMessageOptions): Promise<DiscordSentMessage>;
+    sendMessage(options: DiscordSendMessageOptions): Promise<DiscordSentMessage>;
+    send(options: DiscordSendMessageOptions): Promise<DiscordSentMessage>;
+    startThread(options: DiscordStartThreadOptions): Promise<APIChannel>;
+    addReaction(channelId: string, messageId: string, reaction: DiscordReaction): Promise<void>;
+    webhook(id: string, token: string): DiscordWebhook;
 }
 export {};

package/dist/core/http/DiscordRestClient.js

@@ -1,4 +1,7 @@
 import { setTimeout as sleep } from 'node:timers/promises';
+import { DiscordSentMessage } from '../messages/DiscordSentMessage.js';
+import { createMessageRequestInit, } from '../messages/message-payloads.js';
+import { DiscordWebhook } from '../webhooks/DiscordWebhook.js';
 export class DiscordRestClient {
     options;
     fetchImpl;
@@ -20,7 +23,7 @@ export class DiscordRestClient {
                     ...requestInit,
                     headers: {
                         ...(authenticated ? { Authorization: `Bot ${this.options.token}` } : {}),
-                        'Content-Type': 'application/json',
+                        ...getDefaultContentTypeHeader(requestInit.body),
                         ...(requestInit.headers ?? {}),
                     },
                 });
@@ -74,4 +77,72 @@ export class DiscordRestClient {
             authenticated: false,
         });
     }
+    async createFollowupMessage(interactionToken, options) {
+        const requestInit = createMessageRequestInit(options);
+        const message = await this.request(`/webhooks/${this.options.applicationId}/${interactionToken}`, {
+            method: 'POST',
+            ...requestInit,
+            authenticated: false,
+        });
+        return new DiscordSentMessage(this, message);
+    }
+    async editOriginalMessage(interactionToken, options) {
+        const requestInit = createMessageRequestInit(options);
+        const message = await this.request(`/webhooks/${this.options.applicationId}/${interactionToken}/messages/@original`, {
+            method: 'PATCH',
+            ...requestInit,
+            authenticated: false,
+        });
+        return new DiscordSentMessage(this, message);
+    }
+    async sendMessage(options) {
+        const { channelId, ...messageOptions } = options;
+        const requestInit = createMessageRequestInit(messageOptions);
+        const message = await this.request(`/channels/${channelId}/messages`, {
+            method: 'POST',
+            ...requestInit,
+        });
+        return new DiscordSentMessage(this, message);
+    }
+    send(options) {
+        return this.sendMessage(options);
+    }
+    async startThread(options) {
+        const { channelId, messageId, reason, ...body } = options;
+        return this.request(`/channels/${channelId}/messages/${messageId}/threads`, {
+            method: 'POST',
+            body: JSON.stringify({
+                auto_archive_duration: body.autoArchiveDuration,
+                rate_limit_per_user: body.rateLimitPerUser,
+                name: body.name,
+            }),
+            headers: reason ? { 'X-Audit-Log-Reason': reason } : undefined,
+        });
+    }
+    addReaction(channelId, messageId, reaction) {
+        return this.request(`/channels/${channelId}/messages/${messageId}/reactions/${encodeDiscordReaction(reaction)}/@me`, {
+            method: 'PUT',
+        });
+    }
+    webhook(id, token) {
+        return new DiscordWebhook(this, id, token);
+    }
+}
+function getDefaultContentTypeHeader(body) {
+    return body instanceof FormData ? {} : { 'Content-Type': 'application/json' };
+}
+function encodeDiscordReaction(reaction) {
+    if (typeof reaction !== 'string') {
+        return encodeURIComponent(reaction.id ? `${reaction.name}:${reaction.id}` : reaction.name);
+    }
+    const trimmed = reaction.trim();
+    const customEmojiMatch = trimmed.match(/^<a?:([^:>]+):(\d+)>$/);
+    if (customEmojiMatch) {
+        const [, name, id] = customEmojiMatch;
+        return encodeURIComponent(`${name}:${id}`);
+    }
+    if (/^[^:\s]+:\d+$/.test(trimmed)) {
+        return encodeURIComponent(trimmed);
+    }
+    return encodeURIComponent(trimmed);
 }

package/dist/core/http/__tests__/discord-rest-client.messages.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/http/__tests__/discord-rest-client.messages.test.js

@@ -0,0 +1,122 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { MessageFlags } from "discord-api-types/v10";
+import { ContainerBuilder, TextDisplayBuilder } from "../../../builders/index.js";
+import { DiscordRestClient } from "../DiscordRestClient.js";
+test("sendMessage sends channel messages and returns a thread-capable wrapper", async () => {
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        calls.push({ input: String(input), init: init ?? {} });
+        if (calls.length === 1) {
+            return new Response(JSON.stringify({ id: "msg_1", channel_id: "chan_1" }), { status: 200 });
+        }
+        return new Response(JSON.stringify({ id: "thread_1", type: 11, parent_id: "chan_1" }), { status: 200 });
+    });
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: fetchImpl,
+    });
+    const container = new ContainerBuilder().addComponent(new TextDisplayBuilder().setContent("Hello"));
+    const sentMessage = await rest.send({
+        channelId: "chan_1",
+        components: [container],
+        flags: MessageFlags.IsComponentsV2,
+    });
+    assert.equal(sentMessage.id, "msg_1");
+    await sentMessage.startThread({
+        name: "Thread name",
+        autoArchiveDuration: 60,
+        reason: "Testing",
+    });
+    assert.equal(calls.length, 2);
+    assert.match(calls[0].input, /\/channels\/chan_1\/messages$/);
+    assert.match(calls[1].input, /\/channels\/chan_1\/messages\/msg_1\/threads$/);
+    assert.match(String(calls[0].init.body), /payload|components|flags/);
+});
+test("sentMessage.react supports custom emoji strings and emoji objects", async () => {
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        calls.push({ input: String(input), init: init ?? {} });
+        if (calls.length === 1) {
+            return new Response(JSON.stringify({ id: "msg_react", channel_id: "chan_react" }), { status: 200 });
+        }
+        return new Response(null, { status: 204 });
+    });
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: fetchImpl,
+    });
+    const sentMessage = await rest.sendMessage({
+        channelId: "chan_react",
+        content: "React to me",
+    });
+    await sentMessage.react("<:wave:1234567890>");
+    await sentMessage.react({ name: "thumbsup", id: "999" });
+    assert.equal(calls.length, 3);
+    assert.match(calls[1].input, /\/channels\/chan_react\/messages\/msg_react\/reactions\/wave%3A1234567890\/@me$/);
+    assert.match(calls[2].input, /\/channels\/chan_react\/messages\/msg_react\/reactions\/thumbsup%3A999\/@me$/);
+});
+test("sendMessage uses multipart form-data when files are provided", async () => {
+    let capturedBody;
+    const fetchImpl = (async (_input, init) => {
+        capturedBody = init?.body;
+        return new Response(JSON.stringify({ id: "msg_file", channel_id: "chan_file" }), { status: 200 });
+    });
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: fetchImpl,
+    });
+    await rest.sendMessage({
+        channelId: "chan_file",
+        content: "with file",
+        files: [
+            {
+                name: "hello.txt",
+                data: new TextEncoder().encode("hello world"),
+                contentType: "text/plain",
+            },
+        ],
+    });
+    assert.ok(capturedBody instanceof FormData);
+    const payloadJson = capturedBody.get("payload_json");
+    assert.equal(typeof payloadJson, "string");
+    assert.match(String(payloadJson), /hello\.txt/);
+});
+test("webhook.send returns a sent message wrapper", async () => {
+    const calls = [];
+    const fetchImpl = (async (input, init) => {
+        calls.push({ input: String(input), init: init ?? {} });
+        return new Response(JSON.stringify({ id: "msg_hook", channel_id: "chan_hook" }), { status: 200 });
+    });
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: fetchImpl,
+    });
+    const webhook = rest.webhook("wh_1", "wh_token");
+    const sentMessage = await webhook.send({
+        content: "hello",
+        threadId: "thread_123",
+        username: "Mini",
+    });
+    assert.equal(sentMessage.id, "msg_hook");
+    assert.match(calls[0].input, /\/webhooks\/wh_1\/wh_token\?wait=true&thread_id=thread_123$/);
+    assert.match(String(calls[0].init.body), /"username":"Mini"/);
+});
+test("sendMessage rejects ephemeral flags for regular messages", async () => {
+    const rest = new DiscordRestClient({
+        token: "token",
+        applicationId: "app",
+        fetchImplementation: (async () => new Response(JSON.stringify({ id: "x", channel_id: "y" }), {
+            status: 200,
+        })),
+    });
+    await assert.rejects(() => rest.sendMessage({
+        channelId: "chan",
+        content: "nope",
+        flags: MessageFlags.Ephemeral,
+    }), /regular channel or webhook messages/);
+});

package/dist/core/interactions/InteractionContext.d.ts

@@ -1,6 +1,8 @@
 import type { APIInteractionResponse, APIInteractionResponseCallbackData, APIModalInteractionResponseCallbackData } from 'discord-api-types/v10';
 import type { ParsedInteraction } from '../../types/discord.js';
 import { DiscordRestClient } from '../http/DiscordRestClient.js';
+import type { DiscordSentMessage } from '../messages/DiscordSentMessage.js';
+import type { BaseDiscordMessageOptions, DiscordSendMessageOptions } from '../messages/message-payloads.js';
 export type InteractionContextOptions = {
     interaction: ParsedInteraction;
     rest: DiscordRestClient;
@@ -18,8 +20,9 @@ export declare class InteractionContext {
     reply(data: APIInteractionResponseCallbackData): APIInteractionResponse;
     deferReply(ephemeral?: boolean): APIInteractionResponse;
     showModal(data: APIModalInteractionResponseCallbackData): APIInteractionResponse;
-    editReply(body: unknown): Promise<unknown>;
-    followUp(body: unknown): Promise<unknown>;
+    editReply(body: BaseDiscordMessageOptions): Promise<DiscordSentMessage>;
+    followUp(body: BaseDiscordMessageOptions): Promise<DiscordSentMessage>;
+    send(body: DiscordSendMessageOptions): Promise<DiscordSentMessage>;
     get hasResponded(): boolean;
     private clearAutoAck;
 }

package/dist/core/interactions/InteractionContext.js

@@ -29,10 +29,13 @@ export class InteractionContext {
         return { type: 9, data };
     }
     editReply(body) {
-        return this.options.rest.editOriginal(this.options.interaction.token, body);
+        return this.options.rest.editOriginalMessage(this.options.interaction.token, body);
     }
     followUp(body) {
-        return this.options.rest.createFollowup(this.options.interaction.token, body);
+        return this.options.rest.createFollowupMessage(this.options.interaction.token, body);
+    }
+    send(body) {
+        return this.options.rest.sendMessage(body);
     }
     get hasResponded() {
         return this.responded;

package/dist/core/messages/DiscordSentMessage.d.ts

@@ -0,0 +1,13 @@
+import type { APIChannel, APIMessage } from "discord-api-types/v10";
+import type { DiscordRestClient } from "../http/DiscordRestClient.js";
+import type { DiscordReaction, DiscordStartThreadOptions } from "./message-payloads.js";
+export declare class DiscordSentMessage {
+    private readonly rest;
+    readonly raw: APIMessage;
+    constructor(rest: DiscordRestClient, raw: APIMessage);
+    get id(): string;
+    get channelId(): string;
+    startThread(options: Omit<DiscordStartThreadOptions, "channelId" | "messageId">): Promise<APIChannel>;
+    react(reaction: DiscordReaction): Promise<this>;
+    toJSON(): APIMessage;
+}

package/dist/core/messages/DiscordSentMessage.js

@@ -0,0 +1,28 @@
+export class DiscordSentMessage {
+    rest;
+    raw;
+    constructor(rest, raw) {
+        this.rest = rest;
+        this.raw = raw;
+    }
+    get id() {
+        return this.raw.id;
+    }
+    get channelId() {
+        return this.raw.channel_id;
+    }
+    async startThread(options) {
+        return this.rest.startThread({
+            channelId: this.channelId,
+            messageId: this.id,
+            ...options,
+        });
+    }
+    async react(reaction) {
+        await this.rest.addReaction(this.channelId, this.id, reaction);
+        return this;
+    }
+    toJSON() {
+        return this.raw;
+    }
+}

package/dist/core/messages/message-payloads.d.ts

@@ -0,0 +1,40 @@
+import type { APIAllowedMentions } from "discord-api-types/v10";
+import { type InteractionMessageData, type MessageFlagLike } from "../../utils/interactionMessageHelpers.js";
+export type DiscordMessageFile = {
+    name: string;
+    data: ArrayBuffer | Blob | Buffer | Uint8Array;
+    contentType?: string;
+};
+export type BaseDiscordMessageOptions = Omit<InteractionMessageData, "flags"> & {
+    flags?: MessageFlagLike | MessageFlagLike[];
+    allowedMentions?: APIAllowedMentions;
+    attachments?: Array<Record<string, unknown>>;
+    stickerIds?: string[];
+    files?: DiscordMessageFile[];
+};
+export type DiscordSendMessageOptions = BaseDiscordMessageOptions & {
+    channelId: string;
+};
+export type DiscordStartThreadOptions = {
+    channelId: string;
+    messageId: string;
+    name: string;
+    autoArchiveDuration?: number;
+    rateLimitPerUser?: number;
+    reason?: string;
+};
+export type DiscordWebhookSendOptions = BaseDiscordMessageOptions & {
+    threadId?: string;
+    username?: string;
+    avatarUrl?: string;
+};
+export type DiscordReaction = string | {
+    name: string;
+    id?: string;
+    animated?: boolean;
+};
+export declare function normaliseDiscordMessagePayload(options: BaseDiscordMessageOptions): Record<string, unknown>;
+export declare function createMessageRequestInit(options: BaseDiscordMessageOptions): {
+    body: BodyInit;
+    headers?: HeadersInit;
+};

package/dist/core/messages/message-payloads.js

@@ -0,0 +1,60 @@
+import { MessageFlags } from "discord-api-types/v10";
+import { normaliseInteractionMessageData, } from "../../utils/interactionMessageHelpers.js";
+export function normaliseDiscordMessagePayload(options) {
+    const payload = normaliseInteractionMessageData({
+        content: options.content,
+        components: options.components,
+        embeds: options.embeds,
+        flags: options.flags,
+    });
+    const resolvedPayload = payload ? { ...payload } : {};
+    const flags = resolvedPayload.flags;
+    if (typeof flags === "number" && (flags & MessageFlags.Ephemeral) === MessageFlags.Ephemeral) {
+        throw new Error("[MiniInteraction] Ephemeral flags are not supported for regular channel or webhook messages.");
+    }
+    if (options.allowedMentions) {
+        resolvedPayload.allowed_mentions = options.allowedMentions;
+    }
+    if (options.stickerIds && options.stickerIds.length > 0) {
+        resolvedPayload.sticker_ids = options.stickerIds;
+    }
+    const files = options.files ?? [];
+    if (options.attachments && options.attachments.length > 0) {
+        resolvedPayload.attachments = options.attachments;
+    }
+    else if (files.length > 0) {
+        resolvedPayload.attachments = files.map((file, index) => ({
+            id: String(index),
+            filename: file.name,
+        }));
+    }
+    return resolvedPayload;
+}
+export function createMessageRequestInit(options) {
+    const payload = normaliseDiscordMessagePayload(options);
+    const files = options.files ?? [];
+    if (files.length === 0) {
+        return {
+            body: JSON.stringify(payload),
+            headers: {
+                "Content-Type": "application/json",
+            },
+        };
+    }
+    const formData = new FormData();
+    formData.set("payload_json", JSON.stringify(payload));
+    files.forEach((file, index) => {
+        formData.append(`files[${index}]`, toBlob(file), file.name);
+    });
+    return { body: formData };
+}
+function toBlob(file) {
+    if (file.data instanceof Blob) {
+        return file.data;
+    }
+    if (file.data instanceof ArrayBuffer) {
+        return new Blob([file.data], file.contentType ? { type: file.contentType } : undefined);
+    }
+    const bytes = Uint8Array.from(file.data);
+    return new Blob([bytes.buffer], file.contentType ? { type: file.contentType } : undefined);
+}

package/dist/core/webhooks/DiscordWebhook.d.ts

@@ -0,0 +1,10 @@
+import type { DiscordRestClient } from "../http/DiscordRestClient.js";
+import { DiscordSentMessage } from "../messages/DiscordSentMessage.js";
+import { type DiscordWebhookSendOptions } from "../messages/message-payloads.js";
+export declare class DiscordWebhook {
+    private readonly rest;
+    readonly id: string;
+    readonly token: string;
+    constructor(rest: DiscordRestClient, id: string, token: string);
+    send(options: DiscordWebhookSendOptions): Promise<DiscordSentMessage>;
+}

package/dist/core/webhooks/DiscordWebhook.js

@@ -0,0 +1,47 @@
+import { DiscordSentMessage } from "../messages/DiscordSentMessage.js";
+import { createMessageRequestInit, } from "../messages/message-payloads.js";
+export class DiscordWebhook {
+    rest;
+    id;
+    token;
+    constructor(rest, id, token) {
+        this.rest = rest;
+        this.id = id;
+        this.token = token;
+    }
+    async send(options) {
+        const { threadId, username, avatarUrl, ...messageOptions } = options;
+        const requestInit = createMessageRequestInit(messageOptions);
+        const searchParams = new URLSearchParams({ wait: "true" });
+        if (threadId) {
+            searchParams.set("thread_id", threadId);
+        }
+        const message = await this.rest.request(`/webhooks/${this.id}/${this.token}?${searchParams.toString()}`, {
+            method: "POST",
+            body: appendWebhookPayload(requestInit.body, {
+                username,
+                avatar_url: avatarUrl,
+            }),
+            headers: requestInit.headers,
+            authenticated: false,
+        });
+        return new DiscordSentMessage(this.rest, message);
+    }
+}
+function appendWebhookPayload(body, webhookOverrides) {
+    if (body instanceof FormData) {
+        const payload = JSON.parse(String(body.get("payload_json") ?? "{}"));
+        if (webhookOverrides.username)
+            payload.username = webhookOverrides.username;
+        if (webhookOverrides.avatar_url)
+            payload.avatar_url = webhookOverrides.avatar_url;
+        body.set("payload_json", JSON.stringify(payload));
+        return body;
+    }
+    const payload = JSON.parse(String(body));
+    if (webhookOverrides.username)
+        payload.username = webhookOverrides.username;
+    if (webhookOverrides.avatar_url)
+        payload.avatar_url = webhookOverrides.avatar_url;
+    return JSON.stringify(payload);
+}

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export { ChannelType } from "./types/ChannelType.js";
 export { InteractionFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
 export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
+export { MessageFlags, type APIAllowedMentions } from "discord-api-types/v10";
 export { TextInputStyle } from "discord-api-types/v10";
 export { MiniPermFlags } from "./types/PermissionFlags.js";
 export type { ActionRowComponent, MessageActionRowComponent, InteractionComponentData, } from "./types/ComponentTypes.js";
@@ -26,6 +27,9 @@ export type { OAuthConfig, OAuthTokens, DiscordUser, } from "./oauth/DiscordOAut
 export { OAuthTokenStorage } from "./oauth/OAuthTokenStorage.js";
 export { DiscordRestClient } from "./core/http/DiscordRestClient.js";
 export type { DiscordRestClientOptions } from "./core/http/DiscordRestClient.js";
+export { DiscordSentMessage } from "./core/messages/DiscordSentMessage.js";
+export type { DiscordMessageFile, DiscordReaction, DiscordSendMessageOptions, DiscordStartThreadOptions, DiscordWebhookSendOptions, } from "./core/messages/message-payloads.js";
+export { DiscordWebhook } from "./core/webhooks/DiscordWebhook.js";
 export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export type { InteractionContextOptions } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";

package/dist/index.js

@@ -10,6 +10,7 @@ export { ChannelType } from "./types/ChannelType.js";
 export { InteractionFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
 export { SeparatorSpacingSize } from "./types/SeparatorSpacingSize.js";
+export { MessageFlags } from "discord-api-types/v10";
 export { TextInputStyle } from "discord-api-types/v10";
 export { MiniPermFlags } from "./types/PermissionFlags.js";
 export * from "./builders/index.js";
@@ -20,6 +21,8 @@ export { generateOAuthUrl, getOAuthTokens, refreshAccessToken, getDiscordUser, e
 export { OAuthTokenStorage } from "./oauth/OAuthTokenStorage.js";
 // New v10 core modules
 export { DiscordRestClient } from "./core/http/DiscordRestClient.js";
+export { DiscordSentMessage } from "./core/messages/DiscordSentMessage.js";
+export { DiscordWebhook } from "./core/webhooks/DiscordWebhook.js";
 export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";
 export { InteractionRouter } from "./router/InteractionRouter.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@minesa-org/mini-interaction",
-  "version": "0.4.12",
+  "version": "0.4.16",
   "description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
   "type": "module",
   "main": "dist/index.js",