@sonoransoftware/sonoran.js 1.0.0 → 1.0.3

package/dist/instance/Instance.js

@@ -0,0 +1,135 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Instance = void 0;
+const events_1 = __importDefault(require("events"));
+const globalTypes = __importStar(require("../constants"));
+const CADManager_1 = require("../managers/CADManager");
+const CMSManager_1 = require("../managers/CMSManager");
+const utils_1 = require("../utils");
+class Instance extends events_1.default {
+    constructor(options) {
+        super({ captureRejections: true });
+        this.cadApiUrl = 'https://api.sonorancad.com';
+        this.cadDefaultServerId = 1;
+        this.isCADSuccessful = false;
+        this.cmsApiUrl = 'https://api.sonorancms.com';
+        this.cmsDefaultServerId = 1;
+        this.isCMSSuccessful = false;
+        this.debug = false;
+        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();
+        }
+    }
+    initialize() {
+        if (this.cadCommunityId && this.cadApiKey && this.cadApiUrl) {
+            this._debugLog('About to initialize CAD Manager');
+            this.cad = new CADManager_1.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_1.CMSManager(this);
+        }
+        else {
+            this._debugLog('Not initializing CMS Manager due to a missing community id, api key, or api url.');
+        }
+    }
+    _debugLog(message) {
+        if (this.debug) {
+            (0, utils_1.debugLog)(message);
+        }
+    }
+}
+exports.Instance = Instance;

package/dist/instance/instance.types.d.ts

@@ -0,0 +1,16 @@
+import * as globalTypes from '../constants';
+export declare 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/dist/instance/instance.types.js

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

package/dist/libs/rest/src/index.d.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/dist/libs/rest/src/index.js

@@ -0,0 +1,22 @@
+"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("./lib/errors/APIError"), exports);
+__exportStar(require("./lib/errors/HTTPError"), exports);
+__exportStar(require("./lib/errors/RateLimitError"), exports);
+__exportStar(require("./lib/RequestManager"), exports);
+__exportStar(require("./lib/REST"), exports);
+__exportStar(require("./lib/utils/constants"), exports);

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

@@ -0,0 +1,99 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { RequestData, RequestManager } from './RequestManager';
+import { AllAPITypesType, RESTTypedAPIDataStructs } from './utils/constants';
+import { productEnums } from '../../../../constants';
+import type { AgentOptions } from 'node:https';
+import type { RequestInit, Response } from 'node-fetch';
+import { Instance } from '../../../../instance/Instance';
+import { CADManager } from '../../../../managers/CADManager';
+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 declare type RestManagerTypes = CADManager | CMSManager;
+export declare class REST extends EventEmitter {
+    readonly requestManager: RequestManager;
+    readonly instance: Instance;
+    readonly manager: RestManagerTypes;
+    constructor(_instance: Instance, _manager: RestManagerTypes, _product: productEnums, options: RESTOptions);
+    /**
+     * Runs a request from the api
+     * @param type API Type Enum
+     */
+    request<K extends keyof RESTTypedAPIDataStructs>(type: K, ...args: RESTTypedAPIDataStructs[K]): Promise<unknown>;
+    private formatDataArguments;
+}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REST = void 0;
+const events_1 = require("events");
+const RequestManager_1 = require("./RequestManager");
+const constants_1 = require("./utils/constants");
+const constants_2 = require("../../../../constants");
+const Utils_1 = require("./utils/Utils");
+class REST extends events_1.EventEmitter {
+    constructor(_instance, _manager, _product, options) {
+        super();
+        this.instance = _instance;
+        this.manager = _manager;
+        this.requestManager = new RequestManager_1.RequestManager(_instance, _product, options)
+            .on("restDebug" /* Debug */, this.emit.bind(this, "restDebug" /* Debug */))
+            .on("rateLimited" /* RateLimited */, this.emit.bind(this, "rateLimited" /* RateLimited */))
+            .on("invalidRequestWarning" /* InvalidRequestWarning */, this.emit.bind(this, "invalidRequestWarning" /* InvalidRequestWarning */));
+        this.on('newListener', (name, listener) => {
+            if (name === "request" /* Request */ || name === "response" /* Response */)
+                this.requestManager.on(name, listener);
+        });
+        this.on('removeListener', (name, listener) => {
+            if (name === "request" /* Request */ || name === "response" /* Response */)
+                this.requestManager.off(name, listener);
+        });
+    }
+    /**
+     * Runs a request from the api
+     * @param type API Type Enum
+     */
+    request(type, ...args) {
+        const apiType = constants_1.AllAPITypes.find((aT) => aT.type === type);
+        if (!apiType)
+            throw new Error('Invalid API Type given for request.');
+        let communityId;
+        let apiKey;
+        switch (apiType.product) {
+            case constants_2.productEnums.CAD: {
+                communityId = this.instance.cadCommunityId;
+                apiKey = this.instance.cadApiKey;
+                break;
+            }
+            case constants_2.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: ${(0, Utils_1.convertSubNumToName)(this.manager.version)} Needed Version: ${(0, Utils_1.convertSubNumToName)(apiType.minVersion)}`);
+        const formattedData = this.formatDataArguments(apiType.type, args);
+        const options = {
+            id: communityId,
+            key: apiKey,
+            type,
+            data: formattedData,
+            product: apiType.product
+        };
+        return this.requestManager.queueRequest(options);
+    }
+    formatDataArguments(type, args) {
+        switch (type) {
+            case 'VERIFY_WHITELIST': {
+                return {
+                    apiId: args[0],
+                    accId: constants_2.uuidRegex.test(args[1]) ? args[1] : undefined,
+                    serverId: args[2]
+                };
+            }
+            case 'FULL_WHITELIST': {
+                return {
+                    serverId: args[0]
+                };
+            }
+            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;
+            }
+        }
+    }
+}
+exports.REST = REST;

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

@@ -0,0 +1,58 @@
+/// <reference types="node" />
+import Collection from '@discordjs/collection';
+import { EventEmitter } from 'events';
+import type { Instance } from '../../../../instance/Instance';
+import { RESTOptions, RateLimitData, RestEvents } from './REST';
+import { productEnums } from '../../../../constants';
+import { IHandler } from './handlers/IHandler';
+export declare type RouteLike = `/${string}`;
+export declare const enum RequestMethod {
+    Delete = "delete",
+    Get = "get",
+    Patch = "patch",
+    Post = "post",
+    Put = "put"
+}
+export declare 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 declare class RequestManager extends EventEmitter {
+    readonly ratelimitedTypes: Collection<string, RateLimitData>;
+    readonly handlers: Collection<string, IHandler>;
+    readonly product: productEnums;
+    readonly options: RESTOptions;
+    private instance;
+    constructor(_instance: Instance, _product: productEnums, options: RESTOptions);
+    queueRequest(request: InternalRequestData): Promise<unknown>;
+    onRateLimit(id: string, rateLimitData: RateLimitData): void;
+    removeRateLimit(id: string): void;
+    private createHandler;
+    private static resolveRequestData;
+}

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

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestManager = void 0;
+const collection_1 = __importDefault(require("@discordjs/collection"));
+// import { DiscordSnowflake } from '@sapphire/snowflake';
+const events_1 = require("events");
+const constants_1 = require("./utils/constants");
+const constants_2 = require("../../../../constants");
+const SequentialHandler_1 = require("./handlers/SequentialHandler");
+const utils_1 = require("../../../../utils/utils");
+class RequestManager extends events_1.EventEmitter {
+    constructor(_instance, _product, options) {
+        super();
+        this.ratelimitedTypes = new collection_1.default();
+        this.handlers = new collection_1.default();
+        this.product = _product;
+        this.instance = _instance;
+        switch (_product) {
+            case constants_2.productEnums.CAD: {
+                this.options = { ...constants_1.DefaultCADRestOptions, ...options };
+                break;
+            }
+            case constants_2.productEnums.CMS: {
+                this.options = { ...constants_1.DefaultCMSRestOptions, ...options };
+                break;
+            }
+            default: {
+                throw new Error('No Product provided for RequestManager initialization');
+            }
+        }
+    }
+    async queueRequest(request) {
+        var _a;
+        let requestData = request;
+        const resolvedData = RequestManager.resolveRequestData(this.instance, request.type, request.product, requestData);
+        const handler = (_a = this.handlers.get(`${resolvedData.typePath}:${String(request.product)}`)) !== null && _a !== void 0 ? _a : this.createHandler(resolvedData);
+        return handler.queueRequest(resolvedData.fullUrl, resolvedData.fetchOptions, resolvedData);
+    }
+    onRateLimit(id, rateLimitData) {
+        this.ratelimitedTypes.set(id, rateLimitData);
+    }
+    removeRateLimit(id) {
+        this.ratelimitedTypes.delete(id);
+    }
+    createHandler(data) {
+        const queue = new SequentialHandler_1.SequentialHandler(this, data);
+        this.handlers.set(queue.id, queue);
+        return queue;
+    }
+    static resolveRequestData(instance, type, product, data) {
+        let apiURL = false;
+        let apiData = {
+            requestTypeId: `${type}:${String(product)}`,
+            typePath: '',
+            fullUrl: '',
+            method: '',
+            fetchOptions: {},
+            data,
+            product,
+            type
+        };
+        switch (product) {
+            case constants_2.productEnums.CAD:
+                apiURL = instance.cadApiUrl;
+                break;
+            case constants_2.productEnums.CMS:
+                apiURL = instance.cmsApiUrl;
+                break;
+        }
+        const findType = constants_1.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 = (0, utils_1.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;
+    }
+}
+exports.RequestManager = RequestManager;

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

@@ -0,0 +1,9 @@
+export declare class APIError extends Error {
+    response: string;
+    requestType: string;
+    requestUrl: string;
+    responseCode: number;
+    requestData: any;
+    constructor(response: string, requestType: string, requestUrl: string, responseCode: number, requestData: any);
+    get name(): string;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIError = void 0;
+class APIError extends Error {
+    constructor(response, requestType, requestUrl, responseCode, requestData) {
+        super(response);
+        this.response = response;
+        this.requestType = requestType;
+        this.requestUrl = requestUrl;
+        this.responseCode = responseCode;
+        this.requestData = requestData;
+    }
+    get name() {
+        return `Sonoran.js API Error - ${this.requestType} [${this.responseCode}]`;
+    }
+}
+exports.APIError = APIError;