@minesa-org/mini-interaction 0.4.8 → 0.4.10

package/dist/compat/MiniInteraction.d.ts

@@ -80,6 +80,8 @@ export declare class MiniInteraction {
     private normalizeModuleExports;
     private normalizeExportValue;
     private walkFiles;
+    private getDefaultInitialResponse;
+    private isDeferredResponse;
     private isImportableModule;
     private isInteractionCommand;
     private getCommandName;

package/dist/compat/MiniInteraction.js

@@ -31,6 +31,14 @@ export class MiniInteraction {
     }
     createNodeHandler() {
         return async (req, res) => {
+            let responseSent = false;
+            const commitInitialResponse = (response) => {
+                if (responseSent)
+                    return false;
+                this.sendJson(res, 200, response);
+                responseSent = true;
+                return true;
+            };
             try {
                 const body = await this.readRawBody(req);
                 const signature = this.getHeader(req.headers, "x-signature-ed25519");
@@ -58,17 +66,20 @@ export class MiniInteraction {
                     this.sendJson(res, 200, { type: InteractionResponseType.Pong });
                     return;
                 }
-                const response = await this.dispatch(interaction);
-                this.sendJson(res, 200, response ?? {
-                    type: InteractionResponseType.DeferredChannelMessageWithSource,
-                });
+                const response = await this.dispatch(interaction, commitInitialResponse);
+                if (!responseSent) {
+                    this.sendJson(res, 200, response ?? this.getDefaultInitialResponse(interaction));
+                    responseSent = true;
+                }
             }
             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 });
+                if (!responseSent) {
+                    this.sendJson(res, 500, { error: message });
+                }
             }
         };
     }
@@ -156,29 +167,29 @@ export class MiniInteraction {
             }
         };
     }
-    async dispatch(interaction) {
+    async dispatch(interaction, commitInitialResponse) {
         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);
+            return this.executeCommandHandler(command.handler, interaction, commitInitialResponse);
         }
         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);
+            return this.executeComponentHandler(component.handler, interaction, commitInitialResponse);
         }
         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 this.executeModalHandler(modal.handler, interaction, commitInitialResponse);
         }
         return undefined;
     }
-    async executeCommandHandler(handler, interaction) {
+    async executeCommandHandler(handler, interaction, commitInitialResponse) {
         return this.runWithResponseLifecycle(interaction, async (helpers) => {
             switch (interaction.data.type) {
                 case ApplicationCommandType.ChatInput:
@@ -193,17 +204,19 @@ export class MiniInteraction {
                     }
                     throw new Error(`[MiniInteraction] Unsupported application command type: ${String(interaction.data.type)}`);
             }
-        });
+        }, commitInitialResponse);
     }
-    async executeComponentHandler(handler, interaction) {
-        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createMessageComponentInteraction(interaction, helpers)));
+    async executeComponentHandler(handler, interaction, commitInitialResponse) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createMessageComponentInteraction(interaction, helpers)), commitInitialResponse);
     }
-    async executeModalHandler(handler, interaction) {
-        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createModalSubmitInteraction(interaction, helpers)));
+    async executeModalHandler(handler, interaction, commitInitialResponse) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createModalSubmitInteraction(interaction, helpers)), commitInitialResponse);
     }
-    async runWithResponseLifecycle(interaction, executor) {
+    async runWithResponseLifecycle(interaction, executor, commitInitialResponse) {
         let ackResponse;
         let initialResponseCommitted = false;
+        let followUpSent = false;
+        let committedInitialResponse;
         const helpers = {
             // Legacy helper contracts use canRespond for both initial acknowledgements
             // and later editReply/followUp calls. The compat layer does not currently
@@ -215,6 +228,10 @@ export class MiniInteraction {
             },
             onAck: (response) => {
                 ackResponse = response;
+                if (!initialResponseCommitted && commitInitialResponse?.(response)) {
+                    initialResponseCommitted = true;
+                    committedInitialResponse = response;
+                }
             },
             sendFollowUp: async (token, response, messageId) => {
                 // If the initial interaction response has not been sent yet, collapse the
@@ -228,9 +245,11 @@ export class MiniInteraction {
                 const responseData = "data" in response ? response.data ?? {} : {};
                 if (messageId === "@original") {
                     await this.rest.editOriginal(token, responseData);
+                    followUpSent = true;
                     return;
                 }
                 await this.rest.createFollowup(token, responseData);
+                followUpSent = true;
             },
         };
         const autoDeferMs = Math.min(2500, this.options.timeoutConfig?.initialResponseTimeout ?? 2500);
@@ -241,10 +260,13 @@ export class MiniInteraction {
                 if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
                     console.warn(`[MiniInteraction] Auto-deferred interaction ${interaction.id} after ${autoDeferMs}ms.`);
                 }
-                ackResponse = {
-                    type: InteractionResponseType.DeferredChannelMessageWithSource,
-                };
+                const deferredResponse = this.getDefaultInitialResponse(interaction);
+                ackResponse = deferredResponse;
                 helpers.trackResponse(interaction.id, interaction.token, "deferred");
+                if (!initialResponseCommitted && commitInitialResponse?.(deferredResponse)) {
+                    initialResponseCommitted = true;
+                    committedInitialResponse = deferredResponse;
+                }
             }, autoDeferMs)
             : undefined;
         const timeoutWarningMs = this.options.timeoutConfig?.initialResponseTimeout;
@@ -260,6 +282,18 @@ export class MiniInteraction {
             if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
                 console.debug(`[MiniInteraction] Interaction ${interaction.id} completed with ${result ? "explicit" : "fallback"} response.`);
             }
+            if (initialResponseCommitted &&
+                result &&
+                !followUpSent &&
+                committedInitialResponse &&
+                this.isDeferredResponse(committedInitialResponse) &&
+                !this.isDeferredResponse(result)) {
+                const responseData = "data" in result ? result.data ?? {} : {};
+                await this.rest.editOriginal(interaction.token, responseData);
+            }
+            if (initialResponseCommitted) {
+                return undefined;
+            }
             initialResponseCommitted = true;
             return result ?? ackResponse;
         }
@@ -351,6 +385,16 @@ export class MiniInteraction {
         }));
         return results.flat();
     }
+    getDefaultInitialResponse(interaction) {
+        if (interaction.type === InteractionType.MessageComponent) {
+            return { type: InteractionResponseType.DeferredMessageUpdate };
+        }
+        return { type: InteractionResponseType.DeferredChannelMessageWithSource };
+    }
+    isDeferredResponse(response) {
+        return (response.type === InteractionResponseType.DeferredChannelMessageWithSource ||
+            response.type === InteractionResponseType.DeferredMessageUpdate);
+    }
     isImportableModule(filePath) {
         if (filePath.endsWith(".d.ts"))
             return false;

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

@@ -15,6 +15,7 @@ export declare class DiscordRestClient {
     request<T>(path: string, init?: RequestInit & {
         authenticated?: boolean;
     }): Promise<T>;
+    private createRequestError;
     createFollowup(interactionToken: string, body: unknown): Promise<unknown>;
     editOriginal(interactionToken: string, body: unknown): Promise<unknown>;
 }

package/dist/core/http/DiscordRestClient.js

@@ -14,18 +14,33 @@ export class DiscordRestClient {
         let lastError;
         const { authenticated = true, ...requestInit } = init;
         for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
-            const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
-                ...requestInit,
-                headers: {
-                    ...(authenticated ? { Authorization: `Bot ${this.options.token}` } : {}),
-                    'Content-Type': 'application/json',
-                    ...(requestInit.headers ?? {}),
-                },
-            });
+            let response;
+            try {
+                response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+                    ...requestInit,
+                    headers: {
+                        ...(authenticated ? { Authorization: `Bot ${this.options.token}` } : {}),
+                        'Content-Type': 'application/json',
+                        ...(requestInit.headers ?? {}),
+                    },
+                });
+            }
+            catch (error) {
+                lastError = this.createRequestError(path, requestInit.method, error);
+                if (attempt < this.maxRetries) {
+                    await sleep(150 * (attempt + 1));
+                    continue;
+                }
+                break;
+            }
             if (response.status === 429) {
-                const retryAfter = Number(response.headers.get('retry-after') ?? '1');
-                await sleep(Math.ceil(retryAfter * 1000));
-                continue;
+                if (attempt < this.maxRetries) {
+                    const retryAfter = Number(response.headers.get('retry-after') ?? '1');
+                    await sleep(Math.ceil(retryAfter * 1000));
+                    continue;
+                }
+                lastError = new Error(`[DiscordRestClient] ${requestInit.method ?? 'GET'} ${path} failed: 429`);
+                break;
             }
             if (response.ok) {
                 if (response.status === 204)
@@ -41,6 +56,10 @@ export class DiscordRestClient {
         }
         throw lastError instanceof Error ? lastError : new Error('[DiscordRestClient] unknown request failure');
     }
+    createRequestError(path, method, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return new Error(`[DiscordRestClient] ${method ?? 'GET'} ${path} failed: ${message}`, { cause: error instanceof Error ? error : undefined });
+    }
     createFollowup(interactionToken, body) {
         return this.request(`/webhooks/${this.options.applicationId}/${interactionToken}`, {
             method: 'POST',

package/dist/core/interactions/__tests__/interaction-context.test.js

@@ -29,6 +29,27 @@ test('editReply and followUp call webhook endpoints', async () => {
     assert.equal(calls.length, 2);
     assert.match(calls[0], /messages\/\@original/);
 });
+test('editReply retries transient transport failures', async () => {
+    let attempts = 0;
+    const fetchImpl = (async () => {
+        attempts += 1;
+        if (attempts === 1) {
+            throw new TypeError('fetch failed', {
+                cause: { code: 'UND_ERR_SOCKET' },
+            });
+        }
+        return new Response(JSON.stringify({ ok: true }), { status: 200 });
+    });
+    const rest = new DiscordRestClient({
+        token: 'x',
+        applicationId: 'app',
+        fetchImplementation: fetchImpl,
+        maxRetries: 1,
+    });
+    const ctx = new InteractionContext({ interaction, rest });
+    await ctx.editReply({ content: 'edit' });
+    assert.equal(attempts, 2);
+});
 test('auto-ack diagnostics callback fires for slow handler', async () => {
     let message = '';
     const { rest } = createRest();

package/package.json

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