elynn-baileys 1.0.1

package/lib/Discord/rest/RequestHandler.js

@@ -0,0 +1,323 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module RequestHandler */
+const SequentialBucket_1 = __importDefault(require("./SequentialBucket"));
+const DiscordRESTError_1 = __importDefault(require("./DiscordRESTError"));
+const DiscordHTTPError_1 = __importDefault(require("./DiscordHTTPError"));
+const Constants_1 = require("../Constants");
+const Base_1 = __importDefault(require("../structures/Base"));
+const Errors_1 = require("../util/Errors");
+/**
+ * Latency & ratelimit related things lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/rest/RequestHandler.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+/** The primary means of communicating with Discord via rest. */
+class RequestHandler {
+    _manager;
+    globalBlock = false;
+    latencyRef;
+    options;
+    ratelimits = {};
+    readyQueue = [];
+    constructor(manager, options = {}) {
+        if (options && options.baseURL && options.baseURL.endsWith("/")) {
+            options.baseURL = options.baseURL.slice(0, -1);
+        }
+        this._manager = manager;
+        this.options = {
+            agent: options.agent,
+            baseURL: options.baseURL ?? Constants_1.API_URL,
+            disableLatencyCompensation: !!options.disableLatencyCompensation,
+            followRedirects: !!options.followRedirects,
+            host: options.host ?? (options.baseURL ? new URL(options.baseURL).host : new URL(Constants_1.API_URL).host),
+            latencyThreshold: options.latencyThreshold ?? 30000,
+            maxRatelimitRetryWindow: options.maxRatelimitRetryWindow ?? 30000,
+            ratelimiterOffset: options.ratelimiterOffset ?? 0,
+            requestTimeout: options.requestTimeout ?? 15000,
+            superProperties: options.superProperties ?? null,
+            userAgent: options.userAgent ?? Constants_1.USER_AGENT
+        };
+        this.latencyRef = {
+            lastTimeOffsetCheck: 0,
+            latency: options.ratelimiterOffset ?? 0,
+            raw: Array.from({ length: 10 }).fill(options.ratelimiterOffset ?? 0),
+            timeOffsets: Array.from({ length: 10 }).fill(0),
+            timeoffset: 0
+        };
+    }
+    getRoute(path, method) {
+        let route = path.replaceAll(/\/([a-z-]+)\/\d{15,21}/g, function (match, p) {
+            return p === "channels" || p === "guilds" || p === "webhooks" ? match : `/${p}/:id`;
+        }).replaceAll(/\/reactions\/[^/]+/g, "/reactions/:id").replaceAll(/\/reactions\/:id\/[^/]+/g, "/reactions/:id/:userID").replace(/^\/webhooks\/(\d+)\/[\w-]{64,}/, "/webhooks/$1/:token");
+        if (method === "DELETE" && route.endsWith("/messages/:id")) {
+            const messageID = path.slice(path.lastIndexOf("/") + 1);
+            const createdAt = Base_1.default.getCreatedAt(messageID).getTime();
+            if (Date.now() - this.latencyRef.latency - createdAt >= 1000 * 60 * 60 * 24 * 14) {
+                method += "_OLD";
+            }
+            else if (Date.now() - this.latencyRef.latency - createdAt <= 1000 * 10) {
+                method += "_NEW";
+            }
+            route = method + route;
+        }
+        else if (method === "GET" && /\/guilds\/\d+\/channels$/.test(route)) {
+            route = "/guilds/:id/channels";
+        }
+        if (method === "PUT" || method === "DELETE") {
+            const index = route.indexOf("/reactions");
+            if (index !== -1) {
+                route = "MODIFY" + route.slice(0, index + 10);
+            }
+        }
+        return route;
+    }
+    globalUnblock() {
+        this.globalBlock = false;
+        while (this.readyQueue.length !== 0) {
+            this.readyQueue.shift()();
+        }
+    }
+    /** same as `request`, but with `auth` always set to `true`. */
+    async authRequest(options) {
+        return this.request({
+            ...options,
+            auth: true
+        });
+    }
+    /**
+     * Make a request. `null` will be returned if the request results in a `204 NO CONTENT`.
+     * @param options The options for the request.
+     */
+    async request(options) {
+        options.method = options.method.toUpperCase();
+        if (!Constants_1.RESTMethods.includes(options.method)) {
+            throw new TypeError(`Invalid method "${options.method}.`);
+        }
+        const _stackHolder = {};
+        Error.captureStackTrace(_stackHolder);
+        if (!options.path.startsWith("/")) {
+            options.path = `/${options.path}`;
+        }
+        const route = options.route ?? this.getRoute(options.path, options.method);
+        if (!this.ratelimits[route]) {
+            this.ratelimits[route] = new SequentialBucket_1.default(1, this.latencyRef);
+        }
+        let attempts = 0;
+        return new Promise((resolve, reject) => {
+            async function attempt(cb) {
+                const headers = options.headers ?? {};
+                try {
+                    if (typeof options.auth === "string") {
+                        headers.Authorization = options.auth;
+                    }
+                    else if (options.auth && this._manager.client.options.auth) {
+                        headers.Authorization = this._manager.client.options.auth;
+                    }
+                    if (options.reason) {
+                        headers["X-Audit-Log-Reason"] = encodeURIComponent(options.reason);
+                    }
+                    let reqBody;
+                    if (options.method !== "GET") {
+                        let stringBody;
+                        if (options.json) {
+                            stringBody = JSON.stringify(options.json, (k, v) => typeof v === "bigint" ? v.toString() : v);
+                        }
+                        if (options.form || (options.files && options.files.length !== 0)) {
+                            const data = options.form ?? new FormData();
+                            let index = 0;
+                            if (options.files)
+                                for (const file of options.files.values()) {
+                                    index++;
+                                    if (file.index !== undefined) {
+                                        index = file.index;
+                                    }
+                                    if (!file.contents) {
+                                        continue;
+                                    }
+                                    data.set(file.field || `files[${index}]`, new Blob([file.contents]), file.name);
+                                }
+                            if (stringBody) {
+                                data.set("payload_json", stringBody);
+                            }
+                            reqBody = data;
+                        }
+                        else if (options.json) {
+                            reqBody = stringBody;
+                            headers["Content-Type"] = "application/json";
+                        }
+                    }
+                    if (this.options.host) {
+                        headers.Host = this.options.host;
+                    }
+                    if (this.options.superProperties) {
+                        headers["X-Super-Properties"] = typeof this.options.superProperties === "object" ? JSON.stringify(this.options.superProperties) : this.options.superProperties;
+                    }
+                    const url = `${this.options.baseURL}${options.path}${options.query && Array.from(options.query.keys()).length !== 0 ? `?${options.query.toString()}` : ""}`;
+                    let latency = Date.now();
+                    const controller = new AbortController();
+                    let timeout;
+                    if (this.options.requestTimeout > 0 && this.options.requestTimeout !== Infinity) {
+                        timeout = setTimeout(() => controller.abort(), this.options.requestTimeout);
+                    }
+                    const res = await fetch(url, {
+                        method: options.method,
+                        headers,
+                        body: reqBody,
+                        dispatcher: this.options.agent || undefined,
+                        signal: controller.signal,
+                        redirect: this.options.followRedirects ? "follow" : "manual"
+                    });
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    latency = Date.now() - latency;
+                    if (!this.options.disableLatencyCompensation) {
+                        this.latencyRef.raw.push(latency);
+                        this.latencyRef.latency = this.latencyRef.latency - Math.trunc((this.latencyRef.raw.shift() ?? 0) / 10) + Math.trunc(latency / 10);
+                    }
+                    let resBody;
+                    if (res.status === 204) {
+                        resBody = null;
+                    }
+                    else {
+                        if (res.headers.get("content-type") === "application/json") {
+                            const b = await res.text();
+                            try {
+                                resBody = JSON.parse(b);
+                            }
+                            catch (err) {
+                                this._manager.client.emit("error", err);
+                                resBody = b;
+                            }
+                        }
+                        else {
+                            resBody = Buffer.from(await res.arrayBuffer());
+                        }
+                    }
+                    this._manager.client.emit("request", {
+                        method: options.method,
+                        path: options.path,
+                        route,
+                        withAuth: !!options.auth,
+                        requestBody: reqBody,
+                        responseBody: resBody
+                    });
+                    const headerNow = Date.parse(res.headers.get("date"));
+                    const now = Date.now();
+                    if (this.latencyRef.lastTimeOffsetCheck < (Date.now() - 5000)) {
+                        const timeOffset = headerNow + 500 - (this.latencyRef.lastTimeOffsetCheck = Date.now());
+                        if (this.latencyRef.timeoffset - this.latencyRef.latency >= this.options.latencyThreshold && timeOffset - this.latencyRef.latency >= this.options.latencyThreshold) {
+                            this._manager.client.emit("warn", `Your clock is ${this.latencyRef.timeoffset}ms behind Discord's server clock. Please check your connection and system time.`);
+                        }
+                        this.latencyRef.timeoffset = this.latencyRef.timeoffset - Math.trunc(this.latencyRef.timeOffsets.shift() / 10) + Math.trunc(timeOffset / 10);
+                        this.latencyRef.timeOffsets.push(timeOffset);
+                    }
+                    if (res.headers.has("x-ratelimit-limit")) {
+                        this.ratelimits[route].limit = Number(res.headers.get("x-ratelimit-limit"));
+                    }
+                    if (options.method !== "GET" && (!res.headers.has("x-ratelimit-remaining") || !res.headers.has("x-ratelimit-limit")) && this.ratelimits[route].limit !== 1) {
+                        this._manager.client.emit("debug", [`Missing ratelimit headers for SequentialBucket(${this.ratelimits[route].remaining}/${this.ratelimits[route].limit}) with non-default limit\n`,
+                            `${res.status} ${res.headers.get("content-type") ?? "null"}: ${options.method} ${route} | ${res.headers.get("cf-ray") ?? "null"}\n`,
+                            `content-type = ${res.headers.get("content-type") ?? "null"}\n`,
+                            `x-ratelimit-remaining = ${res.headers.get("x-ratelimit-remaining") ?? "null"}\n`,
+                            `x-ratelimit-limit = ${res.headers.get("x-ratelimit-limit") ?? "null"}\n`,
+                            `x-ratelimit-reset = ${res.headers.get("x-ratelimit-reset") ?? "null"}\n`,
+                            `x-ratelimit-global = ${res.headers.get("x-ratelimit-global") ?? "null"}`].join("\n"));
+                    }
+                    this.ratelimits[route].remaining = res.headers.has("x-ratelimit-remaining") ? Number(res.headers.get("x-ratelimit-remaining")) ?? 0 : 1;
+                    const retryAfter = Number(res.headers.get("x-ratelimit-reset-after") ?? res.headers.get("retry-after") ?? 0) * 1000;
+                    if (retryAfter >= 0) {
+                        if (res.headers.has("x-ratelimit-global")) {
+                            this.globalBlock = true;
+                            setTimeout(this.globalUnblock.bind(this), retryAfter ?? 1);
+                        }
+                        else {
+                            this.ratelimits[route].reset = (retryAfter ?? 1) + now;
+                        }
+                    }
+                    else if (res.headers.has("x-ratelimit-reset")) {
+                        let resetTime = Number(res.headers.get("x-ratelimit-reset")) * 1000;
+                        if (route.endsWith("/reactions/:id") && (resetTime - headerNow) === 1000) {
+                            resetTime = now + 250;
+                        }
+                        this.ratelimits[route].reset = Math.max(resetTime - this.latencyRef.latency, now);
+                    }
+                    else {
+                        this.ratelimits[route].reset = now;
+                    }
+                    if (res.status !== 429) {
+                        this._manager.client.emit("debug", `${now} ${route} ${res.status}: ${latency}ms (${this.latencyRef.latency}ms avg) | ${this.ratelimits[route].remaining}/${this.ratelimits[route].limit} left | Reset ${this.ratelimits[route].reset} (${this.ratelimits[route].reset - now}ms left)`);
+                    }
+                    if (res.status > 300) {
+                        if (res.status === 429) {
+                            let delay = retryAfter;
+                            if (res.headers.get("x-ratelimit-scope") === "shared") {
+                                try {
+                                    delay = resBody.retry_after * 1000;
+                                }
+                                catch (err) {
+                                    cb();
+                                    reject(err);
+                                }
+                            }
+                            this._manager.client.emit("debug", `${res.headers.has("x-ratelimit-global") ? "Global" : "Unexpected"} RateLimit: ${JSON.stringify(resBody)}\n${now} ${route} ${res.status}: ${latency}ms (${this.latencyRef.latency}ms avg) | ${this.ratelimits[route].remaining}/${this.ratelimits[route].limit} left | Reset ${delay} (${this.ratelimits[route].reset - now}ms left) | Scope ${res.headers.get("x-ratelimit-scope")}`);
+                            if (delay) {
+                                if (delay > this.options.maxRatelimitRetryWindow) {
+                                    cb();
+                                    return reject(new Errors_1.RateLimitedError(`Ratelimit on "${options.method} ${route}" exceeds the maximum retry window (${delay} > ${this.options.maxRatelimitRetryWindow})`, delay));
+                                }
+                                setTimeout(() => {
+                                    cb();
+                                    // eslint-disable-next-line prefer-rest-params, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, prefer-spread
+                                    this.request(options).then(resolve).catch(reject);
+                                }, delay);
+                                return;
+                            }
+                            else {
+                                cb();
+                                this.request(options).then(resolve).catch(reject);
+                                return;
+                            }
+                        }
+                        else if (res.status === 502 && ++attempts < 4) {
+                            this._manager.client.emit("debug", `Unexpected 502 on ${options.method} ${route}`);
+                            setTimeout(() => {
+                                this.request(options).then(resolve).catch(reject);
+                            }, Math.floor(Math.random() * 1900 + 100));
+                            return cb();
+                        }
+                        cb();
+                        let { stack } = _stackHolder;
+                        if (stack.startsWith("Error\n")) {
+                            stack = stack.slice(6);
+                        }
+                        const err = resBody && typeof resBody === "object" && "code" in resBody ? new DiscordRESTError_1.default(res, resBody, options.method, stack) : new DiscordHTTPError_1.default(res, resBody, options.method, stack);
+                        reject(err);
+                        return;
+                    }
+                    cb();
+                    resolve(resBody);
+                }
+                catch (err) {
+                    cb();
+                    if (err instanceof Error && err.constructor.name === "DOMException" && err.name === "AbortError") {
+                        reject(new Error(`Request Timed Out (>${this.options.requestTimeout}ms) on ${options.method} ${options.path}`));
+                    }
+                    this._manager.client.emit("error", err);
+                }
+            }
+            if (this.globalBlock && options.auth) {
+                (options.priority ? this.readyQueue.unshift.bind(this.readyQueue) : this.readyQueue.push.bind(this.readyQueue))(() => {
+                    this.ratelimits[route].queue(attempt.bind(this), options.priority);
+                });
+            }
+            else {
+                this.ratelimits[route].queue(attempt.bind(this), options.priority);
+            }
+        });
+    }
+}
+exports.default = RequestHandler;

package/lib/Discord/rest/SequentialBucket.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Latency & ratelimit related things lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/util/SequentialBucket.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+/** A ratelimit bucket. */
+class SequentialBucket {
+    _queue = [];
+    last;
+    latencyRef;
+    limit;
+    processing = false;
+    remaining;
+    reset;
+    constructor(limit, latencyRef) {
+        this.limit = this.remaining = limit;
+        this.latencyRef = latencyRef;
+        this.last = this.reset = 0;
+    }
+    check(force = false) {
+        if (this._queue.length === 0) {
+            if (this.processing) {
+                if (typeof this.processing !== "boolean") {
+                    clearTimeout(this.processing);
+                }
+                this.processing = false;
+            }
+            return;
+        }
+        if (this.processing && !force) {
+            return;
+        }
+        const now = Date.now();
+        const offset = this.latencyRef.latency;
+        if (!this.reset || this.reset < now - offset) {
+            this.reset = now - offset;
+            this.remaining = this.limit;
+        }
+        this.last = now;
+        if (this.remaining <= 0) {
+            this.processing = setTimeout(() => {
+                this.processing = false;
+                this.check(true);
+            }, Math.max(0, (this.reset ?? 0) - now + offset) + 1);
+            return;
+        }
+        --this.remaining;
+        this.processing = true;
+        this._queue.shift()(() => {
+            if (this._queue.length === 0) {
+                this.processing = false;
+            }
+            else {
+                this.check(true);
+            }
+        });
+    }
+    /**
+     * Add an item to the queue.
+     * @param func The function to queue.
+     * @param priority- If true, the item will be added to the front of the queue/
+     */
+    queue(func, priority = false) {
+        if (priority) {
+            this._queue.unshift(func);
+        }
+        else {
+            this._queue.push(func);
+        }
+        this.check();
+    }
+}
+exports.default = SequentialBucket;

package/lib/Discord/rest/SequentialBucket.d.ts

@@ -0,0 +1,24 @@
+/** @module SequentialBucket */
+import type * as Types from "../types/namespaced";
+/**
+ * Latency & ratelimit related things lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/util/SequentialBucket.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+/** A ratelimit bucket. */
+export default class SequentialBucket {
+    private _queue;
+    last: number;
+    latencyRef: Types.RequestHandler.LatencyRef;
+    limit: number;
+    processing: NodeJS.Timeout | boolean;
+    remaining: number;
+    reset: number;
+    constructor(limit: number, latencyRef: Types.RequestHandler.LatencyRef);
+    private check;
+    /**
+     * Add an item to the queue.
+     * @param func The function to queue.
+     * @param priority- If true, the item will be added to the front of the queue/
+     */
+    queue(func: (cb: () => void) => void, priority?: boolean): void;
+}

package/lib/Discord/rest/SequentialBucket.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Latency & ratelimit related things lovingly borrowed from eris
+ * https://github.com/abalabahaha/eris/blob/dev/lib/util/SequentialBucket.js (eb403730855714eafa36c541dbe2cb84c9979158)
+ */
+/** A ratelimit bucket. */
+class SequentialBucket {
+    _queue = [];
+    last;
+    latencyRef;
+    limit;
+    processing = false;
+    remaining;
+    reset;
+    constructor(limit, latencyRef) {
+        this.limit = this.remaining = limit;
+        this.latencyRef = latencyRef;
+        this.last = this.reset = 0;
+    }
+    check(force = false) {
+        if (this._queue.length === 0) {
+            if (this.processing) {
+                if (typeof this.processing !== "boolean") {
+                    clearTimeout(this.processing);
+                }
+                this.processing = false;
+            }
+            return;
+        }
+        if (this.processing && !force) {
+            return;
+        }
+        const now = Date.now();
+        const offset = this.latencyRef.latency;
+        if (!this.reset || this.reset < now - offset) {
+            this.reset = now - offset;
+            this.remaining = this.limit;
+        }
+        this.last = now;
+        if (this.remaining <= 0) {
+            this.processing = setTimeout(() => {
+                this.processing = false;
+                this.check(true);
+            }, Math.max(0, (this.reset ?? 0) - now + offset) + 1);
+            return;
+        }
+        --this.remaining;
+        this.processing = true;
+        this._queue.shift()(() => {
+            if (this._queue.length === 0) {
+                this.processing = false;
+            }
+            else {
+                this.check(true);
+            }
+        });
+    }
+    /**
+     * Add an item to the queue.
+     * @param func The function to queue.
+     * @param priority- If true, the item will be added to the front of the queue/
+     */
+    queue(func, priority = false) {
+        if (priority) {
+            this._queue.unshift(func);
+        }
+        else {
+            this._queue.push(func);
+        }
+        this.check();
+    }
+}
+exports.default = SequentialBucket;