@minesa-org/mini-interaction 0.4.3 → 0.4.4

package/dist/compat/MiniInteraction.d.ts

@@ -0,0 +1,64 @@
+type TimeoutConfig = {
+    initialResponseTimeout?: number;
+    autoDeferSlowOperations?: boolean;
+    enableTimeoutWarnings?: boolean;
+    enableResponseDebugLogging?: boolean;
+};
+export type MiniInteractionOptions = {
+    commandsDirectory?: string;
+    componentsDirectory?: string;
+    utilsDirectory?: string;
+    timeoutConfig?: TimeoutConfig;
+    debug?: boolean;
+    cwd?: string;
+    publicKey?: string;
+    applicationId?: string;
+    token?: string;
+};
+type NodeRequest = {
+    body?: unknown;
+    rawBody?: string | Uint8Array | Buffer;
+    headers: Record<string, string | string[] | undefined> | {
+        get(name: string): string | null;
+    };
+    method?: string;
+    [Symbol.asyncIterator]?: () => AsyncIterableIterator<Uint8Array>;
+    on?: (event: string, listener: (...args: unknown[]) => void) => void;
+};
+type NodeResponse = {
+    statusCode?: number;
+    setHeader?: (name: string, value: string) => void;
+    end: (body?: string) => void;
+    status?: (code: number) => NodeResponse;
+    json?: (body: unknown) => void;
+};
+export declare class MiniInteraction {
+    private readonly options;
+    private readonly projectRoot;
+    private readonly rest;
+    private readonly responseStates;
+    private loadedModulesPromise?;
+    constructor(options?: MiniInteractionOptions);
+    createNodeHandler(): (req: NodeRequest, res: NodeResponse) => Promise<void>;
+    private dispatch;
+    private executeCommandHandler;
+    private executeComponentHandler;
+    private executeModalHandler;
+    private runWithResponseLifecycle;
+    private loadModules;
+    private discoverModules;
+    private loadDirectory;
+    private normalizeModuleExports;
+    private normalizeExportValue;
+    private walkFiles;
+    private isImportableModule;
+    private isInteractionCommand;
+    private getCommandName;
+    private isCustomIdHandler;
+    private looksLikeModalFile;
+    private readRawBody;
+    private getHeader;
+    private sendJson;
+}
+export declare const LegacyMiniInteractionAdapter: typeof MiniInteraction;
+export {};

package/dist/compat/MiniInteraction.js

@@ -0,0 +1,336 @@
+import { readdir } from "node:fs/promises";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { ApplicationCommandType, InteractionResponseType, InteractionType, } from "discord-api-types/v10";
+import { createCommandInteraction } from "../utils/CommandInteractionOptions.js";
+import { createAppCommandInteraction, createMessageContextMenuInteraction, createUserContextMenuInteraction, } from "../utils/ContextMenuInteraction.js";
+import { createMessageComponentInteraction } from "../utils/MessageComponentInteraction.js";
+import { createModalSubmitInteraction } from "../utils/ModalSubmitInteraction.js";
+import { DiscordRestClient } from "../core/http/DiscordRestClient.js";
+import { verifyAndParseInteraction } from "../core/interactions/InteractionVerifier.js";
+export class MiniInteraction {
+    options;
+    projectRoot;
+    rest;
+    responseStates = new Map();
+    loadedModulesPromise;
+    constructor(options = {}) {
+        this.options = options;
+        this.projectRoot = path.resolve(options.cwd ?? process.cwd());
+        const applicationId = options.applicationId ??
+            process.env.DISCORD_APPLICATION_ID ??
+            process.env.DISCORD_APP_ID;
+        const token = options.token ??
+            process.env.DISCORD_BOT_TOKEN ??
+            process.env.DISCORD_TOKEN;
+        if (!applicationId || !token) {
+            throw new Error("[MiniInteraction] Missing Discord REST credentials. Set applicationId/token or DISCORD_APPLICATION_ID + DISCORD_BOT_TOKEN.");
+        }
+        this.rest = new DiscordRestClient({ applicationId, token });
+    }
+    createNodeHandler() {
+        return async (req, res) => {
+            try {
+                const body = await this.readRawBody(req);
+                const signature = this.getHeader(req.headers, "x-signature-ed25519");
+                const timestamp = this.getHeader(req.headers, "x-signature-timestamp");
+                const publicKey = this.options.publicKey ?? process.env.DISCORD_PUBLIC_KEY;
+                if (!publicKey) {
+                    this.sendJson(res, 500, {
+                        error: "[MiniInteraction] Missing DISCORD_PUBLIC_KEY.",
+                    });
+                    return;
+                }
+                if (!signature || !timestamp) {
+                    this.sendJson(res, 401, {
+                        error: "[MiniInteraction] Missing Discord signature headers.",
+                    });
+                    return;
+                }
+                const interaction = await verifyAndParseInteraction({
+                    body,
+                    signature,
+                    timestamp,
+                    publicKey,
+                });
+                if (interaction.type === InteractionType.Ping) {
+                    this.sendJson(res, 200, { type: InteractionResponseType.Pong });
+                    return;
+                }
+                const response = await this.dispatch(interaction);
+                this.sendJson(res, 200, response ?? {
+                    type: InteractionResponseType.DeferredChannelMessageWithSource,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "[MiniInteraction] Unknown error";
+                if (this.options.debug) {
+                    console.error("[MiniInteraction] createNodeHandler failed", error);
+                }
+                this.sendJson(res, 500, { error: message });
+            }
+        };
+    }
+    async dispatch(interaction) {
+        const modules = await this.loadModules();
+        if (interaction.type === InteractionType.ApplicationCommand) {
+            const command = modules.commands.find((candidate) => this.getCommandName(candidate) === interaction.data.name);
+            if (!command)
+                return undefined;
+            return this.executeCommandHandler(command.handler, interaction);
+        }
+        if (interaction.type === InteractionType.MessageComponent) {
+            const component = modules.components.find((candidate) => candidate.customId === interaction.data.custom_id);
+            if (!component)
+                return undefined;
+            return this.executeComponentHandler(component.handler, interaction);
+        }
+        if (interaction.type === InteractionType.ModalSubmit) {
+            const modal = modules.modals.find((candidate) => candidate.customId === interaction.data.custom_id);
+            if (!modal)
+                return undefined;
+            return this.executeModalHandler(modal.handler, interaction);
+        }
+        return undefined;
+    }
+    async executeCommandHandler(handler, interaction) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => {
+            switch (interaction.data.type) {
+                case ApplicationCommandType.ChatInput:
+                    return handler(createCommandInteraction(interaction, helpers));
+                case ApplicationCommandType.User:
+                    return handler(createUserContextMenuInteraction(interaction, helpers));
+                case ApplicationCommandType.Message:
+                    return handler(createMessageContextMenuInteraction(interaction, helpers));
+                default:
+                    if (interaction.data.type === ApplicationCommandType.PrimaryEntryPoint) {
+                        return handler(createAppCommandInteraction(interaction, helpers));
+                    }
+                    throw new Error(`[MiniInteraction] Unsupported application command type: ${String(interaction.data.type)}`);
+            }
+        });
+    }
+    async executeComponentHandler(handler, interaction) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createMessageComponentInteraction(interaction, helpers)));
+    }
+    async executeModalHandler(handler, interaction) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createModalSubmitInteraction(interaction, helpers)));
+    }
+    async runWithResponseLifecycle(interaction, executor) {
+        let ackResponse;
+        const helpers = {
+            canRespond: (interactionId) => (this.responseStates.get(interactionId) ?? "pending") === "pending",
+            trackResponse: (interactionId, _token, state) => {
+                this.responseStates.set(interactionId, state);
+            },
+            onAck: (response) => {
+                ackResponse = response;
+            },
+            sendFollowUp: async (token, response, messageId) => {
+                const responseData = "data" in response ? response.data ?? {} : {};
+                if (messageId === "@original") {
+                    await this.rest.editOriginal(token, responseData);
+                    return;
+                }
+                await this.rest.createFollowup(token, responseData);
+            },
+        };
+        const autoDeferMs = Math.min(2500, this.options.timeoutConfig?.initialResponseTimeout ?? 2500);
+        const autoDeferTimer = this.options.timeoutConfig?.autoDeferSlowOperations === true
+            ? setTimeout(() => {
+                if (!helpers.canRespond(interaction.id))
+                    return;
+                if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
+                    console.warn(`[MiniInteraction] Auto-deferred interaction ${interaction.id} after ${autoDeferMs}ms.`);
+                }
+                ackResponse = {
+                    type: InteractionResponseType.DeferredChannelMessageWithSource,
+                };
+                helpers.trackResponse(interaction.id, interaction.token, "deferred");
+            }, autoDeferMs)
+            : undefined;
+        const timeoutWarningMs = this.options.timeoutConfig?.initialResponseTimeout;
+        const timeoutWarningTimer = this.options.timeoutConfig?.enableTimeoutWarnings && timeoutWarningMs
+            ? setTimeout(() => {
+                if (this.responseStates.get(interaction.id))
+                    return;
+                console.warn(`[MiniInteraction] Interaction ${interaction.id} exceeded ${timeoutWarningMs}ms without a response.`);
+            }, timeoutWarningMs)
+            : undefined;
+        try {
+            const result = await executor(helpers);
+            if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
+                console.debug(`[MiniInteraction] Interaction ${interaction.id} completed with ${result ? "explicit" : "fallback"} response.`);
+            }
+            return result ?? ackResponse;
+        }
+        finally {
+            if (autoDeferTimer)
+                clearTimeout(autoDeferTimer);
+            if (timeoutWarningTimer)
+                clearTimeout(timeoutWarningTimer);
+        }
+    }
+    async loadModules() {
+        if (!this.loadedModulesPromise) {
+            this.loadedModulesPromise = this.discoverModules();
+        }
+        return this.loadedModulesPromise;
+    }
+    async discoverModules() {
+        const commands = this.options.commandsDirectory
+            ? await this.loadDirectory(this.options.commandsDirectory)
+            : [];
+        const components = this.options.componentsDirectory
+            ? await this.loadDirectory(this.options.componentsDirectory)
+            : [];
+        const loaded = {
+            commands: [],
+            components: [],
+            modals: [],
+        };
+        for (const { filePath, value } of commands) {
+            if (this.isInteractionCommand(value)) {
+                loaded.commands.push(value);
+            }
+            else if (this.options.debug) {
+                console.warn(`[MiniInteraction] Ignored non-command module: ${filePath}`);
+            }
+        }
+        for (const { filePath, value } of components) {
+            if (!this.isCustomIdHandler(value)) {
+                if (this.options.debug) {
+                    console.warn(`[MiniInteraction] Ignored non-component module: ${filePath}`);
+                }
+                continue;
+            }
+            if (this.looksLikeModalFile(filePath)) {
+                loaded.modals.push(value);
+            }
+            else {
+                loaded.components.push(value);
+            }
+        }
+        return loaded;
+    }
+    async loadDirectory(directory) {
+        const absoluteDirectory = path.resolve(this.projectRoot, directory);
+        const files = await this.walkFiles(absoluteDirectory);
+        const loaded = await Promise.all(files
+            .filter((filePath) => this.isImportableModule(filePath))
+            .map(async (filePath) => ({
+            filePath,
+            values: this.normalizeModuleExports(await import(pathToFileURL(filePath).href)),
+        })));
+        return loaded.flatMap(({ filePath, values }) => values.map((value) => ({ filePath, value })));
+    }
+    normalizeModuleExports(moduleValue) {
+        const values = [];
+        if ("default" in moduleValue) {
+            values.push(...this.normalizeExportValue(moduleValue.default));
+        }
+        for (const [key, value] of Object.entries(moduleValue)) {
+            if (key === "default")
+                continue;
+            values.push(...this.normalizeExportValue(value));
+        }
+        return values;
+    }
+    normalizeExportValue(value) {
+        if (Array.isArray(value))
+            return value;
+        return [value];
+    }
+    async walkFiles(directory) {
+        const entries = await readdir(directory, { withFileTypes: true });
+        const results = await Promise.all(entries.map(async (entry) => {
+            const resolvedPath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                return this.walkFiles(resolvedPath);
+            }
+            return [resolvedPath];
+        }));
+        return results.flat();
+    }
+    isImportableModule(filePath) {
+        if (filePath.endsWith(".d.ts"))
+            return false;
+        return /\.(ts|mts|js|mjs|cjs)$/i.test(filePath);
+    }
+    isInteractionCommand(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            "data" in value &&
+            "handler" in value &&
+            typeof value.handler === "function");
+    }
+    getCommandName(command) {
+        const data = command.data;
+        if (typeof data.toJSON === "function") {
+            return data.toJSON().name;
+        }
+        return data.name;
+    }
+    isCustomIdHandler(value) {
+        return (typeof value === "object" &&
+            value !== null &&
+            "customId" in value &&
+            "handler" in value &&
+            typeof value.customId === "string" &&
+            typeof value.handler === "function");
+    }
+    looksLikeModalFile(filePath) {
+        const normalized = filePath.toLowerCase();
+        return (normalized.includes(`${path.sep}modals${path.sep}`) ||
+            normalized.endsWith(".modal.ts") ||
+            normalized.endsWith(".modal.js") ||
+            normalized.includes("_modal.") ||
+            normalized.includes("-modal."));
+    }
+    async readRawBody(req) {
+        if (typeof req.rawBody === "string")
+            return req.rawBody;
+        if (req.rawBody instanceof Uint8Array) {
+            return Buffer.from(req.rawBody).toString("utf8");
+        }
+        if (typeof req.body === "string")
+            return req.body;
+        if (req.body instanceof Uint8Array) {
+            return Buffer.from(req.body).toString("utf8");
+        }
+        if (req.body && typeof req.body === "object") {
+            return JSON.stringify(req.body);
+        }
+        if (typeof req[Symbol.asyncIterator] === "function") {
+            const chunks = [];
+            for await (const chunk of req) {
+                chunks.push(Buffer.from(chunk));
+            }
+            return Buffer.concat(chunks).toString("utf8");
+        }
+        return "";
+    }
+    getHeader(headers, name) {
+        if (typeof headers.get === "function") {
+            return headers.get(name) ?? undefined;
+        }
+        const recordHeaders = headers;
+        const direct = recordHeaders[name] ??
+            recordHeaders[name.toLowerCase()] ??
+            recordHeaders[name.toUpperCase()];
+        if (Array.isArray(direct))
+            return direct[0];
+        return direct;
+    }
+    sendJson(res, statusCode, body) {
+        if (typeof res.status === "function" && typeof res.json === "function") {
+            const response = res.status(statusCode);
+            response.json?.(body);
+            return;
+        }
+        res.statusCode = statusCode;
+        res.setHeader?.("Content-Type", "application/json; charset=utf-8");
+        res.end(JSON.stringify(body));
+    }
+}
+export const LegacyMiniInteractionAdapter = MiniInteraction;

package/dist/index.d.ts

@@ -30,6 +30,8 @@ export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export type { InteractionContextOptions } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";
 export { InteractionRouter } from "./router/InteractionRouter.js";
+export { MiniInteraction, LegacyMiniInteractionAdapter, } from "./compat/MiniInteraction.js";
+export type { MiniInteractionOptions } from "./compat/MiniInteraction.js";
 export type { APIRadioComponent, APIRadioOption } from "./types/radio.js";
 export { RADIO_COMPONENT_TYPE } from "./types/radio.js";
 export type { APICheckboxComponent, APICheckboxOption } from "./types/checkbox.js";

package/dist/index.js

@@ -23,6 +23,7 @@ export { DiscordRestClient } from "./core/http/DiscordRestClient.js";
 export { InteractionContext } from "./core/interactions/InteractionContext.js";
 export { verifyAndParseInteraction } from "./core/interactions/InteractionVerifier.js";
 export { InteractionRouter } from "./router/InteractionRouter.js";
+export { MiniInteraction, LegacyMiniInteractionAdapter, } from "./compat/MiniInteraction.js";
 export { RADIO_COMPONENT_TYPE } from "./types/radio.js";
 export { CHECKBOX_COMPONENT_TYPE } from "./types/checkbox.js";
 export { ValidationError } from "./types/validation.js";

package/package.json

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