@discordjs/rest 1.7.0-dev.1679918672-b8b852e.0 → 1.7.0

package/dist/index.mjs

@@ -8,7 +8,8 @@ import { URL } from "node:url";
 import process from "node:process";
 import { APIVersion } from "discord-api-types/v10";
 import { Agent } from "undici";
-var DefaultUserAgent = `DiscordBot (https://discord.js.org, 1.7.0-dev.1679918672-b8b852e.0)`;
+var DefaultUserAgent = `DiscordBot (https://discord.js.org, 1.7.0)`;
+var DefaultUserAgentAppendix = process.release?.name === "node" ? `Node.js/${process.version}` : "";
 var DefaultRestOptions = {
   get agent() {
     return new Agent({
@@ -27,7 +28,7 @@ var DefaultRestOptions = {
   rejectOnRateLimit: null,
   retries: 3,
   timeout: 15e3,
-  userAgentAppendix: `Node.js ${process.version}`,
+  userAgentAppendix: DefaultUserAgentAppendix,
   version: APIVersion,
   hashSweepInterval: 144e5,
   // 4 Hours
@@ -52,6 +53,7 @@ var OverwrittenMimeTypes = {
   // https://github.com/discordjs/discord.js/issues/8557
   "image/apng": "image/png"
 };
+var BurstHandlerMajorIdKey = "burst";
 
 // src/lib/CDN.ts
 var CDN = class {
@@ -387,11 +389,8 @@ import { lazy } from "@discordjs/util";
 import { DiscordSnowflake } from "@sapphire/snowflake";
 import { FormData as FormData2 } from "undici";
 
-// src/lib/handlers/SequentialHandler.ts
-import { setTimeout, clearTimeout } from "node:timers";
+// src/lib/handlers/BurstHandler.ts
 import { setTimeout as sleep } from "node:timers/promises";
-import { AsyncQueue } from "@sapphire/async-queue";
-import { request } from "undici";
 
 // src/lib/utils/utils.ts
 import { Blob, Buffer as Buffer2 } from "node:buffer";
@@ -502,10 +501,199 @@ function shouldRetry(error) {
   return "code" in error && error.code === "ECONNRESET" || error.message.includes("ECONNRESET");
 }
 __name(shouldRetry, "shouldRetry");
+async function onRateLimit(manager, rateLimitData) {
+  const { options } = manager;
+  if (!options.rejectOnRateLimit)
+    return;
+  const shouldThrow = typeof options.rejectOnRateLimit === "function" ? await options.rejectOnRateLimit(rateLimitData) : options.rejectOnRateLimit.some((route) => rateLimitData.route.startsWith(route.toLowerCase()));
+  if (shouldThrow) {
+    throw new RateLimitError(rateLimitData);
+  }
+}
+__name(onRateLimit, "onRateLimit");
 
-// src/lib/handlers/SequentialHandler.ts
+// src/lib/handlers/Shared.ts
+import { setTimeout, clearTimeout } from "node:timers";
+import { request } from "undici";
 var invalidCount = 0;
 var invalidCountResetTime = null;
+function incrementInvalidCount(manager) {
+  if (!invalidCountResetTime || invalidCountResetTime < Date.now()) {
+    invalidCountResetTime = Date.now() + 1e3 * 60 * 10;
+    invalidCount = 0;
+  }
+  invalidCount++;
+  const emitInvalid = manager.options.invalidRequestWarningInterval > 0 && invalidCount % manager.options.invalidRequestWarningInterval === 0;
+  if (emitInvalid) {
+    manager.emit("invalidRequestWarning" /* InvalidRequestWarning */, {
+      count: invalidCount,
+      remainingTime: invalidCountResetTime - Date.now()
+    });
+  }
+}
+__name(incrementInvalidCount, "incrementInvalidCount");
+async function makeNetworkRequest(manager, routeId, url, options, requestData, retries) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), manager.options.timeout).unref();
+  if (requestData.signal) {
+    const signal = requestData.signal;
+    if (signal.aborted)
+      controller.abort();
+    else
+      signal.addEventListener("abort", () => controller.abort());
+  }
+  let res;
+  try {
+    res = await request(url, { ...options, signal: controller.signal });
+  } catch (error) {
+    if (!(error instanceof Error))
+      throw error;
+    if (shouldRetry(error) && retries !== manager.options.retries) {
+      return null;
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+  if (manager.listenerCount("response" /* Response */)) {
+    manager.emit(
+      "response" /* Response */,
+      {
+        method: options.method ?? "get",
+        path: routeId.original,
+        route: routeId.bucketRoute,
+        options,
+        data: requestData,
+        retries
+      },
+      { ...res }
+    );
+  }
+  return res;
+}
+__name(makeNetworkRequest, "makeNetworkRequest");
+async function handleErrors(manager, res, method, url, requestData, retries) {
+  const status = res.statusCode;
+  if (status >= 500 && status < 600) {
+    if (retries !== manager.options.retries) {
+      return null;
+    }
+    throw new HTTPError(status, method, url, requestData);
+  } else {
+    if (status >= 400 && status < 500) {
+      if (status === 401 && requestData.auth) {
+        manager.setToken(null);
+      }
+      const data = await parseResponse(res);
+      throw new DiscordAPIError(data, "code" in data ? data.code : data.error, status, method, url, requestData);
+    }
+    return res;
+  }
+}
+__name(handleErrors, "handleErrors");
+
+// src/lib/handlers/BurstHandler.ts
+var BurstHandler = class {
+  /**
+   * @param manager - The request manager
+   * @param hash - The hash that this RequestHandler handles
+   * @param majorParameter - The major parameter for this handler
+   */
+  constructor(manager, hash, majorParameter) {
+    this.manager = manager;
+    this.hash = hash;
+    this.majorParameter = majorParameter;
+    this.id = `${hash}:${majorParameter}`;
+  }
+  /**
+   * {@inheritdoc IHandler.id}
+   */
+  id;
+  /**
+   * {@inheritDoc IHandler.inactive}
+   */
+  inactive = false;
+  /**
+   * Emits a debug message
+   *
+   * @param message - The message to debug
+   */
+  debug(message) {
+    this.manager.emit("restDebug" /* Debug */, `[REST ${this.id}] ${message}`);
+  }
+  /**
+   * {@inheritDoc IHandler.queueRequest}
+   */
+  async queueRequest(routeId, url, options, requestData) {
+    return this.runRequest(routeId, url, options, requestData);
+  }
+  /**
+   * The method that actually makes the request to the API, and updates info about the bucket accordingly
+   *
+   * @param routeId - The generalized API route with literal ids for major parameters
+   * @param url - The fully resolved URL to make the request to
+   * @param options - The fetch options needed to make the request
+   * @param requestData - Extra data from the user's request needed for errors and additional processing
+   * @param retries - The number of retries this request has already attempted (recursion)
+   */
+  async runRequest(routeId, url, options, requestData, retries = 0) {
+    const method = options.method ?? "get";
+    const res = await makeNetworkRequest(this.manager, routeId, url, options, requestData, retries);
+    if (res === null) {
+      return this.runRequest(routeId, url, options, requestData, ++retries);
+    }
+    const status = res.statusCode;
+    let retryAfter = 0;
+    const retry = parseHeader(res.headers["retry-after"]);
+    if (retry)
+      retryAfter = Number(retry) * 1e3 + this.manager.options.offset;
+    if (status === 401 || status === 403 || status === 429) {
+      incrementInvalidCount(this.manager);
+    }
+    if (status >= 200 && status < 300) {
+      return res;
+    } else if (status === 429) {
+      const isGlobal = res.headers["x-ratelimit-global"] !== void 0;
+      await onRateLimit(this.manager, {
+        timeToReset: retryAfter,
+        limit: Number.POSITIVE_INFINITY,
+        method,
+        hash: this.hash,
+        url,
+        route: routeId.bucketRoute,
+        majorParameter: this.majorParameter,
+        global: isGlobal
+      });
+      this.debug(
+        [
+          "Encountered unexpected 429 rate limit",
+          `  Global         : ${isGlobal}`,
+          `  Method         : ${method}`,
+          `  URL            : ${url}`,
+          `  Bucket         : ${routeId.bucketRoute}`,
+          `  Major parameter: ${routeId.majorParameter}`,
+          `  Hash           : ${this.hash}`,
+          `  Limit          : ${Number.POSITIVE_INFINITY}`,
+          `  Retry After    : ${retryAfter}ms`,
+          `  Sublimit       : None`
+        ].join("\n")
+      );
+      await sleep(retryAfter);
+      return this.runRequest(routeId, url, options, requestData, retries);
+    } else {
+      const handled = await handleErrors(this.manager, res, method, url, requestData, retries);
+      if (handled === null) {
+        return this.runRequest(routeId, url, options, requestData, ++retries);
+      }
+      return handled;
+    }
+  }
+};
+__name(BurstHandler, "BurstHandler");
+
+// src/lib/handlers/SequentialHandler.ts
+import { setTimeout as sleep2 } from "node:timers/promises";
+import { AsyncQueue } from "@sapphire/async-queue";
 var SequentialHandler = class {
   /**
    * @param manager - The request manager
@@ -594,21 +782,9 @@ var SequentialHandler = class {
    * @param time - The amount of time to delay all requests for
    */
   async globalDelayFor(time) {
-    await sleep(time);
+    await sleep2(time);
     this.manager.globalDelay = null;
   }
-  /*
-   * Determines whether the request should be queued or whether a RateLimitError should be thrown
-   */
-  async onRateLimit(rateLimitData) {
-    const { options } = this.manager;
-    if (!options.rejectOnRateLimit)
-      return;
-    const shouldThrow = typeof options.rejectOnRateLimit === "function" ? await options.rejectOnRateLimit(rateLimitData) : options.rejectOnRateLimit.some((route) => rateLimitData.route.startsWith(route.toLowerCase()));
-    if (shouldThrow) {
-      throw new RateLimitError(rateLimitData);
-    }
-  }
   /**
    * {@inheritDoc IHandler.queueRequest}
    */
@@ -657,22 +833,22 @@ var SequentialHandler = class {
     while (this.limited) {
       const isGlobal = this.globalLimited;
       let limit2;
-      let timeout2;
+      let timeout;
       let delay;
       if (isGlobal) {
         limit2 = this.manager.options.globalRequestsPerSecond;
-        timeout2 = this.manager.globalReset + this.manager.options.offset - Date.now();
+        timeout = this.manager.globalReset + this.manager.options.offset - Date.now();
         if (!this.manager.globalDelay) {
-          this.manager.globalDelay = this.globalDelayFor(timeout2);
+          this.manager.globalDelay = this.globalDelayFor(timeout);
         }
         delay = this.manager.globalDelay;
       } else {
         limit2 = this.limit;
-        timeout2 = this.timeToReset;
-        delay = sleep(timeout2);
+        timeout = this.timeToReset;
+        delay = sleep2(timeout);
       }
       const rateLimitData = {
-        timeToReset: timeout2,
+        timeToReset: timeout,
         limit: limit2,
         method: options.method ?? "get",
         hash: this.hash,
@@ -682,11 +858,11 @@ var SequentialHandler = class {
         global: isGlobal
       };
       this.manager.emit("rateLimited" /* RateLimited */, rateLimitData);
-      await this.onRateLimit(rateLimitData);
+      await onRateLimit(this.manager, rateLimitData);
       if (isGlobal) {
-        this.debug(`Global rate limit hit, blocking all requests for ${timeout2}ms`);
+        this.debug(`Global rate limit hit, blocking all requests for ${timeout}ms`);
       } else {
-        this.debug(`Waiting ${timeout2}ms for rate limit to pass`);
+        this.debug(`Waiting ${timeout}ms for rate limit to pass`);
       }
       await delay;
     }
@@ -696,41 +872,9 @@ var SequentialHandler = class {
     }
     this.manager.globalRemaining--;
     const method = options.method ?? "get";
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.manager.options.timeout).unref();
-    if (requestData.signal) {
-      const signal = requestData.signal;
-      if (signal.aborted)
-        controller.abort();
-      else
-        signal.addEventListener("abort", () => controller.abort());
-    }
-    let res;
-    try {
-      res = await request(url, { ...options, signal: controller.signal });
-    } catch (error) {
-      if (!(error instanceof Error))
-        throw error;
-      if (shouldRetry(error) && retries !== this.manager.options.retries) {
-        return await this.runRequest(routeId, url, options, requestData, ++retries);
-      }
-      throw error;
-    } finally {
-      clearTimeout(timeout);
-    }
-    if (this.manager.listenerCount("response" /* Response */)) {
-      this.manager.emit(
-        "response" /* Response */,
-        {
-          method,
-          path: routeId.original,
-          route: routeId.bucketRoute,
-          options,
-          data: requestData,
-          retries
-        },
-        { ...res }
-      );
+    const res = await makeNetworkRequest(this.manager, routeId, url, options, requestData, retries);
+    if (res === null) {
+      return this.runRequest(routeId, url, options, requestData, ++retries);
     }
     const status = res.statusCode;
     let retryAfter = 0;
@@ -763,34 +907,23 @@ var SequentialHandler = class {
       }
     }
     if (status === 401 || status === 403 || status === 429) {
-      if (!invalidCountResetTime || invalidCountResetTime < Date.now()) {
-        invalidCountResetTime = Date.now() + 1e3 * 60 * 10;
-        invalidCount = 0;
-      }
-      invalidCount++;
-      const emitInvalid = this.manager.options.invalidRequestWarningInterval > 0 && invalidCount % this.manager.options.invalidRequestWarningInterval === 0;
-      if (emitInvalid) {
-        this.manager.emit("invalidRequestWarning" /* InvalidRequestWarning */, {
-          count: invalidCount,
-          remainingTime: invalidCountResetTime - Date.now()
-        });
-      }
+      incrementInvalidCount(this.manager);
     }
     if (status >= 200 && status < 300) {
       return res;
     } else if (status === 429) {
       const isGlobal = this.globalLimited;
       let limit2;
-      let timeout2;
+      let timeout;
       if (isGlobal) {
         limit2 = this.manager.options.globalRequestsPerSecond;
-        timeout2 = this.manager.globalReset + this.manager.options.offset - Date.now();
+        timeout = this.manager.globalReset + this.manager.options.offset - Date.now();
       } else {
         limit2 = this.limit;
-        timeout2 = this.timeToReset;
+        timeout = this.timeToReset;
       }
-      await this.onRateLimit({
-        timeToReset: timeout2,
+      await onRateLimit(this.manager, {
+        timeToReset: timeout,
         limit: limit2,
         method,
         hash: this.hash,
@@ -822,7 +955,7 @@ var SequentialHandler = class {
         }
         this.#sublimitPromise?.resolve();
         this.#sublimitPromise = null;
-        await sleep(sublimitTimeout);
+        await sleep2(sublimitTimeout);
         let resolve;
         const promise = new Promise((res2) => resolve = res2);
         this.#sublimitPromise = { promise, resolve };
@@ -832,20 +965,12 @@ var SequentialHandler = class {
         }
       }
       return this.runRequest(routeId, url, options, requestData, retries);
-    } else if (status >= 500 && status < 600) {
-      if (retries !== this.manager.options.retries) {
-        return this.runRequest(routeId, url, options, requestData, ++retries);
-      }
-      throw new HTTPError(status, method, url, requestData);
     } else {
-      if (status >= 400 && status < 500) {
-        if (status === 401 && requestData.auth) {
-          this.manager.setToken(null);
-        }
-        const data = await parseResponse(res);
-        throw new DiscordAPIError(data, "code" in data ? data.code : data.error, status, method, url, requestData);
+      const handled = await handleErrors(this.manager, res, method, url, requestData, retries);
+      if (handled === null) {
+        return this.runRequest(routeId, url, options, requestData, ++retries);
       }
-      return res;
+      return handled;
     }
   }
 };
@@ -986,7 +1111,7 @@ var RequestManager = class extends EventEmitter {
    * @internal
    */
   createHandler(hash, majorParameter) {
-    const queue = new SequentialHandler(this, hash, majorParameter);
+    const queue = majorParameter === BurstHandlerMajorIdKey ? new BurstHandler(this, hash, majorParameter) : new SequentialHandler(this, hash, majorParameter);
     this.handlers.set(queue.id, queue);
     return queue;
   }
@@ -1087,6 +1212,13 @@ var RequestManager = class extends EventEmitter {
    * @internal
    */
   static generateRouteData(endpoint, method) {
+    if (endpoint.startsWith("/interactions/") && endpoint.endsWith("/callback")) {
+      return {
+        majorParameter: BurstHandlerMajorIdKey,
+        bucketRoute: "/interactions/:id/:token/callback",
+        original: endpoint
+      };
+    }
     const majorIdMatch = /^\/(?:channels|guilds|webhooks)\/(\d{17,19})/.exec(endpoint);
     const majorId = majorIdMatch?.[1] ?? "global";
     const baseRoute = endpoint.replaceAll(/\d{17,19}/g, ":id").replace(/\/reactions\/(.*)/, "/reactions/:reaction");
@@ -1215,14 +1347,16 @@ var REST = class extends EventEmitter2 {
 __name(REST, "REST");
 
 // src/index.ts
-var version = "1.7.0-dev.1679918672-b8b852e.0";
+var version = "1.7.0";
 export {
   ALLOWED_EXTENSIONS,
   ALLOWED_SIZES,
   ALLOWED_STICKER_EXTENSIONS,
+  BurstHandlerMajorIdKey,
   CDN,
   DefaultRestOptions,
   DefaultUserAgent,
+  DefaultUserAgentAppendix,
   DiscordAPIError,
   HTTPError,
   OverwrittenMimeTypes,