@sonoransoftware/sonoran.js 1.0.11 → 1.0.12

package/dist/libs/rest/src/lib/RequestManager.d.ts

@@ -55,4 +55,5 @@ export declare class RequestManager extends EventEmitter {
     removeRateLimit(id: string): void;
     private createHandler;
     private static resolveRequestData;
+    debug(log: string): void;
 }

package/dist/libs/rest/src/lib/RequestManager.js

@@ -186,5 +186,8 @@ class RequestManager extends events_1.EventEmitter {
         };
         return apiData;
     }
+    debug(log) {
+        return this.instance._debugLog(log);
+    }
 }
 exports.RequestManager = RequestManager;

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

@@ -94,6 +94,7 @@ class SequentialHandler {
         const controller = new node_abort_controller_1.AbortController();
         const timeout = setTimeout(() => controller.abort(), 30000).unref();
         let res;
+        void this.manager.debug(`[${url} Request] - ${JSON.stringify({ url, options, data })}`);
         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'
@@ -106,13 +107,13 @@ class SequentialHandler {
         finally {
             clearTimeout(timeout);
         }
+        void this.manager.debug(`[${url} Response] - ${JSON.stringify(res)}`);
         if (res.ok) {
             const parsedRes = await SequentialHandler.parseResponse(res);
             return parsedRes;
         }
         else if (res.status === 400 || res.status === 401 || res.status === 404) {
             const parsedRes = await 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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sonoransoftware/sonoran.js",
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "Sonoran.js is a library that allows you to interact with the Sonoran CAD and Sonoran CMS API. Based off of and utilizes several Discord.js library techniques for ease of use.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/libs/rest/src/lib/RequestManager.ts

@@ -253,4 +253,8 @@ export class RequestManager extends EventEmitter {
 
     return apiData;
   }
+
+  debug(log: string) {
+    return this.instance._debugLog(log);
+  }
 }

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

@@ -1,158 +1,161 @@
-// import { setTimeout as sleep } from 'node:timers/promises';
-import { AsyncQueue } from '@sapphire/async-queue';
-import fetch, { RequestInit, Response } from 'node-fetch';
-import { AbortController } from "node-abort-controller";
-// import { DiscordAPIError, DiscordErrorData, OAuthErrorData } from '../errors/DiscordAPIError';
-import { APIError } from '../errors';
-import { HTTPError } from '../errors/HTTPError';
-// import { RateLimitError } from '../errors/RateLimitError';
-import type { RequestManager, APIData, /**RequestData*/ } from '../RequestManager';
-import { RateLimitData } from '../REST';
-// import { RESTEvents } from '../utils/constants';
-// import type { RateLimitData } from '../REST';
-import type { IHandler } from './IHandler';
-
-export class SequentialHandler implements IHandler {
-	/**
-	 * The unique id of the handler
-	 */
-	public readonly id: string;
-
-	/**
-	 * 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
-	#asyncQueue = new AsyncQueue();
-
-	/**
-	 * @param manager The request manager
-	 * @param hash The hash that this RequestHandler handles
-	 * @param majorParameter The major parameter for this handler
-	 */
-	public constructor(
-		private readonly manager: RequestManager,
-		private readonly data: APIData,
-	) {
-		this.id = `${this.data.typePath}:${String(this.data.product)}`;
-	}
-
-	/**
-	 * If the bucket is currently inactive (no pending requests)
-	 */
-	public get inactive(): boolean {
-		return (
-			this.#asyncQueue.remaining === 0
-		);
-	}
-
-	public getMang(): RequestManager {
-		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
-	 */
-	public async queueRequest(
-		url: string,
-		options: RequestInit,
-    data: APIData
-	): Promise<unknown> {
-		let queue = this.#asyncQueue;
-		// Wait for any previous requests to be completed before this one is run
-		await queue.wait();
-		try {
-			// Make the request, and return the results
-			return await 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)
-	 */
-	private async runRequest(
-		url: string,
-		options: RequestInit,
-    data: APIData,
-		// retries = 0,
-	): Promise<unknown> {
-		const controller = new AbortController();
-		const timeout = setTimeout(() => controller.abort(), 30000).unref();
-		let res: Response;
-
-		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 = await fetch(url, { ...options, signal: controller.signal as any });
-		} catch (error: unknown) {
-			throw error;
-		} finally {
-			clearTimeout(timeout);
-		}
-
-		if (res.ok) {
-			const parsedRes = await SequentialHandler.parseResponse(res);
-			return parsedRes;
-		} else if (res.status === 400 || res.status === 401 || res.status === 404) {
-			const parsedRes = await SequentialHandler.parseResponse(res);
-			// throw new HTTPError(String(parsedRes), res.constructor.name, res.status, data.method, url);
-			throw new APIError(parsedRes as string, data.type, data.fullUrl, res.status, data);
-		} else if (res.status === 429) {
-			const timeout = setTimeout(() => {
-				this.manager.removeRateLimit(data.requestTypeId);
-			}, 60 * 1000);
-			const ratelimitData: 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(res.statusText, res.constructor.name, res.status, data.method, url);
-		}
-    return null;
-	}
-
-	private static parseResponse(res: Response): Promise<unknown> {
-		if (res.headers.get('Content-Type')?.startsWith('application/json')) {
-			return res.json();
-		}
-	
-		return res.text();
-	}
+// import { setTimeout as sleep } from 'node:timers/promises';
+import { AsyncQueue } from '@sapphire/async-queue';
+import fetch, { RequestInit, Response } from 'node-fetch';
+import { AbortController } from "node-abort-controller";
+// import { DiscordAPIError, DiscordErrorData, OAuthErrorData } from '../errors/DiscordAPIError';
+import { APIError } from '../errors';
+import { HTTPError } from '../errors/HTTPError';
+// import { RateLimitError } from '../errors/RateLimitError';
+import type { RequestManager, APIData, /**RequestData*/ } from '../RequestManager';
+import { RateLimitData } from '../REST';
+// import { RESTEvents } from '../utils/constants';
+// import type { RateLimitData } from '../REST';
+import type { IHandler } from './IHandler';
+
+export class SequentialHandler implements IHandler {
+	/**
+	 * The unique id of the handler
+	 */
+	public readonly id: string;
+
+	/**
+	 * 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
+	#asyncQueue = new AsyncQueue();
+
+	/**
+	 * @param manager The request manager
+	 * @param hash The hash that this RequestHandler handles
+	 * @param majorParameter The major parameter for this handler
+	 */
+	public constructor(
+		private readonly manager: RequestManager,
+		private readonly data: APIData,
+	) {
+		this.id = `${this.data.typePath}:${String(this.data.product)}`;
+	}
+
+	/**
+	 * If the bucket is currently inactive (no pending requests)
+	 */
+	public get inactive(): boolean {
+		return (
+			this.#asyncQueue.remaining === 0
+		);
+	}
+
+	public getMang(): RequestManager {
+		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
+	 */
+	public async queueRequest(
+		url: string,
+		options: RequestInit,
+    data: APIData
+	): Promise<unknown> {
+		let queue = this.#asyncQueue;
+		// Wait for any previous requests to be completed before this one is run
+		await queue.wait();
+		try {
+			// Make the request, and return the results
+			return await 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)
+	 */
+	private async runRequest(
+		url: string,
+		options: RequestInit,
+    data: APIData,
+		// retries = 0,
+	): Promise<unknown> {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), 30000).unref();
+		let res: Response;
+
+		void this.manager.debug(`[${url} Request] - ${JSON.stringify({ url, options, data })}`);
+
+		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 = await fetch(url, { ...options, signal: controller.signal as any });
+		} catch (error: unknown) {
+			throw error;
+		} finally {
+			clearTimeout(timeout);
+		}
+
+		void this.manager.debug(`[${url} Response] - ${JSON.stringify(res)}`);
+
+		if (res.ok) {
+			const parsedRes = await SequentialHandler.parseResponse(res);
+			return parsedRes;
+		} else if (res.status === 400 || res.status === 401 || res.status === 404) {
+			const parsedRes = await SequentialHandler.parseResponse(res);
+			throw new APIError(parsedRes as string, data.type, data.fullUrl, res.status, data);
+		} else if (res.status === 429) {
+			const timeout = setTimeout(() => {
+				this.manager.removeRateLimit(data.requestTypeId);
+			}, 60 * 1000);
+			const ratelimitData: 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(res.statusText, res.constructor.name, res.status, data.method, url);
+		}
+    return null;
+	}
+
+	private static parseResponse(res: Response): Promise<unknown> {
+		if (res.headers.get('Content-Type')?.startsWith('application/json')) {
+			return res.json();
+		}
+	
+		return res.text();
+	}
 }