@discordeno/rest 19.0.0-next.e70bfc3 → 19.0.0-next.e7d32e4

package/dist/cjs/index.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_exportStar(require("./typings/routes.cjs"), exports);
+_exportStar(require("./invalidBucket.cjs"), exports);
+_exportStar(require("./manager.cjs"), exports);
+_exportStar(require("./queue.cjs"), exports);
+_exportStar(require("./routes.cjs"), exports);
+_exportStar(require("./types.cjs"), exports);
+function _exportStar(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) Object.defineProperty(to, k, {
+            enumerable: true,
+            get: function() {
+                return from[k];
+            }
+        });
+    });
+    return from;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3R5cGluZ3Mvcm91dGVzLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9pbnZhbGlkQnVja2V0LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9tYW5hZ2VyLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9xdWV1ZS5qcydcbmV4cG9ydCAqIGZyb20gJy4vcm91dGVzLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcy5qcydcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O29CQUFjO29CQUNBO29CQUNBO29CQUNBO29CQUNBO29CQUNBIn0=

package/dist/cjs/invalidBucket.cjs

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createInvalidRequestBucket", {
+    enumerable: true,
+    get: ()=>createInvalidRequestBucket
+});
+const _utils = require("@discordeno/utils");
+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,
+        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){
+                _utils.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) {
+                    _utils.logger.warn(`[InvalidBucket] processing waiting queue is now paused until more requests are available. ${bucket.waiting.length} pending requests. ${JSON.stringify(bucket)}`);
+                    await (0, _utils.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;
+            _utils.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\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        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          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      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}\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\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":["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","logger","info","JSON","stringify","warn","delay","shift","handleCompletedRequest","code","sharedScope","includes"],"mappings":";;;;+BASgBA;;aAAAA;;uBATc;AASvB,SAASA,2BAA2BC,OAAoC,EAAwB;IACrG,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,KAAK;QAEjBC,SAAS,EAAE;QAEXC,iBAAiB,WAAY;YAC3B,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,CAAC;YAED,OAAOJ,OAAOG,GAAG,GAAGH,OAAOC,eAAe,GAAGD,OAAOQ,cAAc,GAAGR,OAAOM,MAAM;QACpF;QAEAU,kBAAkB,WAAY;YAC5B,OAAOhB,OAAOY,eAAe,KAAK;QACpC;QAEAK,2BAA2B,iBAAkB;YAC3C,qDAAqD;YACrD,OAAO,MAAM,IAAIC,QAAQ,OAAOC,UAAY;gBAC1C,2FAA2F;gBAC3F,IAAInB,OAAOgB,gBAAgB,IAAI;oBAC7BhB,OAAOQ,cAAc,IAAI;oBACzBW;gBACF,OAAO;oBACLnB,OAAOW,OAAO,CAACS,IAAI,CAACD;oBACpB,MAAMnB,OAAOqB,cAAc;gBAC7B,CAAC;YACH;QACF;QAEAA,gBAAgB,iBAAkB;YAChC,qEAAqE;YACrE,IAAIrB,OAAOU,UAAU,EAAE;YAEvB,gDAAgD;YAChDV,OAAOU,UAAU,GAAG,IAAI;YAExB,MAAOV,OAAOW,OAAO,CAACW,MAAM,GAAG,EAAG;gBAChCC,aAAM,CAACC,IAAI,CACT,CAAC,6DAA6D,EAAExB,OAAOW,OAAO,CAACW,MAAM,CAAC,8BAA8B,EAAEG,KAAKC,SAAS,CAClI1B,QACA,CAAC;gBAGL,IAAI,CAACA,OAAOgB,gBAAgB,MAAMhB,OAAOK,OAAO,KAAKQ,WAAW;oBAC9DU,aAAM,CAACI,IAAI,CACT,CAAC,0FAA0F,EACzF3B,OAAOW,OAAO,CAACW,MAAM,CACtB,mBAAmB,EAAEG,KAAKC,SAAS,CAAC1B,QAAQ,CAAC;oBAEhD,MAAM4B,IAAAA,YAAK,EAAC5B,OAAOK,OAAO,GAAGS,KAAKC,GAAG;gBACvC,CAAC;gBAEDf,OAAOQ,cAAc,IAAI;gBACzB,qCAAqC;gBACrCR,OAAOW,OAAO,CAACkB,KAAK;YACtB;YAEA,sEAAsE;YACtE7B,OAAOU,UAAU,GAAG,KAAK;QAC3B;QAEAoB,wBAAwB,SAAUC,IAAI,EAAEC,WAAW,EAAE;YACnD,+DAA+D;YAC/DhC,OAAOQ,cAAc,IAAI;YACzB,+DAA+D;YAC/D,IAAI,CAACR,OAAOO,aAAa,CAAC0B,QAAQ,CAACF,OAAO;YAC1C,yCAAyC;YACzC,IAAIA,SAAS,OAAOC,aAAa;YAEjC,2BAA2B;YAC3B,IAAIhC,OAAOK,OAAO,KAAKQ,WAAW;gBAChCb,OAAOK,OAAO,GAAGS,KAAKC,GAAG,KAAKf,OAAOI,QAAQ;YAC/C,CAAC;YAEDJ,OAAOC,eAAe,IAAI;YAC1BsB,aAAM,CAACI,IAAI,CAAC,CAAC,iFAAiF,EAAE3B,OAAOC,eAAe,CAAC,CAAC;QAC1H;IACF;IAEA,OAAOD;AACT"}