@discordeno/rest 19.0.0-next.fd8642b → 19.0.0-next.fda3003

package/dist/cjs/types.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/cjs/typings/routes.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+export * from './typings/routes.js';
+export * from './invalidBucket.js';
+export * from './manager.js';
+export * from './queue.js';
+export * from './routes.js';
+export * from './types.js';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3R5cGluZ3Mvcm91dGVzLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9pbnZhbGlkQnVja2V0LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9tYW5hZ2VyLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9xdWV1ZS5qcydcbmV4cG9ydCAqIGZyb20gJy4vcm91dGVzLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcy5qcydcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFxQjtBQUNuQyxjQUFjLHFCQUFvQjtBQUNsQyxjQUFjLGVBQWM7QUFDNUIsY0FBYyxhQUFZO0FBQzFCLGNBQWMsY0FBYTtBQUMzQixjQUFjLGFBQVkifQ==

package/dist/esm/invalidBucket.js

@@ -0,0 +1,83 @@
+import { delay, logger } from '@discordeno/utils';
+/**
+ * A invalid request bucket is used in a similar manner as a leaky bucket but a invalid request bucket can be refilled as needed.
+ * It's purpose is to make sure the bot does not hit the limit to getting a 1 hr ban.
+ *
+ * @param options The options used to configure this bucket.
+ * @returns RefillingBucket
+ */ export function createInvalidRequestBucket(options) {
+    const bucket = {
+        invalidRequests: options.current ?? 0,
+        max: options.max ?? 10000,
+        interval: options.interval ?? 600_000,
+        resetAt: options.resetAt,
+        safety: options.safety ?? 1,
+        errorStatuses: options.errorStatuses ?? [
+            401,
+            403,
+            429
+        ],
+        activeRequests: options.requested ?? 0,
+        processing: false,
+        logger: options.logger ?? logger,
+        waiting: [],
+        requestsAllowed: function() {
+            if (bucket.resetAt !== undefined && Date.now() >= bucket.resetAt) {
+                bucket.invalidRequests = 0;
+                bucket.resetAt = Date.now() + bucket.interval;
+            }
+            return bucket.max - bucket.invalidRequests - bucket.activeRequests - bucket.safety;
+        },
+        isRequestAllowed: function() {
+            return bucket.requestsAllowed() > 0;
+        },
+        waitUntilRequestAvailable: async function() {
+            // eslint-disable-next-line no-async-promise-executor
+            return await new Promise(async (resolve)=>{
+                // If whatever amount of requests is left is more than the safety margin, allow the request
+                if (bucket.isRequestAllowed()) {
+                    bucket.activeRequests += 1;
+                    resolve();
+                } else {
+                    bucket.waiting.push(resolve);
+                    await bucket.processWaiting();
+                }
+            });
+        },
+        processWaiting: async function() {
+            // If already processing, that loop will handle all waiting requests.
+            if (bucket.processing) return;
+            // Mark as processing so other loops don't start
+            bucket.processing = true;
+            while(bucket.waiting.length > 0){
+                bucket.logger.info(`[InvalidBucket] processing waiting queue while loop ran with ${bucket.waiting.length} pending requests to be made. ${JSON.stringify(bucket)}`);
+                if (!bucket.isRequestAllowed() && bucket.resetAt !== undefined) {
+                    bucket.logger.warn(`[InvalidBucket] processing waiting queue is now paused until more requests are available. ${bucket.waiting.length} pending requests. ${JSON.stringify(bucket)}`);
+                    await delay(bucket.resetAt - Date.now());
+                }
+                bucket.activeRequests += 1;
+                // Resolve the next item in the queue
+                bucket.waiting.shift()?.();
+            }
+            // Mark as false so next pending request can be triggered by new loop.
+            bucket.processing = false;
+        },
+        handleCompletedRequest: function(code, sharedScope) {
+            // Since request is complete, we can remove one from requested.
+            bucket.activeRequests -= 1;
+            // Since it is as a valid request, we don't need to do anything
+            if (!bucket.errorStatuses.includes(code)) return;
+            // Shared scope is not considered invalid
+            if (code === 429 && sharedScope) return;
+            // INVALID REQUEST WAS MADE
+            if (bucket.resetAt === undefined) {
+                bucket.resetAt = Date.now() + bucket.interval;
+            }
+            bucket.invalidRequests += 1;
+            bucket.logger.warn(`[InvalidBucket] an invalid request was made. Increasing invalidRequests count to ${bucket.invalidRequests}`);
+        }
+    };
+    return bucket;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/invalidBucket.ts"],"sourcesContent":["import { delay, logger } from '@discordeno/utils'\n\n/**\n * A invalid request bucket is used in a similar manner as a leaky bucket but a invalid request bucket can be refilled as needed.\n * It's purpose is to make sure the bot does not hit the limit to getting a 1 hr ban.\n *\n * @param options The options used to configure this bucket.\n * @returns RefillingBucket\n */\nexport function createInvalidRequestBucket(options: InvalidRequestBucketOptions): InvalidRequestBucket {\n  const bucket: InvalidRequestBucket = {\n    invalidRequests: options.current ?? 0,\n    max: options.max ?? 10000,\n    interval: options.interval ?? 600_000, // 10 minutes\n    resetAt: options.resetAt,\n    safety: options.safety ?? 1,\n    errorStatuses: options.errorStatuses ?? [401, 403, 429],\n    activeRequests: options.requested ?? 0,\n    processing: false,\n    logger: options.logger ?? logger,\n\n    waiting: [],\n\n    requestsAllowed: function () {\n      if (bucket.resetAt !== undefined && Date.now() >= bucket.resetAt) {\n        bucket.invalidRequests = 0\n        bucket.resetAt = Date.now() + bucket.interval\n      }\n\n      return bucket.max - bucket.invalidRequests - bucket.activeRequests - bucket.safety\n    },\n\n    isRequestAllowed: function () {\n      return bucket.requestsAllowed() > 0\n    },\n\n    waitUntilRequestAvailable: async function () {\n      // eslint-disable-next-line no-async-promise-executor\n      return await new Promise(async (resolve) => {\n        // If whatever amount of requests is left is more than the safety margin, allow the request\n        if (bucket.isRequestAllowed()) {\n          bucket.activeRequests += 1\n          resolve()\n        } else {\n          bucket.waiting.push(resolve)\n          await bucket.processWaiting()\n        }\n      })\n    },\n\n    processWaiting: async function () {\n      // If already processing, that loop will handle all waiting requests.\n      if (bucket.processing) return\n\n      // Mark as processing so other loops don't start\n      bucket.processing = true\n\n      while (bucket.waiting.length > 0) {\n        bucket.logger.info(\n          `[InvalidBucket] processing waiting queue while loop ran with ${bucket.waiting.length} pending requests to be made. ${JSON.stringify(\n            bucket,\n          )}`,\n        )\n\n        if (!bucket.isRequestAllowed() && bucket.resetAt !== undefined) {\n          bucket.logger.warn(\n            `[InvalidBucket] processing waiting queue is now paused until more requests are available. ${\n              bucket.waiting.length\n            } pending requests. ${JSON.stringify(bucket)}`,\n          )\n          await delay(bucket.resetAt - Date.now())\n        }\n\n        bucket.activeRequests += 1\n        // Resolve the next item in the queue\n        bucket.waiting.shift()?.()\n      }\n\n      // Mark as false so next pending request can be triggered by new loop.\n      bucket.processing = false\n    },\n\n    handleCompletedRequest: function (code, sharedScope) {\n      // Since request is complete, we can remove one from requested.\n      bucket.activeRequests -= 1\n      // Since it is as a valid request, we don't need to do anything\n      if (!bucket.errorStatuses.includes(code)) return\n      // Shared scope is not considered invalid\n      if (code === 429 && sharedScope) return\n\n      // INVALID REQUEST WAS MADE\n      if (bucket.resetAt === undefined) {\n        bucket.resetAt = Date.now() + bucket.interval\n      }\n\n      bucket.invalidRequests += 1\n      bucket.logger.warn(`[InvalidBucket] an invalid request was made. Increasing invalidRequests count to ${bucket.invalidRequests}`)\n    },\n  }\n\n  return bucket\n}\n\nexport interface InvalidRequestBucketOptions {\n  /** current invalid amount */\n  current?: number\n  /** max invalid requests allowed until ban. Defaults to 10,000 */\n  max?: number\n  /** The time that discord allows to make the max number of invalid requests. Defaults to 10 minutes */\n  interval?: number\n  /** When the timeout for the bucket has started at. */\n  resetAt?: number\n  /** how safe to be from max. Defaults to 1 */\n  safety?: number\n  /** The request statuses that count as an invalid request. */\n  errorStatuses?: number[]\n  /** The amount of requests that were requested from this bucket. */\n  requested?: number\n  /** The logger that will be used for the bucket */\n  logger?: Pick<typeof logger, 'debug' | 'info' | 'warn' | 'error' | 'fatal'>\n}\n\nexport interface InvalidRequestBucket {\n  /** current invalid amount */\n  invalidRequests: number\n  /** max invalid requests allowed until ban. Defaults to 10,000 */\n  max: number\n  /** The time that discord allows to make the max number of invalid requests. Defaults to 10 minutes */\n  interval: number\n  /** When the timeout for this bucket has started at. */\n  resetAt: number | undefined\n  /** how safe to be from max. Defaults to 1 */\n  safety: number\n  /** The request statuses that count as an invalid request. */\n  errorStatuses: number[]\n  /** The amount of requests that were requested from this bucket. */\n  activeRequests: number\n  /** The requests that are currently pending. */\n  waiting: Array<(value: void | PromiseLike<void>) => void>\n  /** Whether or not the waiting queue is already processing. */\n  processing: boolean\n  /** The logger that will be used for the bucket */\n  logger: Pick<typeof logger, 'debug' | 'info' | 'warn' | 'error' | 'fatal'>\n\n  /** Gives the number of requests that are currently allowed. */\n  requestsAllowed: () => number\n  /** Checks if a request is allowed at this time. */\n  isRequestAllowed: () => boolean\n  /** Waits until a request is available */\n  waitUntilRequestAvailable: () => Promise<void>\n  /** Begins processing the waiting queue of requests. */\n  processWaiting: () => Promise<void>\n  /** Handler for whenever a request is validated. This should update the requested values or trigger any other necessary stuff. */\n  handleCompletedRequest: (code: number, sharedScope: boolean) => void\n}\n"],"names":["delay","logger","createInvalidRequestBucket","options","bucket","invalidRequests","current","max","interval","resetAt","safety","errorStatuses","activeRequests","requested","processing","waiting","requestsAllowed","undefined","Date","now","isRequestAllowed","waitUntilRequestAvailable","Promise","resolve","push","processWaiting","length","info","JSON","stringify","warn","shift","handleCompletedRequest","code","sharedScope","includes"],"mappings":"AAAA,SAASA,KAAK,EAAEC,MAAM,QAAQ,oBAAmB;AAEjD;;;;;;CAMC,GACD,OAAO,SAASC,2BAA2BC,OAAoC;IAC7E,MAAMC,SAA+B;QACnCC,iBAAiBF,QAAQG,OAAO,IAAI;QACpCC,KAAKJ,QAAQI,GAAG,IAAI;QACpBC,UAAUL,QAAQK,QAAQ,IAAI;QAC9BC,SAASN,QAAQM,OAAO;QACxBC,QAAQP,QAAQO,MAAM,IAAI;QAC1BC,eAAeR,QAAQQ,aAAa,IAAI;YAAC;YAAK;YAAK;SAAI;QACvDC,gBAAgBT,QAAQU,SAAS,IAAI;QACrCC,YAAY;QACZb,QAAQE,QAAQF,MAAM,IAAIA;QAE1Bc,SAAS,EAAE;QAEXC,iBAAiB;YACf,IAAIZ,OAAOK,OAAO,KAAKQ,aAAaC,KAAKC,GAAG,MAAMf,OAAOK,OAAO,EAAE;gBAChEL,OAAOC,eAAe,GAAG;gBACzBD,OAAOK,OAAO,GAAGS,KAAKC,GAAG,KAAKf,OAAOI,QAAQ;YAC/C;YAEA,OAAOJ,OAAOG,GAAG,GAAGH,OAAOC,eAAe,GAAGD,OAAOQ,cAAc,GAAGR,OAAOM,MAAM;QACpF;QAEAU,kBAAkB;YAChB,OAAOhB,OAAOY,eAAe,KAAK;QACpC;QAEAK,2BAA2B;YACzB,qDAAqD;YACrD,OAAO,MAAM,IAAIC,QAAQ,OAAOC;gBAC9B,2FAA2F;gBAC3F,IAAInB,OAAOgB,gBAAgB,IAAI;oBAC7BhB,OAAOQ,cAAc,IAAI;oBACzBW;gBACF,OAAO;oBACLnB,OAAOW,OAAO,CAACS,IAAI,CAACD;oBACpB,MAAMnB,OAAOqB,cAAc;gBAC7B;YACF;QACF;QAEAA,gBAAgB;YACd,qEAAqE;YACrE,IAAIrB,OAAOU,UAAU,EAAE;YAEvB,gDAAgD;YAChDV,OAAOU,UAAU,GAAG;YAEpB,MAAOV,OAAOW,OAAO,CAACW,MAAM,GAAG,EAAG;gBAChCtB,OAAOH,MAAM,CAAC0B,IAAI,CAChB,CAAC,6DAA6D,EAAEvB,OAAOW,OAAO,CAACW,MAAM,CAAC,8BAA8B,EAAEE,KAAKC,SAAS,CAClIzB,QACA,CAAC;gBAGL,IAAI,CAACA,OAAOgB,gBAAgB,MAAMhB,OAAOK,OAAO,KAAKQ,WAAW;oBAC9Db,OAAOH,MAAM,CAAC6B,IAAI,CAChB,CAAC,0FAA0F,EACzF1B,OAAOW,OAAO,CAACW,MAAM,CACtB,mBAAmB,EAAEE,KAAKC,SAAS,CAACzB,QAAQ,CAAC;oBAEhD,MAAMJ,MAAMI,OAAOK,OAAO,GAAGS,KAAKC,GAAG;gBACvC;gBAEAf,OAAOQ,cAAc,IAAI;gBACzB,qCAAqC;gBACrCR,OAAOW,OAAO,CAACgB,KAAK;YACtB;YAEA,sEAAsE;YACtE3B,OAAOU,UAAU,GAAG;QACtB;QAEAkB,wBAAwB,SAAUC,IAAI,EAAEC,WAAW;YACjD,+DAA+D;YAC/D9B,OAAOQ,cAAc,IAAI;YACzB,+DAA+D;YAC/D,IAAI,CAACR,OAAOO,aAAa,CAACwB,QAAQ,CAACF,OAAO;YAC1C,yCAAyC;YACzC,IAAIA,SAAS,OAAOC,aAAa;YAEjC,2BAA2B;YAC3B,IAAI9B,OAAOK,OAAO,KAAKQ,WAAW;gBAChCb,OAAOK,OAAO,GAAGS,KAAKC,GAAG,KAAKf,OAAOI,QAAQ;YAC/C;YAEAJ,OAAOC,eAAe,IAAI;YAC1BD,OAAOH,MAAM,CAAC6B,IAAI,CAAC,CAAC,iFAAiF,EAAE1B,OAAOC,eAAe,CAAC,CAAC;QACjI;IACF;IAEA,OAAOD;AACT"}