@discordeno/rest 19.0.0-next.40c19da → 19.0.0-next.4142946

package/README.md

@@ -1,6 +1,14 @@
 # Discordeno Rest
 
-A standalone and server-less REST module with functionality of REST, independently.
+<img align="right" src="https://raw.githubusercontent.com/discordeno/discordeno/main/website/static/img/logo.png" height="150px" />
+
+Discord API library for [Node.JS](https://nodejs.org), [Deno](https://deno.land) & [Bun](https://bun.sh/)
+
+[![Discord](https://img.shields.io/discord/785384884197392384?color=7289da&logo=discord&logoColor=dark)](https://discord.com/invite/5vBgXk3UcZ)
+[![codecov](https://codecov.io/gh/discordeno/discordeno/branch/main/graph/badge.svg?token=SQI9OYJ7AK)](https://codecov.io/gh/discordeno/discordeno)
+![action status](https://github.com/discordeno/discordeno/actions/workflows/lib-check.yml/badge.svg?event=push)
+
+A standalone REST module with functionality of REST, independently.
 
 - Easily host on any serverless infrastructure.
   - Easy to use and setup with Cloudflare Workers (FREE for 100K requests per day!)
@@ -14,3 +22,9 @@ A standalone and server-less REST module with functionality of REST, independent
   - Seamless updates! When you want to update and reboot the bot, you could potentially lose tons of messages or
     responses that are in queue. Using this you could restart your bot without ever worrying about losing any responses.
 - Scalability! Scalability! Scalability!
+
+## Links
+
+- [Website](https://discordeno.js.org/)
+- [Documentation](https://doc.deno.land/https/deno.land/x/discordeno/mod.ts)
+- [Discord](https://discord.com/invite/5vBgXk3UcZ)

package/dist/cjs/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./typings/routes.cjs"), exports);
+_export_star(require("./invalidBucket.cjs"), exports);
+_export_star(require("./manager.cjs"), exports);
+_export_star(require("./queue.cjs"), exports);
+_export_star(require("./routes.cjs"), exports);
+_export_star(require("./types.cjs"), exports);
+function _export_star(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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3R5cGluZ3Mvcm91dGVzLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9pbnZhbGlkQnVja2V0LmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9tYW5hZ2VyLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi9xdWV1ZS5qcydcbmV4cG9ydCAqIGZyb20gJy4vcm91dGVzLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcy5qcydcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O3FCQUFjO3FCQUNBO3FCQUNBO3FCQUNBO3FCQUNBO3FCQUNBIn0=

package/dist/cjs/invalidBucket.cjs

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createInvalidRequestBucket", {
+    enumerable: true,
+    get: function() {
+        return 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,
+        logger: options.logger ?? _utils.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() {
+            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 (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;
+            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      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":["createInvalidRequestBucket","options","bucket","invalidRequests","current","max","interval","resetAt","safety","errorStatuses","activeRequests","requested","processing","logger","waiting","requestsAllowed","undefined","Date","now","isRequestAllowed","waitUntilRequestAvailable","Promise","resolve","push","processWaiting","length","info","JSON","stringify","warn","delay","shift","handleCompletedRequest","code","sharedScope","includes"],"mappings":";;;;+BASgBA;;;eAAAA;;;uBATc;AASvB,SAASA,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;QACZC,QAAQZ,QAAQY,MAAM,IAAIA,aAAM;QAEhCC,SAAS,EAAE;QAEXC,iBAAiB;YACf,IAAIb,OAAOK,OAAO,KAAKS,aAAaC,KAAKC,GAAG,MAAMhB,OAAOK,OAAO,EAAE;gBAChEL,OAAOC,eAAe,GAAG;gBACzBD,OAAOK,OAAO,GAAGU,KAAKC,GAAG,KAAKhB,OAAOI,QAAQ;YAC/C;YAEA,OAAOJ,OAAOG,GAAG,GAAGH,OAAOC,eAAe,GAAGD,OAAOQ,cAAc,GAAGR,OAAOM,MAAM;QACpF;QAEAW,kBAAkB;YAChB,OAAOjB,OAAOa,eAAe,KAAK;QACpC;QAEAK,2BAA2B;YACzB,OAAO,MAAM,IAAIC,QAAQ,OAAOC;gBAC9B,2FAA2F;gBAC3F,IAAIpB,OAAOiB,gBAAgB,IAAI;oBAC7BjB,OAAOQ,cAAc,IAAI;oBACzBY;gBACF,OAAO;oBACLpB,OAAOY,OAAO,CAACS,IAAI,CAACD;oBACpB,MAAMpB,OAAOsB,cAAc;gBAC7B;YACF;QACF;QAEAA,gBAAgB;YACd,qEAAqE;YACrE,IAAItB,OAAOU,UAAU,EAAE;YAEvB,gDAAgD;YAChDV,OAAOU,UAAU,GAAG;YAEpB,MAAOV,OAAOY,OAAO,CAACW,MAAM,GAAG,EAAG;gBAChCvB,OAAOW,MAAM,CAACa,IAAI,CAChB,CAAC,6DAA6D,EAAExB,OAAOY,OAAO,CAACW,MAAM,CAAC,8BAA8B,EAAEE,KAAKC,SAAS,CAClI1B,QACA,CAAC;gBAGL,IAAI,CAACA,OAAOiB,gBAAgB,MAAMjB,OAAOK,OAAO,KAAKS,WAAW;oBAC9Dd,OAAOW,MAAM,CAACgB,IAAI,CAChB,CAAC,0FAA0F,EACzF3B,OAAOY,OAAO,CAACW,MAAM,CACtB,mBAAmB,EAAEE,KAAKC,SAAS,CAAC1B,QAAQ,CAAC;oBAEhD,MAAM4B,IAAAA,YAAK,EAAC5B,OAAOK,OAAO,GAAGU,KAAKC,GAAG;gBACvC;gBAEAhB,OAAOQ,cAAc,IAAI;gBACzB,qCAAqC;gBACrCR,OAAOY,OAAO,CAACiB,KAAK;YACtB;YAEA,sEAAsE;YACtE7B,OAAOU,UAAU,GAAG;QACtB;QAEAoB,wBAAwB,SAAUC,IAAI,EAAEC,WAAW;YACjD,+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,KAAKS,WAAW;gBAChCd,OAAOK,OAAO,GAAGU,KAAKC,GAAG,KAAKhB,OAAOI,QAAQ;YAC/C;YAEAJ,OAAOC,eAAe,IAAI;YAC1BD,OAAOW,MAAM,CAACgB,IAAI,CAAC,CAAC,iFAAiF,EAAE3B,OAAOC,eAAe,CAAC,CAAC;QACjI;IACF;IAEA,OAAOD;AACT"}