@sonoransoftware/sonoran.js 1.0.0 → 1.0.1

package/dist/libs/rest/src/lib/errors/HTTPError.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Represents a HTTP error
+ */
+export declare class HTTPError extends Error {
+    name: string;
+    status: number;
+    method: string;
+    url: string;
+    /**
+     * @param message The error message
+     * @param name The name of the error
+     * @param status The status code of the response
+     * @param method The method of the request that erred
+     * @param url The url of the request that erred
+     */
+    constructor(message: string, name: string, status: number, method: string, url: string);
+}

package/dist/libs/rest/src/lib/errors/HTTPError.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPError = void 0;
+/**
+ * Represents a HTTP error
+ */
+class HTTPError extends Error {
+    /**
+     * @param message The error message
+     * @param name The name of the error
+     * @param status The status code of the response
+     * @param method The method of the request that erred
+     * @param url The url of the request that erred
+     */
+    constructor(message, name, status, method, url) {
+        super(message);
+        this.name = name;
+        this.status = status;
+        this.method = method;
+        this.url = url;
+    }
+}
+exports.HTTPError = HTTPError;

package/dist/libs/rest/src/lib/errors/RateLimitError.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type { RateLimitData } from '../REST';
+import { productEnums } from '../../../../../constants';
+export declare class RateLimitError extends Error implements RateLimitData {
+    product: productEnums;
+    type: string;
+    timeTill: NodeJS.Timer;
+    constructor({ product, type, timeTill }: RateLimitData);
+    /**
+     * The name of the error
+     */
+    get name(): string;
+}

package/dist/libs/rest/src/lib/errors/RateLimitError.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitError = void 0;
+const constants_1 = require("../../../../../constants");
+class RateLimitError extends Error {
+    constructor({ product, type, timeTill }) {
+        super();
+        this.product = product;
+        this.type = type;
+        this.timeTill = timeTill;
+    }
+    /**
+     * The name of the error
+     */
+    get name() {
+        return `Ratelimit Hit - [${this.product === constants_1.productEnums.CAD ? 'Sonoran CAD' : this.product === constants_1.productEnums.CMS ? 'Sonoran CMS' : 'Invalid Product'} '${this.type}']`;
+    }
+}
+exports.RateLimitError = RateLimitError;

package/dist/libs/rest/src/lib/errors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './APIError';
+export * from './APIError';
+export * from './HTTPError';
+export * from './RateLimitError';

package/dist/libs/rest/src/lib/errors/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./APIError"), exports);
+__exportStar(require("./APIError"), exports);
+__exportStar(require("./HTTPError"), exports);
+__exportStar(require("./RateLimitError"), exports);

package/dist/libs/rest/src/lib/handlers/IHandler.d.ts

@@ -0,0 +1,7 @@
+import type { RequestInit } from 'node-fetch';
+import type { APIData } from '../RequestManager';
+export interface IHandler {
+    queueRequest: (url: string, options: RequestInit, data: APIData) => Promise<unknown>;
+    get inactive(): boolean;
+    readonly id: string;
+}

package/dist/libs/rest/src/lib/handlers/IHandler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/libs/rest/src/lib/handlers/SequentialHandler.d.ts

@@ -0,0 +1,45 @@
+import { RequestInit } from 'node-fetch';
+import type { RequestManager, APIData } from '../RequestManager';
+import type { IHandler } from './IHandler';
+export declare class SequentialHandler implements IHandler {
+    #private;
+    private readonly manager;
+    private readonly data;
+    /**
+     * The unique id of the handler
+     */
+    readonly id: string;
+    /**
+     * @param manager The request manager
+     * @param hash The hash that this RequestHandler handles
+     * @param majorParameter The major parameter for this handler
+     */
+    constructor(manager: RequestManager, data: APIData);
+    /**
+     * If the bucket is currently inactive (no pending requests)
+     */
+    get inactive(): boolean;
+    getMang(): RequestManager;
+    /**
+     * Emits a debug message
+     * @param message The message to debug
+     */
+    /**
+     * Queues a request to be sent
+     * @param routeId The generalized api route with literal ids for major parameters
+     * @param url The url to do the request on
+     * @param options All the information needed to make a request
+     * @param requestData Extra data from the user's request needed for errors and additional processing
+     */
+    queueRequest(url: string, options: RequestInit, data: APIData): Promise<unknown>;
+    /**
+     * 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 node-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)
+     */
+    private runRequest;
+    private static parseResponse;
+}

package/dist/libs/rest/src/lib/handlers/SequentialHandler.js

@@ -0,0 +1,155 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _SequentialHandler_asyncQueue;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequentialHandler = void 0;
+// import { setTimeout as sleep } from 'node:timers/promises';
+const async_queue_1 = require("@sapphire/async-queue");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+// import { DiscordAPIError, DiscordErrorData, OAuthErrorData } from '../errors/DiscordAPIError';
+const errors_1 = require("../errors");
+const HTTPError_1 = require("../errors/HTTPError");
+class SequentialHandler {
+    /**
+     * @param manager The request manager
+     * @param hash The hash that this RequestHandler handles
+     * @param majorParameter The major parameter for this handler
+     */
+    constructor(manager, data) {
+        this.manager = manager;
+        this.data = data;
+        /**
+         * The total number of requests that can be made before we are rate limited
+         */
+        // private limit = Infinity;
+        /**
+         * The interface used to sequence async requests sequentially
+         */
+        // eslint-disable-next-line @typescript-eslint/explicit-member-accessibility
+        _SequentialHandler_asyncQueue.set(this, new async_queue_1.AsyncQueue());
+        this.id = `${this.data.typePath}:${String(this.data.product)}`;
+    }
+    /**
+     * If the bucket is currently inactive (no pending requests)
+     */
+    get inactive() {
+        return (__classPrivateFieldGet(this, _SequentialHandler_asyncQueue, "f").remaining === 0);
+    }
+    getMang() {
+        return this.manager;
+    }
+    /**
+     * Emits a debug message
+     * @param message The message to debug
+     */
+    // private debug(message: string) {
+    // 	this.manager.emit(RESTEvents.Debug, `[REST ${this.id}] ${message}`);
+    // }
+    /*
+     * Determines whether the request should be queued or whether a RateLimitError should be thrown
+     */
+    // private async onRateLimit(rateLimitData: RateLimitData) {
+    // 	const { options } = this.manager;
+    // 	if (options.rejectOnRateLimit) {
+    // 		throw new RateLimitError(rateLimitData);
+    // 	}
+    // }
+    /**
+     * Queues a request to be sent
+     * @param routeId The generalized api route with literal ids for major parameters
+     * @param url The url to do the request on
+     * @param options All the information needed to make a request
+     * @param requestData Extra data from the user's request needed for errors and additional processing
+     */
+    queueRequest(url, options, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let queue = __classPrivateFieldGet(this, _SequentialHandler_asyncQueue, "f");
+            // Wait for any previous requests to be completed before this one is run
+            yield queue.wait();
+            try {
+                // Make the request, and return the results
+                return yield this.runRequest(url, options, data);
+            }
+            finally {
+                // Allow the next request to fire
+                queue.shift();
+            }
+        });
+    }
+    /**
+     * 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 node-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)
+     */
+    runRequest(url, options, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 30000).unref();
+            let res;
+            try {
+                // node-fetch typings are a bit weird, so we have to cast to any to get the correct signature
+                // Type 'AbortSignal' is not assignable to type 'import('discord.js-modules/node_modules/@types/node-fetch/externals').AbortSignal'
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                res = yield (0, node_fetch_1.default)(url, Object.assign(Object.assign({}, options), { signal: controller.signal }));
+            }
+            catch (error) {
+                throw error;
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+            if (res.ok) {
+                const parsedRes = yield SequentialHandler.parseResponse(res);
+                return parsedRes;
+            }
+            else if (res.status === 400 || res.status === 401 || res.status === 404) {
+                const parsedRes = yield SequentialHandler.parseResponse(res);
+                // throw new HTTPError(String(parsedRes), res.constructor.name, res.status, data.method, url);
+                throw new errors_1.APIError(parsedRes, data.type, data.fullUrl, res.status, data);
+            }
+            else if (res.status === 429) {
+                const timeout = setTimeout(() => {
+                    this.manager.removeRateLimit(data.requestTypeId);
+                }, 60 * 1000);
+                const ratelimitData = {
+                    product: data.product,
+                    type: data.type,
+                    timeTill: timeout
+                };
+                this.manager.onRateLimit(data.requestTypeId, ratelimitData);
+            }
+            else if (res.status >= 500 && res.status < 600) {
+                throw new HTTPError_1.HTTPError(res.statusText, res.constructor.name, res.status, data.method, url);
+            }
+            return null;
+        });
+    }
+    static parseResponse(res) {
+        var _a;
+        if ((_a = res.headers.get('Content-Type')) === null || _a === void 0 ? void 0 : _a.startsWith('application/json')) {
+            return res.json();
+        }
+        return res.text();
+    }
+}
+exports.SequentialHandler = SequentialHandler;
+_SequentialHandler_asyncQueue = new WeakMap();

package/dist/libs/rest/src/lib/utils/Utils.d.ts

@@ -0,0 +1 @@
+export declare function convertSubNumToName(subLevel: number): "FREE" | "STARTER" | "STANDARD" | "PLUS" | "PRO" | "ONE";

package/dist/libs/rest/src/lib/utils/Utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertSubNumToName = void 0;
+function convertSubNumToName(subLevel) {
+    switch (subLevel) {
+        case 0:
+            return 'FREE';
+        case 1:
+            return 'STARTER';
+        case 2:
+            return 'STANDARD';
+        case 3:
+            return 'PLUS';
+        case 4:
+            return 'PRO';
+        case 6:
+            return 'ONE';
+        default:
+            return 'FREE';
+    }
+}
+exports.convertSubNumToName = convertSubNumToName;