@buape/carbon 0.13.0 → 0.15.0

package/dist/src/classes/RequestClient.js

@@ -1,12 +1,16 @@
 import { DiscordError } from "../errors/DiscordError.js";
 import { RateLimitError } from "../errors/RatelimitError.js";
+import { serializeRequestBody } from "../internals/RequestBody.js";
+import { normalizeRequestSchedulerOptions, RequestScheduler } from "../internals/RequestScheduler.js";
 const defaultOptions = {
     tokenHeader: "Bot",
     baseUrl: "https://discord.com/api",
     apiVersion: 10,
     userAgent: "DiscordBot (https://github.com/buape/carbon, v0.0.0)",
     timeout: 15000,
-    queueRequests: true
+    queueRequests: true,
+    maxQueueSize: 1000,
+    runtimeProfile: "serverless"
 };
 /**
  * This is the main class that handles making requests to the Discord API.
@@ -17,23 +21,28 @@ export class RequestClient {
      * The options used to initialize the client
      */
     options;
-    queue = [];
     token;
-    rateLimitResetTime;
-    abortController = null;
+    customFetch;
+    nextRequestId = 0;
+    wakeupTimer = null;
+    wakeupDueAt = null;
+    activeWorkers = 0;
+    activeBucketKeys = new Set();
+    maxConcurrentWorkers = 1;
+    maxRateLimitRetries = 2;
+    scheduler;
+    routeBuckets = new Map();
+    bucketStates = new Map();
+    globalRateLimitUntil = 0;
+    requestControllers = new Set();
     constructor(token, options) {
         this.token = token;
+        this.customFetch = options?.fetch;
         this.options = {
             ...defaultOptions,
             ...options
         };
-        this.rateLimitResetTime = 0;
-    }
-    async waitForRateLimit() {
-        const delay = this.rateLimitResetTime - Date.now();
-        if (delay > 0) {
-            await new Promise((resolve) => setTimeout(resolve, delay));
-        }
+        this.configureScheduler();
     }
     async get(path, query) {
         return await this.request("GET", path, { query });
@@ -50,178 +59,438 @@ export class RequestClient {
     async delete(path, data, query) {
         return await this.request("DELETE", path, { data, query });
     }
+    configureScheduler() {
+        const normalized = normalizeRequestSchedulerOptions({
+            runtimeProfile: this.options.runtimeProfile ?? "serverless",
+            maxQueueSize: this.options.maxQueueSize,
+            scheduler: this.options.scheduler
+        });
+        this.maxConcurrentWorkers = normalized.maxConcurrency;
+        this.maxRateLimitRetries = normalized.maxRateLimitRetries;
+        this.scheduler = new RequestScheduler({
+            lanes: normalized.lanes
+        });
+    }
     async request(method, path, { data, query }) {
-        if (this.options.queueRequests) {
+        const routeKey = this.getRouteKey(method, path);
+        if (!this.options.queueRequests) {
             return new Promise((resolve, reject) => {
-                this.queue.push({ method, path, data, query, resolve, reject });
-                this.processQueue();
+                this.executeRequest({
+                    id: this.nextRequestId++,
+                    method,
+                    path,
+                    data,
+                    query,
+                    resolve,
+                    reject,
+                    routeKey,
+                    priority: this.getPriority(method, path),
+                    enqueuedAt: Date.now(),
+                    retryCount: 0
+                })
+                    .then(resolve)
+                    .catch((err) => {
+                    reject(err);
+                });
             });
         }
         return new Promise((resolve, reject) => {
-            this.executeRequest({ method, path, data, query, resolve, reject })
-                .then(resolve)
-                .catch((err) => {
-                reject(err);
+            const priority = this.getPriority(method, path);
+            const enqueueError = this.enqueueRequest({
+                id: this.nextRequestId++,
+                method,
+                path,
+                data,
+                query,
+                resolve,
+                reject,
+                routeKey,
+                priority,
+                enqueuedAt: Date.now(),
+                retryCount: 0
             });
+            if (enqueueError) {
+                reject(enqueueError);
+                return;
+            }
+            this.pumpQueue();
         });
     }
+    enqueueRequest(request) {
+        return this.scheduler.enqueue(request);
+    }
+    pumpQueue() {
+        if (!this.options.queueRequests)
+            return;
+        while (this.activeWorkers < this.maxConcurrentWorkers) {
+            const next = this.takeNextReadyRequest();
+            if (!next)
+                return;
+            this.activeWorkers += 1;
+            const bucketKey = this.getCurrentBucketKey(next.routeKey);
+            this.activeBucketKeys.add(bucketKey);
+            this.runQueuedRequest(next)
+                .catch((error) => {
+                console.error("[RequestClient] Queue worker failed", error);
+            })
+                .finally(() => {
+                this.activeBucketKeys.delete(bucketKey);
+                this.activeWorkers -= 1;
+                this.pumpQueue();
+            });
+        }
+    }
+    async runQueuedRequest(request) {
+        try {
+            const result = await this.executeRequest(request);
+            request.resolve(result);
+        }
+        catch (error) {
+            if (error instanceof RateLimitError &&
+                this.options.queueRequests &&
+                request.retryCount < this.maxRateLimitRetries) {
+                const enqueueError = this.enqueueRequest({
+                    ...request,
+                    retryCount: request.retryCount + 1,
+                    enqueuedAt: Date.now()
+                });
+                if (enqueueError) {
+                    request.reject(enqueueError);
+                    return;
+                }
+                return;
+            }
+            if (error instanceof Error) {
+                request.reject(error);
+                return;
+            }
+            request.reject(new Error("Unknown error during request", { cause: error }));
+        }
+    }
+    takeNextReadyRequest() {
+        const next = this.scheduler.takeNext({
+            isRouteReady: (routeKey) => this.getRouteWaitTime(routeKey),
+            isBucketActive: (routeKey) => this.activeBucketKeys.has(this.getCurrentBucketKey(routeKey))
+        });
+        if (!next.request) {
+            if (next.waitMs !== null) {
+                this.scheduleWakeup(next.waitMs);
+            }
+            return null;
+        }
+        this.clearWakeupTimer();
+        return next.request;
+    }
+    scheduleWakeup(waitMs) {
+        if (waitMs <= 0) {
+            this.clearWakeupTimer();
+            this.pumpQueue();
+            return;
+        }
+        const dueAt = Date.now() + waitMs;
+        if (this.wakeupTimer &&
+            this.wakeupDueAt !== null &&
+            this.wakeupDueAt <= dueAt) {
+            return;
+        }
+        if (this.wakeupTimer) {
+            clearTimeout(this.wakeupTimer);
+            this.wakeupTimer = null;
+        }
+        this.wakeupDueAt = dueAt;
+        this.wakeupTimer = setTimeout(() => {
+            this.wakeupTimer = null;
+            this.wakeupDueAt = null;
+            this.pumpQueue();
+        }, Math.max(0, dueAt - Date.now()));
+    }
+    clearWakeupTimer() {
+        if (!this.wakeupTimer) {
+            this.wakeupDueAt = null;
+            return;
+        }
+        clearTimeout(this.wakeupTimer);
+        this.wakeupTimer = null;
+        this.wakeupDueAt = null;
+    }
+    getRouteWaitTime(routeKey, now = Date.now()) {
+        if (this.globalRateLimitUntil > now) {
+            return this.globalRateLimitUntil - now;
+        }
+        const bucketKey = this.getCurrentBucketKey(routeKey);
+        const bucket = this.bucketStates.get(bucketKey);
+        if (bucket && bucket.delayUntil > now) {
+            return bucket.delayUntil - now;
+        }
+        return 0;
+    }
+    getPriority(method, path) {
+        const normalizedPath = path.toLowerCase();
+        const normalizedMethod = method.toUpperCase();
+        if (/^\/interactions\/\d+\/[^/]+\/callback$/.test(normalizedPath)) {
+            return "critical";
+        }
+        if (normalizedPath.startsWith("/webhooks/") &&
+            (normalizedMethod === "POST" ||
+                normalizedMethod === "PATCH" ||
+                normalizedMethod === "DELETE")) {
+            return "standard";
+        }
+        if (normalizedMethod !== "GET" &&
+            /\/channels\/\d+\/messages/.test(normalizedPath)) {
+            return "standard";
+        }
+        return "background";
+    }
     async executeRequest(request) {
-        await this.waitForRateLimit();
-        const { method, path, data, query } = request;
+        const { method, path, data, query, routeKey } = request;
+        await this.waitForBucket(routeKey);
         const queryString = query
             ? `?${Object.entries(query)
                 .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
                 .join("&")}`
             : "";
         const url = `${this.options.baseUrl}${path}${queryString}`;
+        const originalRequest = new Request(url, { method });
         const headers = this.token === "webhook"
             ? new Headers()
             : new Headers({
                 Authorization: `${this.options.tokenHeader} ${this.token}`
             });
-        // Add custom headers if provided
         if (data?.headers) {
             for (const [key, value] of Object.entries(data.headers)) {
                 headers.set(key, value);
             }
         }
-        this.abortController = new AbortController();
-        let body;
-        if (data?.body &&
-            typeof data.body === "object" &&
-            ("files" in data.body ||
-                ("data" in data.body &&
-                    data.body.data &&
-                    typeof data.body.data === "object" &&
-                    "files" in data.body.data))) {
-            const payload = data.body;
-            if (typeof payload === "string") {
-                data.body = { content: payload, attachments: [] };
-            }
-            else {
-                data.body = { ...payload, attachments: [] };
-            }
-            const formData = new FormData();
-            const files = (() => {
-                if (typeof payload === "object" && payload !== null) {
-                    if ("files" in payload) {
-                        return payload.files || [];
-                    }
-                    if ("data" in payload &&
-                        typeof payload.data === "object" &&
-                        payload.data !== null) {
-                        return (payload.data
-                            .files || []);
-                    }
-                }
-                return [];
-            })();
-            for (const [index, file] of files.entries()) {
-                let { data: fileData } = file;
-                if (!(fileData instanceof Blob)) {
-                    fileData = new Blob([fileData]);
-                }
-                formData.append(`files[${index}]`, fileData, file.name);
-                data.body.attachments.push({
-                    id: index,
-                    filename: file.name,
-                    description: file.description
-                });
-            }
-            if (data.body != null) {
-                const cleanedBody = {
-                    ...data.body,
-                    files: undefined
-                };
-                formData.append("payload_json", JSON.stringify(cleanedBody));
+        const abortController = new AbortController();
+        this.requestControllers.add(abortController);
+        const timeoutMs = typeof this.options.timeout === "number" && this.options.timeout > 0
+            ? this.options.timeout
+            : undefined;
+        const body = serializeRequestBody(data, headers);
+        let timeoutId;
+        if (timeoutMs !== undefined) {
+            timeoutId = setTimeout(() => {
+                abortController.abort();
+            }, timeoutMs);
+        }
+        let response;
+        const fetchFn = this.customFetch ?? fetch;
+        try {
+            response = await fetchFn(url, {
+                method,
+                headers,
+                body,
+                signal: abortController.signal
+            });
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
             }
-            body = formData;
+            this.requestControllers.delete(abortController);
+        }
+        let rawBody = "";
+        let parsedBody;
+        try {
+            rawBody = await response.text();
+        }
+        catch {
+            rawBody = "";
         }
-        else if (data?.body != null) {
-            headers.set("Content-Type", "application/json");
-            if (data.rawBody) {
-                body = data.body;
+        if (rawBody.length > 0) {
+            try {
+                parsedBody = JSON.parse(rawBody);
             }
-            else {
-                body = JSON.stringify(data.body);
+            catch {
+                parsedBody = undefined;
             }
         }
-        const response = await fetch(url, {
-            method,
-            headers,
-            body,
-            signal: this.abortController.signal
-        });
         if (response.status === 429) {
-            const responseBody = await response.json();
-            const rateLimitError = new RateLimitError(response, responseBody);
-            if (this.options.queueRequests) {
-                const rateLimitResetTime = Number(response.headers.get("Retry-After")) * 1000;
-                this.rateLimitResetTime = Date.now() + rateLimitResetTime;
-                if (rateLimitError.scope === "global") {
-                    await new Promise((res) => setTimeout(res, rateLimitResetTime));
-                    this.queue.unshift(request);
-                }
-            }
+            const rateLimitBody = parsedBody &&
+                typeof parsedBody === "object" &&
+                "retry_after" in parsedBody &&
+                "message" in parsedBody
+                ? parsedBody
+                : {
+                    message: typeof parsedBody === "string"
+                        ? parsedBody
+                        : rawBody || "You are being rate limited.",
+                    retry_after: (() => {
+                        const retryAfterHeader = response.headers.get("Retry-After");
+                        if (retryAfterHeader &&
+                            !Number.isNaN(Number(retryAfterHeader))) {
+                            return Number(retryAfterHeader);
+                        }
+                        return 1;
+                    })(),
+                    global: response.headers.get("X-RateLimit-Scope") === "global"
+                };
+            const rateLimitError = new RateLimitError(response, rateLimitBody, originalRequest);
+            this.scheduleRateLimit(routeKey, path, rateLimitError);
             throw rateLimitError;
         }
+        this.updateBucketFromHeaders(routeKey, path, response);
         if (response.status >= 400 && response.status < 600) {
-            throw new DiscordError(response, await response.json());
-        }
-        try {
-            return await response.json();
+            const discordErrorBody = parsedBody && typeof parsedBody === "object"
+                ? parsedBody
+                : {
+                    message: rawBody || "Discord API error",
+                    code: 0
+                };
+            throw new DiscordError(response, discordErrorBody);
         }
-        catch (err) {
-            if (err instanceof SyntaxError) {
-                // If there is no JSON
-                return await response.text();
+        if (parsedBody !== undefined)
+            return parsedBody;
+        if (rawBody.length > 0)
+            return rawBody;
+        return null;
+    }
+    async waitForBucket(routeKey) {
+        while (true) {
+            const now = Date.now();
+            if (this.globalRateLimitUntil > now) {
+                await sleep(this.globalRateLimitUntil - now);
+                continue;
+            }
+            const bucketKey = this.routeBuckets.get(routeKey) ?? routeKey;
+            const bucket = this.bucketStates.get(bucketKey);
+            if (bucket && bucket.delayUntil > now) {
+                await sleep(bucket.delayUntil - now);
+                continue;
             }
-            throw err;
+            break;
         }
     }
-    async processQueue() {
-        if (this.queue.length === 0)
-            return;
-        const queueItem = this.queue.shift();
-        if (!queueItem)
+    scheduleRateLimit(routeKey, path, error) {
+        const bucketKey = error.bucket
+            ? this.getBucketKey(routeKey, path, error.bucket)
+            : this.getCurrentBucketKey(routeKey);
+        const waitTime = Math.max(0, Math.ceil(error.retryAfter * 1000));
+        const now = Date.now();
+        const bucket = this.bucketStates.get(bucketKey) ?? {
+            delayUntil: 0,
+            extraBackoff: 0,
+            remaining: 0
+        };
+        const existingDelayPassed = bucket.delayUntil <= now;
+        const extraBackoff = existingDelayPassed
+            ? Math.min(bucket.extraBackoff ? bucket.extraBackoff * 2 : 1000, 60_000)
+            : (bucket.extraBackoff ?? 0);
+        const nextAvailable = now + waitTime + extraBackoff;
+        this.bucketStates.set(bucketKey, {
+            delayUntil: nextAvailable,
+            extraBackoff,
+            remaining: 0
+        });
+        this.routeBuckets.set(routeKey, bucketKey);
+        if (error.scope === "global") {
+            this.globalRateLimitUntil = nextAvailable;
+        }
+    }
+    updateBucketFromHeaders(routeKey, path, response) {
+        const bucketId = response.headers.get("X-RateLimit-Bucket");
+        const remainingRaw = response.headers.get("X-RateLimit-Remaining");
+        const resetAfterRaw = response.headers.get("X-RateLimit-Reset-After");
+        const hasInfo = !!bucketId || !!remainingRaw || !!resetAfterRaw;
+        if (!hasInfo)
             return;
-        const { method, path, data, query, resolve, reject } = queueItem;
-        try {
-            const result = await this.executeRequest({
-                method,
-                path,
-                data,
-                query,
-                resolve,
-                reject
-            });
-            resolve(result);
+        const key = bucketId
+            ? this.getBucketKey(routeKey, path, bucketId)
+            : this.getCurrentBucketKey(routeKey);
+        if (bucketId)
+            this.routeBuckets.set(routeKey, key);
+        const remaining = remainingRaw ? Number(remainingRaw) : undefined;
+        const resetAfter = resetAfterRaw ? Number(resetAfterRaw) * 1000 : undefined;
+        const now = Date.now();
+        const bucket = this.bucketStates.get(key) ?? {
+            delayUntil: 0,
+            extraBackoff: 0,
+            remaining: 1
+        };
+        if (typeof remaining === "number" && !Number.isNaN(remaining)) {
+            bucket.remaining = remaining;
         }
-        catch (error) {
-            if (error instanceof RateLimitError &&
-                this.options.queueRequests &&
-                error.scope === "global") {
-                this.queue.unshift(queueItem);
+        if (typeof resetAfter === "number" &&
+            !Number.isNaN(resetAfter) &&
+            bucket.remaining <= 0) {
+            bucket.delayUntil = now + resetAfter;
+        }
+        else if (bucket.remaining > 0) {
+            bucket.delayUntil = 0;
+        }
+        bucket.extraBackoff = 0;
+        this.bucketStates.set(key, bucket);
+    }
+    getCurrentBucketKey(routeKey) {
+        return this.routeBuckets.get(routeKey) ?? routeKey;
+    }
+    getBucketKey(routeKey, path, bucketId) {
+        if (!bucketId)
+            return routeKey;
+        const major = this.getMajorParameter(path);
+        return major ? `${bucketId}:${major}` : bucketId;
+    }
+    getMajorParameter(path) {
+        const segments = path.split("/");
+        for (let index = 0; index < segments.length; index += 1) {
+            const segment = segments[index];
+            const prev = segments[index - 1];
+            if (prev === "channels" || prev === "guilds") {
+                return segment;
             }
-            else {
-                if (error instanceof Error) {
-                    reject(error);
-                }
-                else {
-                    reject(new Error("Unknown error during request", { cause: error }));
-                }
+            if (prev === "webhooks") {
+                const webhookToken = segments[index + 1];
+                return webhookToken ? `${segment}/${webhookToken}` : segment;
             }
         }
-        finally {
-            this.abortController = null;
-            this.processQueue();
-        }
+        return null;
+    }
+    getRouteKey(method, path) {
+        const segments = path.split("/");
+        const normalized = segments
+            .map((segment, index) => {
+            if (!/^\d{16,}$/.test(segment))
+                return segment;
+            const prev = segments[index - 1];
+            if (prev && ["channels", "guilds"].includes(prev)) {
+                return segment;
+            }
+            if (prev === "webhooks") {
+                return segment;
+            }
+            if (segments[index - 2] === "webhooks") {
+                return segment;
+            }
+            return ":id";
+        })
+            .join("/");
+        return `${method}:${normalized}`;
+    }
+    clearQueue() {
+        this.scheduler.clear(new Error("Request queue cleared"));
+    }
+    get queueSize() {
+        return this.scheduler.size;
+    }
+    getSchedulerMetrics() {
+        const schedulerMetrics = this.scheduler.getMetrics();
+        return {
+            queueSize: this.queueSize,
+            activeWorkers: this.activeWorkers,
+            maxConcurrentWorkers: this.maxConcurrentWorkers,
+            ...schedulerMetrics,
+            globalRateLimitUntil: this.globalRateLimitUntil,
+            activeBuckets: this.activeBucketKeys.size
+        };
     }
     abortAllRequests() {
-        if (this.abortController) {
-            this.abortController.abort();
+        for (const controller of this.requestControllers) {
+            controller.abort();
         }
-        this.queue = [];
+        this.requestControllers.clear();
+        this.clearQueue();
     }
 }
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(ms, 0)));
 //# sourceMappingURL=RequestClient.js.map