@minesa-org/mini-interaction 0.4.9 → 0.4.11

package/dist/compat/MiniInteraction.js

@@ -255,6 +255,10 @@ export class MiniInteraction {
         const autoDeferMs = Math.min(2500, this.options.timeoutConfig?.initialResponseTimeout ?? 2500);
         const autoDeferTimer = this.options.timeoutConfig?.autoDeferSlowOperations === true
             ? setTimeout(() => {
+                if (initialResponseCommitted)
+                    return;
+                if (this.responseStates.get(interaction.id))
+                    return;
                 if (!helpers.canRespond(interaction.id))
                     return;
                 if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {

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.9",
+  "version": "0.4.11",
   "description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
   "type": "module",
   "main": "dist/index.js",