@sonoransoftware/sonoran.js 1.0.0

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

@@ -0,0 +1,256 @@
+import Collection from '@discordjs/collection';
+// import { DiscordSnowflake } from '@sapphire/snowflake';
+import { EventEmitter } from 'node:events';
+// import type { RequestInit, BodyInit } from 'node-fetch';
+
+import type Instance from '../../../../instance/Instance';
+import { RESTOptions, RateLimitData, RestEvents } from './REST';
+import { DefaultCADRestOptions, DefaultCMSRestOptions, AllAPITypes/**, RESTTypedAPIDataStructs, PossibleRequestData*/ } from './utils/constants';
+import { productEnums } from '../../../../constants';
+// import { APIError, HTTPError } from './errors';
+import { IHandler } from './handlers/IHandler';
+import { SequentialHandler } from './handlers/SequentialHandler';
+import { cloneObject } from '../../../../utils/utils';
+
+export type RouteLike = `/${string}`;
+
+export const enum RequestMethod {
+	Delete = 'delete',
+	Get = 'get',
+	Patch = 'patch',
+	Post = 'post',
+	Put = 'put',
+}
+
+export type ReqDataType = Array<unknown> | unknown;
+
+export interface RequestData {
+  id: string;
+  key: string;
+  type: string;
+  data: any;
+}
+
+export interface InternalRequestData extends RequestData {
+  product: productEnums;
+}
+
+export interface RequestHeaders {
+  'User-Agent': string;
+}
+
+export interface APIData {
+  requestTypeId: string;
+  typePath: string;
+  fullUrl: string;
+  method: string;
+  fetchOptions: RequestInit;
+  data: RequestData;
+  product: productEnums;
+  type: string;
+}
+
+export interface RequestManager {
+	on: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) &
+		(<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
+
+	once: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) &
+		(<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
+
+	emit: (<K extends keyof RestEvents>(event: K, ...args: RestEvents[K]) => boolean) &
+		(<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, ...args: any[]) => boolean);
+
+	off: (<K extends keyof RestEvents>(event: K, listener: (...args: RestEvents[K]) => void) => this) &
+		(<S extends string | symbol>(event: Exclude<S, keyof RestEvents>, listener: (...args: any[]) => void) => this);
+
+	removeAllListeners: (<K extends keyof RestEvents>(event?: K) => this) &
+		(<S extends string | symbol>(event?: Exclude<S, keyof RestEvents>) => this);
+}
+
+export class RequestManager extends EventEmitter {
+  public readonly ratelimitedTypes = new Collection<string, RateLimitData>();
+  public readonly handlers = new Collection<string, IHandler>();
+  public readonly product: productEnums;
+  public readonly options: RESTOptions;
+  private instance: Instance;
+
+  constructor(_instance: Instance, _product: productEnums, options: RESTOptions) {
+    super();
+    this.product = _product;
+    this.instance = _instance;
+    switch (_product) {
+      case productEnums.CAD: {
+        this.options = { ...DefaultCADRestOptions, ...options };
+        break;
+      }
+      case productEnums.CMS: {
+        this.options = { ...DefaultCMSRestOptions, ...options };
+        break;
+      }
+      default: {
+        throw new Error('No Product provided for RequestManager initialization');
+      }
+    }
+  }
+
+  public async queueRequest(request: InternalRequestData): Promise<unknown> {
+    let requestData = request as RequestData;
+    const resolvedData: APIData = RequestManager.resolveRequestData(this.instance, request.type, request.product, requestData);
+    const handler = this.handlers.get(`${resolvedData.typePath}:${String(request.product)}`) ?? this.createHandler(resolvedData);
+    return handler.queueRequest(resolvedData.fullUrl, resolvedData.fetchOptions as any, resolvedData);
+  }
+
+  public onRateLimit(id: string, rateLimitData: RateLimitData): void {
+    this.ratelimitedTypes.set(id, rateLimitData);
+  }
+
+  public removeRateLimit(id: string): void {
+    this.ratelimitedTypes.delete(id);
+  }
+
+  private createHandler(data: APIData) {
+    const queue = new SequentialHandler(this, data);
+    this.handlers.set(queue.id, queue);
+    return queue;
+  }
+
+  private static resolveRequestData(instance: Instance, type: string, product: productEnums, data: RequestData): APIData {
+    let apiURL: string | boolean = false;
+    let apiData: APIData = {
+      requestTypeId: `${type}:${String(product)}`,
+      typePath: '',
+      fullUrl: '',
+      method: '',
+      fetchOptions: {},
+      data,
+      product,
+      type
+    };
+
+    switch (product) {
+      case productEnums.CAD:
+        apiURL = instance.cadApiUrl;
+        break;
+      case productEnums.CMS:
+        apiURL = instance.cmsApiUrl;
+        break;
+    }
+
+    const findType = AllAPITypes.find((_type) => _type.type === type);
+    if (findType) {
+      apiData.fullUrl = `${apiURL}/${findType.path}`;
+      apiData.method = findType.method;
+      apiData.fetchOptions.method = findType.method;
+      apiData.typePath = findType.path;
+
+      const clonedData = cloneObject(data.data);
+
+      switch (findType.type) {
+        case 'SET_SERVERS': {
+          apiData.data.data = clonedData;
+          break;
+        }
+        case 'SET_PENAL_CODES': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'SET_API_ID': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'NEW_RECORD': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'EDIT_RECORD': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'LOOKUP_INT': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'LOOKUP': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'SET_ACCOUNT_PERMISSIONS': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'BAN_USER': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'AUTH_STREETSIGNS': {
+          apiData.data.data = clonedData;
+          break;
+        }
+        case 'SET_POSTALS': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'NEW_CHARACTER': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'EDIT_CHARACTER': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'MODIFY_IDENTIFIER': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'ADD_BLIP': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'MODIFY_BLIP': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'GET_CALLS': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'GET_ACTIVE_UNITS': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'NEW_DISPATCH': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        case 'UNIT_LOCATION': {
+          apiData.data.data = clonedData.data;
+          break;
+        }
+        default: {
+          if (data.data) {
+            if (Array.isArray(data.data)) {
+              if (data.data.length > 0) {
+                apiData.data.data = [ clonedData ];
+              } else {
+                apiData.data.data = [];
+              }
+            } else {
+              apiData.data.data = [ clonedData ];
+            }
+          } else {
+            apiData.data.data = [];
+          }
+          break;
+        }
+      }
+    }
+
+    apiData.fetchOptions.body = JSON.stringify(apiData.data);
+    apiData.fetchOptions.headers = {
+      'Accept': 'application/json',
+      'Content-Type': 'application/json'
+    };
+
+    return apiData;
+  }
+}

package/src/libs/rest/src/lib/errors/APIError.ts

@@ -0,0 +1,15 @@
+export class APIError extends Error {
+  public constructor(
+    public response: string,
+    public requestType: string,
+    public requestUrl: string,
+    public responseCode: number,
+    public requestData: any
+  ) {
+    super(response);
+  }
+
+  public override get name(): string {
+    return `Sonoran.js API Error - ${this.requestType} [${this.responseCode}]`;
+  }
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Represents a HTTP error
+ */
+export 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
+	 */
+	public constructor(
+		message: string,
+		public override name: string,
+		public status: number,
+		public method: string,
+		public url: string
+	) {
+		super(message);
+	}
+}

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

@@ -0,0 +1,21 @@
+import type { RateLimitData } from '../REST';
+import { productEnums } from '../../../../../constants';
+
+export class RateLimitError extends Error implements RateLimitData {
+	public product: productEnums;
+	public type: string;
+	public timeTill: NodeJS.Timer;
+	public constructor({ product, type, timeTill }: RateLimitData) {
+		super();
+		this.product = product;
+		this.type = type;
+		this.timeTill = timeTill;
+	}
+
+	/**
+	 * The name of the error
+	 */
+	public override get name(): string {
+		return `Ratelimit Hit - [${this.product === productEnums.CAD ? 'Sonoran CAD' : this.product === productEnums.CMS ? 'Sonoran CMS' : 'Invalid Product' } '${this.type}']`;
+	}
+}

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

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

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

@@ -0,0 +1,13 @@
+import type { RequestInit } from 'node-fetch';
+import type { APIData } from '../RequestManager';
+
+export interface IHandler {
+	queueRequest: (
+		url: string,
+		options: RequestInit,
+		data: APIData,
+	) => Promise<unknown>;
+	// eslint-disable-next-line @typescript-eslint/method-signature-style -- This is meant to be a getter returning a bool
+	get inactive(): boolean;
+	readonly id: string;
+}

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

@@ -0,0 +1,157 @@
+// import { setTimeout as sleep } from 'node:timers/promises';
+import { AsyncQueue } from '@sapphire/async-queue';
+import fetch, { RequestInit, Response } from 'node-fetch';
+// 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();
+	}
+}