Files
WebHooker/server/lib/drivers/discord/rest.ts
T
翅膀 0761c4bc5a fix(discord): defer long rate-limit waits
Long rate-limit sleeps block delivery progress inside a worker.
Return a retryable 429 for the queue when the wait exceeds the bound.
2026-10-23 23:22:21 +08:00

127 lines
3.8 KiB
TypeScript

import { log } from "../../lib/log";
import type { SendResult } from "../types";
const DISCORD_API = "https://discord.com/api/v10";
interface DiscordMessage {
id?: string;
}
/**
* Longest rate-limit wait (seconds) slept inside one request; a longer one is
* returned as a 429 failure so the delivery queue retries it later instead.
*/
const MAX_INLINE_RETRY_AFTER = 10;
/**
* Longest a single API call may take. Bounded, so a message edit always ends
* well within the update-chain lock it runs under (see `deliverUpdate`).
*/
export const REQUEST_TIMEOUT_MS = 15_000;
async function request(
url: string,
method: string,
token: string,
message: unknown,
channelId: string,
): Promise<SendResult> {
for (let attempt = 0; attempt < 3; attempt++) {
try {
const res = await fetch(url, {
method,
headers: {
Authorization: `Bot ${token}`,
"Content-Type": "application/json",
},
body: JSON.stringify(message),
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
});
if (res.status === 429) {
const rateLimit = (await res.json().catch(() => ({}))) as { retry_after?: number };
const seconds = Number(rateLimit.retry_after);
const retryAfter = Number.isFinite(seconds) && seconds > 0 ? seconds : 1;
log.warn({ retryAfter, attempt }, "Rate limited");
if (retryAfter > MAX_INLINE_RETRY_AFTER || attempt === 2) {
return {
ok: false,
error: `Rate limited (retry_after=${retryAfter})`,
errorCode: "RATE_LIMITED",
status: 429,
attempts: attempt + 1,
};
}
await new Promise((r) => setTimeout(r, retryAfter * 1000));
continue;
}
if (!res.ok) {
const err = await res.text();
if (res.status >= 500) {
log.error({ status: res.status, err, attempt, channelId }, "Discord API 5xx");
if (attempt === 2)
return {
ok: false,
error: err,
errorCode: "DISCORD_5XX",
status: res.status,
attempts: attempt + 1,
};
await new Promise((r) => setTimeout(r, 1000 * (attempt + 1)));
continue;
}
log.error({ status: res.status, err, channelId }, "Discord API error");
return {
ok: false,
error: err,
errorCode: "DISCORD_ERROR",
status: res.status,
attempts: attempt + 1,
};
}
let messageId: string | undefined;
try {
const data = (await res.json()) as DiscordMessage;
messageId = data.id;
} catch {
// ignore malformed success body
}
return { ok: true, status: res.status, messageId, attempts: attempt + 1 };
} catch (err) {
log.error({ err, attempt, channelId }, "Failed to send message");
if (attempt === 2)
return { ok: false, error: String(err), errorCode: "NETWORK", attempts: attempt + 1 };
await new Promise((r) => setTimeout(r, 1000 * (attempt + 1)));
}
}
return { ok: false, error: "Max retries exceeded", errorCode: "RETRIES", attempts: 3 };
}
export async function sendMessage(
token: string,
channelId: string,
message: unknown,
threadId?: string,
): Promise<SendResult> {
const url = threadId
? `${DISCORD_API}/channels/${threadId}/messages`
: `${DISCORD_API}/channels/${channelId}/messages`;
return request(url, "POST", token, message, channelId);
}
export async function editMessage(
token: string,
channelId: string,
messageId: string,
message: unknown,
threadId?: string,
): Promise<SendResult> {
const base = threadId ?? channelId;
const url = `${DISCORD_API}/channels/${base}/messages/${messageId}`;
return request(url, "PATCH", token, message, channelId);
}