@sonoransoftware/sonoran.js 1.0.0

package/src/constants.ts

@@ -0,0 +1,174 @@
+import Collection from '@discordjs/collection';
+import { CADDispatchOriginEnums, CADDispatchStatusEnums } from './libs/rest/src';
+import { DataManager } from './managers/DataManager';
+import { CADActiveUnitsManager } from './managers/CADActiveUnitsManager';
+import { CADActiveUnit } from './structures/CADActiveUnit';
+
+export enum productEnums {
+  CAD,
+  CMS
+}
+
+export interface CADNewDispatchBuilderOptions {
+	serverId?: number;
+	origin?: CADDispatchOriginEnums;
+	status?: CADDispatchStatusEnums;
+	priority?: 1 | 2 | 3;
+	block?: string;
+	address?: string;
+	postal?: string;
+	title?: string;
+	code?: string;
+	primary?: number;
+	trackPrimary?: boolean;
+	description?: string;
+	metaData?: Record<string, string>;
+	units?: string[];
+}
+
+export type Constructable<T> = abstract new (...args: any[]) => T;
+
+export interface Caches {
+	CADActiveUnitsManager: [manager: typeof CADActiveUnitsManager, holds: CADActiveUnit];
+}
+
+export type CacheConstructors = {
+  [K in keyof Caches]: Caches[K][0] & { name: K };
+};
+
+export type CacheFactory = (
+  manager: CacheConstructors[keyof Caches],
+  holds: Caches[typeof manager['name']][1],
+) => typeof manager['prototype'] extends DataManager<infer K, infer V, any> ? Collection<K, V> : never;
+
+export interface CADActiveUnitFetchOptions {
+	id?: number | number[];
+	accId?: string | string[];
+	apiId?: string | string[];
+}
+
+export enum CADSubscriptionVersionEnum {
+	FREE = 0,
+	STARTER = 1,
+	STANDARD = 2,
+	PLUS = 3,
+	PRO = 4,
+	ONE = 6
+}
+
+export enum CMSSubscriptionVersionEnum {
+	FREE = 0,
+	STARTER = 1,
+	STANDARD = 2,
+	PLUS = 3,
+	PRO = 4,
+	ONE = 6
+}
+
+export type Mutable<T> = {
+	-readonly [k in keyof T]: T[k];
+};
+
+export interface CMSVerifyWhitelistPromiseResult {
+	success: boolean;
+	reason?: string;
+}
+
+export interface CMSGetComAccountPromiseResult {
+	success: boolean;
+	reason?: string;
+	data?: {
+		accId: string;
+		active: boolean;
+		accName: string;
+		comName: string;
+		primaryIdentifier: string;
+		secondaryIdentifiers: string[];
+		primaryRank: string;
+		secondaryRanks: string[];
+		primaryDepartment: string;
+		secondaryDepartments: string[];
+		joinDate: string;
+		totalRankPower: number;
+		comOwner: boolean;
+		isBanned: boolean;
+		lastLogin: string;
+		activeApiIds: string[];
+	}
+}
+
+export const uuidRegex = /[a-f0-9]{8}-?[a-f0-9]{4}-?4[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}/i;
+
+export interface CMSClockInOutPromiseResult {
+	success: boolean;
+	reason?: string;
+	clockedIn?: boolean;
+}
+
+export interface CMSClockInOutParams {
+	accId?: string;
+	apiId?: string;
+	forceClockIn?: boolean;
+}
+
+export interface CMSCheckComApiIdPromiseResult {
+	success: boolean;
+	reason?: string;
+	username?: string;
+}
+
+export interface CADGetAccountPromiseResult {
+	success: boolean;
+	reason?: string;
+	data?: {
+		uuid: string;
+		username: string;
+		status: number;
+		joined: string;
+		lastLogin: string;
+		permissions: {
+			civilian: boolean;
+			lawyer: boolean;
+			dmv: boolean;
+			police: boolean;
+			fire: boolean;
+			ems: boolean;
+			dispatch: boolean;
+			admin: boolean;
+			polRecAdd: boolean;
+			polRecEdit: boolean;
+			polRecRemove: boolean;
+			polSuper: boolean;
+			polEditUnit: boolean;
+			polEditOtherUnit: boolean;
+			selfDispatch: boolean;
+			medRecAdd: boolean;
+			medRecEdit: boolean;
+			medRecRemove: boolean;
+			medSuper: boolean;
+			fireRecAdd: boolean;
+			fireRecEdit: boolean;
+			fireRecRemove: boolean;
+			fireSuper: boolean;
+			dmvRecAdd: boolean;
+			dmvRecEdit: boolean;
+			dmvRecRemove: boolean;
+			dmvSuper: boolean;
+			lawRecAdd: boolean;
+			lawRecEdit: boolean;
+			lawRecRemove: boolean;
+			lawSuper: boolean;
+			adminAccounts: boolean;
+			adminPermissionKeys: boolean;
+			adminCustomization: boolean;
+			adminDepartments: boolean;
+			adminTenCodes: boolean;
+			adminPenalCodes: boolean;
+			adminInGameIntegration: boolean;
+			adminDiscordIntegration: boolean;
+			adminLimits: boolean;
+			adminLogs: boolean;
+		},
+		apiIds: string[];
+	}
+}

package/src/errors/LibraryErrors.ts

@@ -0,0 +1,43 @@
+const messages = new Map();
+
+export class GenericError extends Error {
+  private readonly errCode: string;
+  constructor(key: string, ...args: Array<any>) {
+    super(GenericError.message(key, args));
+    this.errCode = key;
+    if (Error.captureStackTrace) Error.captureStackTrace(this, GenericError);
+  }
+
+  get name(): string {
+    return `${super.name} [${this.errCode}]`;
+  }
+
+  get code(): string {
+    return this.errCode;
+  }
+
+  /**
+   * Format the message for an error.
+   * @param {string} key Error key
+   * @param {Array<any>} args Arguments to pass for util format or as function args
+   * @returns {string} Formatted string
+   */
+  private static message(key: string, args: Array<any>): string {
+    if (typeof key !== 'string') throw new Error('Error message key must be a string');
+    const msg = messages.get(key);
+    if (!msg) throw new Error(`An invalid error message key was used: ${key}.`);
+    if (typeof msg === 'function') return msg(...args);
+    if (!args?.length) return msg;
+    args.unshift(msg);
+    return String(...args);
+  }
+}
+
+/**
+ * Register an error code and message.
+ * @param {string} sym Unique name for the error
+ * @param {*} val Value of the error
+ */
+export function register(sym: symbol, val: any): void {
+  messages.set(sym, typeof val === 'function' ? val : String(val));
+}

package/src/errors/Messages.ts

@@ -0,0 +1,7 @@
+import { register } from './LibraryErrors';
+
+const Messages: Record<string | number | symbol, any> = {
+  NOT_IMPLEMENTED: (what: string, name: string) => `Method ${what} not implemented on ${name}.`
+};
+
+for (const [name, message] of Object.entries(Messages)) register(Symbol(name), message);

package/src/errors/index.ts

@@ -0,0 +1,2 @@
+export * from './LibraryErrors';
+export * from './Messages';

package/src/index.ts

@@ -0,0 +1,12 @@
+export * from './instance/Instance';
+export * from './builders';
+export * from './libs/rest/src';
+
+import { productEnums, CADNewDispatchBuilderOptions, CADSubscriptionVersionEnum, CMSSubscriptionVersionEnum } from './constants';
+
+export {
+  productEnums,
+  CADNewDispatchBuilderOptions,
+  CADSubscriptionVersionEnum,
+  CMSSubscriptionVersionEnum
+}

package/src/instance/Instance.ts

@@ -0,0 +1,118 @@
+import EventEmitter from 'node:events';
+
+import * as globalTypes from '../constants';
+import * as InstanceTypes from './instance.types';
+import { CADManager } from '../managers/CADManager';
+import { CMSManager } from '../managers/CMSManager';
+import { debugLog } from '../utils';
+
+export default class Instance extends EventEmitter {
+  public cadCommunityId: string | undefined;
+  public cadApiKey: string | undefined;
+  public cadApiUrl: string = 'https://api.sonorancad.com';
+  public cadDefaultServerId: number = 1;
+  public isCADSuccessful: boolean = false;
+  public cmsCommunityId: string | undefined;
+  public cmsApiKey: string | undefined;
+  public cmsApiUrl: string = 'https://api.sonorancms.com';
+  public cmsDefaultServerId: number = 1;
+  public isCMSSuccessful: boolean = false;
+
+  public cad: CADManager | undefined;
+  public cms: CMSManager | undefined;
+
+  public debug: boolean = false;
+
+  constructor(options: InstanceTypes.InstanceOptions) {
+    super({ captureRejections: true });
+    if (options.debug) {
+      this.debug = options.debug;
+    }
+    if (Object.prototype.hasOwnProperty.call(options, 'apiKey') && Object.prototype.hasOwnProperty.call(options, 'communityId')) {
+      if (Object.prototype.hasOwnProperty.call(options, 'product')) {
+        switch (options.product) {
+          case globalTypes.productEnums.CAD: {
+            this.cadCommunityId = options.communityId;
+            this.cadApiKey = options.apiKey;
+            if (options.serverId !== undefined) {
+              this._debugLog(`Overriding default server id... ${options.serverId}`);
+              this.cadDefaultServerId = options.serverId;
+            }
+            if (Object.prototype.hasOwnProperty.call(options, 'cadApiUrl') && typeof options.cadApiUrl === 'string') {
+              this._debugLog(`Overriding CAD API Url... ${options.cadApiUrl}`);
+              this.cadApiUrl = options.cadApiUrl;
+            }
+            this._debugLog('About to initialize instance.');
+            this.initialize();
+            break;
+          }
+          case globalTypes.productEnums.CMS: {
+            this.cmsCommunityId = options.communityId;
+            this.cmsApiKey = options.apiKey;
+            if (options.serverId !== undefined) {
+              this._debugLog(`Overriding default server id... ${options.serverId}`);
+              this.cmsDefaultServerId = options.serverId;
+            }
+            if (Object.prototype.hasOwnProperty.call(options, 'cmsApiUrl') && typeof options.cmsApiUrl === 'string') {
+              this._debugLog(`Overriding CMS API URL... ${options.cmsApiUrl}`);
+              this.cmsApiUrl = options.cmsApiUrl;
+            }
+            this.initialize();
+            break;
+          }
+          default: {
+            throw new Error('Invalid product enum given for constructor.');
+          }
+        }
+      } else {
+        throw new Error('No product enum given when instancing.');
+      }
+    } else {
+      this.cadCommunityId = options.cadCommunityId;
+      this.cadApiKey = options.cadApiKey;
+      this.cmsCommunityId = options.cmsCommunityId;
+      this.cmsApiKey = options.cmsApiKey;
+
+      if (options.cadDefaultServerId !== undefined) {
+        this._debugLog(`Overriding default CAD server id... ${options.serverId}`);
+        this.cadDefaultServerId = options.cadDefaultServerId;
+      }
+      if (options.cmsDefaultServerId !== undefined) {
+        this._debugLog(`Overriding default CMS server id... ${options.serverId}`);
+        this.cmsDefaultServerId = options.cmsDefaultServerId;
+      }
+      if (Object.prototype.hasOwnProperty.call(options, 'cadApiUrl') && typeof options.cadApiUrl === 'string') {
+        this._debugLog(`Overriding CAD API Url... ${options.cadApiUrl}`);
+        this.cadApiUrl = options.cadApiUrl;
+      }
+      if (Object.prototype.hasOwnProperty.call(options, 'cmsApiUrl') && typeof options.cmsApiUrl === 'string') {
+        this._debugLog(`Overriding CMS API URL... ${options.cmsApiUrl}`);
+        this.cmsApiUrl = options.cmsApiUrl;
+      }
+      this.initialize();
+    }
+  }
+
+
+
+  private initialize() {
+    if (this.cadCommunityId && this.cadApiKey && this.cadApiUrl) {
+      this._debugLog('About to initialize CAD Manager');
+      this.cad = new CADManager(this);
+    } else {
+      this._debugLog('Not initializing CAD Manager due to a missing community id, api key, or api url.');
+    }
+    if (this.cmsCommunityId && this.cmsApiKey && this.cmsApiUrl) {
+      this._debugLog('About to initialize CMS Manager');
+      this.cms = new CMSManager(this);
+    } else {
+      this._debugLog('Not initializing CMS Manager due to a missing community id, api key, or api url.');
+    }
+  }
+
+  public _debugLog(message: string): void {
+    if (this.debug) {
+      debugLog(message);
+    }
+  }
+}

package/src/instance/instance.types.ts

@@ -0,0 +1,17 @@
+import * as globalTypes from '../constants';
+
+export type InstanceOptions = {
+  communityId?: string;
+  apiKey?: string;
+  product?: globalTypes.productEnums;
+  serverId?: number;
+  cadCommunityId?: string;
+  cadApiKey?: string;
+  cadApiUrl?: string;
+  cadDefaultServerId?: number;
+  cmsCommunityId?: string;
+  cmsApiKey?: string;
+  cmsApiUrl?: string;
+  cmsDefaultServerId?: number;
+  debug?: boolean;
+};

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

@@ -0,0 +1,6 @@
+export * from './lib/errors/APIError';
+export * from './lib/errors/HTTPError';
+export * from './lib/errors/RateLimitError';
+export * from './lib/RequestManager';
+export * from './lib/REST';
+export * from './lib/utils/constants';

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

@@ -0,0 +1,201 @@
+import { EventEmitter } from 'node:events';
+import {
+	InternalRequestData,
+	// RequestMethod,
+	RequestData,
+	RequestManager,
+	// RouteLike
+} from './RequestManager';
+import { AllAPITypes, AllAPITypesType, RESTEvents, RESTTypedAPIDataStructs } from './utils/constants';
+import { productEnums, uuidRegex } from '../../../../constants';
+import type { AgentOptions } from 'node:https';
+import type { RequestInit, Response } from 'node-fetch';
+// import type Collection from '@discordjs/collection';
+import Instance from '../../../../instance/Instance';
+import { CADManager } from '../../../../managers/CADManager';
+import { convertSubNumToName } from './utils/Utils';
+import { CMSManager } from '../../../../managers/CMSManager';
+
+/**
+ * Options to be passed when creating the REST instance
+ */
+export interface RESTOptions {
+	/**
+	 * HTTPS Agent options
+	 * @default {}
+	 */
+	agent: Omit<AgentOptions, 'keepAlive'>;
+	/**
+	 * The base api path, without version
+	 */
+	api: string;
+	/**
+	 * Additional headers to send for all API requests
+	 * @default {}
+	 */
+	headers: Record<string, string>;
+	/**
+	 * Wether the request should be queued if there's a current ratelimit or to reject.
+	 * @default true
+	 */
+	 rejectOnRateLimit: boolean;
+}
+
+/**
+ * Data emitted on `RESTEvents.RateLimited`
+ */
+export interface RateLimitData {
+	product: productEnums;
+  type: string;
+  timeTill: NodeJS.Timer;
+}
+
+export interface APIRequest {
+	/**
+	 * The HTTP method used in this request
+	 */
+	type: AllAPITypesType;
+	/**
+	 * Additional HTTP options for this request
+	 */
+	options: RequestInit;
+	/**
+	 * The data that was used to form the body of this request
+	 */
+	data: RequestData;
+}
+
+export interface InvalidRequestWarningData {
+	/**
+	 * Number of invalid requests that have been made in the window
+	 */
+	count: number;
+	/**
+	 * API request type which the request is for
+	 */
+	type: string;
+	/**
+	 * Product which the invalid request is for
+	 */
+	product: productEnums;
+}
+
+export interface RestEvents {
+	invalidRequestWarning: [invalidRequestInfo: InvalidRequestWarningData];
+	restDebug: [info: string];
+	rateLimited: [rateLimitInfo: RateLimitData];
+	request: [request: APIRequest];
+	response: [request: APIRequest, response: Response];
+	newListener: [name: string, listener: (...args: any) => void];
+	removeListener: [name: string, listener: (...args: any) => void];
+}
+
+export interface REST {
+	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 type RestManagerTypes = CADManager | CMSManager;
+
+export class REST extends EventEmitter {
+	public readonly requestManager: RequestManager;
+	public readonly instance: Instance;
+	public readonly manager: RestManagerTypes;
+
+	public constructor(_instance: Instance, _manager: RestManagerTypes,_product: productEnums, options: RESTOptions) {
+		super();
+		this.instance = _instance;
+		this.manager = _manager;
+		this.requestManager = new RequestManager(_instance, _product, options)
+			.on(RESTEvents.Debug, this.emit.bind(this, RESTEvents.Debug))
+			.on(RESTEvents.RateLimited, this.emit.bind(this, RESTEvents.RateLimited))
+			.on(RESTEvents.InvalidRequestWarning, this.emit.bind(this, RESTEvents.InvalidRequestWarning));
+
+		this.on('newListener', (name, listener) => {
+			if (name === RESTEvents.Request || name === RESTEvents.Response) this.requestManager.on(name, listener);
+		});
+		this.on('removeListener', (name, listener) => {
+			if (name === RESTEvents.Request || name === RESTEvents.Response) this.requestManager.off(name, listener);
+		});
+	}
+
+	/**
+	 * Runs a request from the api
+	 * @param type API Type Enum
+	 */
+	public request<K extends keyof RESTTypedAPIDataStructs>(type: K, ...args: RESTTypedAPIDataStructs[K]) {
+		const apiType = AllAPITypes.find((aT) => aT.type === type);
+		if (!apiType) throw new Error('Invalid API Type given for request.');
+		let communityId: string | undefined;
+		let apiKey: string | undefined;
+		switch (apiType.product) {
+			case productEnums.CAD: {
+				communityId = this.instance.cadCommunityId;	
+				apiKey = this.instance.cadApiKey;	
+				break;
+			}
+			case productEnums.CMS: {
+				communityId = this.instance.cmsCommunityId;
+				apiKey = this.instance.cmsApiKey;
+				break;
+			}
+		}
+		if (!communityId || !apiKey) throw new Error(`Community ID or API Key could not be found for request. P${apiType.product}`);
+		if (apiType.minVersion > this.manager.version) throw new Error(`[${type}] Subscription version too low for this API type request. Current Version: ${convertSubNumToName(this.manager.version)} Needed Version: ${convertSubNumToName(apiType.minVersion)}`);
+		const formattedData = this.formatDataArguments(apiType.type, args);
+		const options: InternalRequestData = {
+			id: communityId,
+			key: apiKey,
+			type,
+			data: formattedData,
+			product: apiType.product
+		};
+		return this.requestManager.queueRequest(options);
+	}
+
+	private formatDataArguments(type: string, args: any) {
+		switch (type) {
+			case 'VERIFY_WHITELIST': {
+				return {
+					apiId: args[0],
+					accId: uuidRegex.test(args[1]) ? args[1] : undefined,
+					serverId: args[2]
+				}
+			}
+			case 'GET_COM_ACCOUNT': {
+				return {
+					apiId: args[0],
+					username: args[1],
+					accId: args[2]
+				};
+			}
+			case 'CLOCK_IN_OUT': {
+				return {
+					apiId: args[0],
+					accId: args[1],
+					forceClockIn: args[2]
+				};
+			}
+			case 'CHECK_COM_APIID': {
+				return {
+					apiId: args[0]
+				};
+			}
+			default: {
+				return args;
+			}
+		}
+	}
+}