mirror of
https://github.com/Elysola/WebHooker.git
synced 2026-11-20 17:13:49 +00:00
Long rate-limit sleeps block delivery progress inside a worker. Return a retryable 429 for the queue when the wait exceeds the bound.
127 lines
3.8 KiB
TypeScript
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);
|
|
}
|