@sonoransoftware/sonoran.js 1.0.6 → 1.0.8

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

@@ -110,6 +110,11 @@ class REST extends events_1.EventEmitter {
                     remove: args[3],
                 };
             }
+            case 'VERIFY_SECRET': {
+                return {
+                    secret: args[0],
+                };
+            }
             default: {
                 return args;
             }

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

@@ -87,6 +87,10 @@ class RequestManager extends events_1.EventEmitter {
                     break;
                 }
                 case 'SET_API_ID': {
+                    apiData.data.data = { secret: clonedData.data[0] };
+                    break;
+                }
+                case 'VERIFY_SECRET': {
                     apiData.data.data = clonedData.data;
                     break;
                 }

package/dist/managers/CADManager.d.ts

@@ -8,7 +8,9 @@ import { CADServerManager } from './CADServerManager';
  * Manages all Sonoran CAD data and methods to interact with the public API.
  */
 export declare class CADManager extends BaseManager {
+    readonly ready = false;
     readonly version: CADSubscriptionVersionEnum;
+    readonly failReason: unknown;
     rest: REST | undefined;
     servers: CADServerManager | undefined;
     constructor(instance: Instance);

package/dist/managers/CADManager.js

@@ -34,23 +34,28 @@ const CADServerManager_1 = require("./CADServerManager");
 class CADManager extends BaseManager_1.BaseManager {
     constructor(instance) {
         super(instance);
+        this.ready = false;
         this.version = 0;
+        this.failReason = null;
         this.rest = new src_1.REST(instance, this, globalTypes.productEnums.CAD, src_1.DefaultCADRestOptions);
         this.buildManager(instance);
     }
     async buildManager(instance) {
         var _a;
+        const mutableThis = this;
         try {
             const versionResp = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('GET_VERSION'));
-            const mutableThis = this;
             mutableThis.version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i, '$1'));
             if (this.version >= globalTypes.CADSubscriptionVersionEnum.STANDARD) {
                 this.servers = new CADServerManager_1.CADServerManager(instance, this);
             }
             instance.isCADSuccessful = true;
+            instance.emit('CAD_SETUP_SUCCESSFUL');
         }
         catch (err) {
-            console.log(err);
+            mutableThis.failReason = err;
+            instance.emit('CAD_SETUP_UNSUCCESSFUL', err);
+            throw err;
         }
     }
     /**

package/dist/managers/CMSManager.d.ts

@@ -10,6 +10,7 @@ import { CMSServerManager } from './CMSServerManager';
 export declare class CMSManager extends BaseManager {
     readonly ready: boolean;
     readonly version: CMSSubscriptionVersionEnum;
+    readonly failReason: unknown;
     rest: REST | undefined;
     servers: CMSServerManager | undefined;
     constructor(instance: Instance);

package/dist/managers/CMSManager.js

@@ -36,27 +36,26 @@ class CMSManager extends BaseManager_1.BaseManager {
         super(instance);
         this.ready = false;
         this.version = 0;
+        this.failReason = null;
         this.rest = new src_1.REST(instance, this, globalTypes.productEnums.CMS, src_1.DefaultCMSRestOptions);
         this.buildManager(instance);
     }
     async buildManager(instance) {
         var _a;
+        const mutableThis = this;
         try {
             const versionResp = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('GET_SUB_VERSION'));
             const version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i, '$1'));
-            const mutableThis = this;
             if (version >= globalTypes.CMSSubscriptionVersionEnum.STANDARD) {
                 this.servers = new CMSServerManager_1.CMSServerManager(instance, this);
             }
             mutableThis.ready = true;
             mutableThis.version = version;
-            console.log(mutableThis.version);
-            console.log(this.version);
-            console.log(version);
             instance.isCMSSuccessful = true;
             instance.emit('CMS_SETUP_SUCCESSFUL');
         }
         catch (err) {
+            mutableThis.failReason = err;
             instance.emit('CMS_SETUP_UNSUCCESSFUL', err);
             throw err;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sonoransoftware/sonoran.js",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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/REST.ts

@@ -215,6 +215,11 @@ export class REST extends EventEmitter {
 					remove: args[3],
 				};
 			}
+			case 'VERIFY_SECRET': {
+				return {
+					secret: args[0],
+				};
+			}
 			default: {
 				return args;
 			}

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

@@ -1,256 +1,260 @@
-import Collection from '@discordjs/collection';
-// import { DiscordSnowflake } from '@sapphire/snowflake';
-import { EventEmitter } from '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;
-  }
+import Collection from '@discordjs/collection';
+// import { DiscordSnowflake } from '@sapphire/snowflake';
+import { EventEmitter } from '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 = { secret: clonedData.data[0] };
+          break;
+        }
+        case 'VERIFY_SECRET': {
+          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/managers/CADManager.ts

@@ -1,59 +1,64 @@
-import { Instance } from '../instance/Instance';
-import { CADSubscriptionVersionEnum } from '../constants';
-import { APIError, DefaultCADRestOptions, REST } from '../libs/rest/src';
-import { BaseManager } from './BaseManager';
-import * as globalTypes from '../constants';
-import type { Mutable } from '../constants';
-import { CADServerManager } from './CADServerManager';
-
-/**
- * Manages all Sonoran CAD data and methods to interact with the public API.
- */
-export class CADManager extends BaseManager {
-  public readonly version: CADSubscriptionVersionEnum = 0;
-  public rest: REST | undefined;
-  public servers: CADServerManager | undefined;
-
-  constructor(instance: Instance) {
-    super(instance);
-
-    this.rest = new REST(instance, this, globalTypes.productEnums.CAD, DefaultCADRestOptions);
-    this.buildManager(instance);
-  }
-
-  protected async buildManager(instance: Instance) {
-    try {
-      const versionResp: any = await this.rest?.request('GET_VERSION');
-      const mutableThis = this as Mutable<CADManager>;
-      mutableThis.version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i,'$1'));
-      if (this.version >= globalTypes.CADSubscriptionVersionEnum.STANDARD) {
-        this.servers = new CADServerManager(instance, this);
-      }
-      instance.isCADSuccessful = true;
-    } catch (err) {
-      console.log(err);
-    }
-  }
-
-  /**
-   * Gets a community account by `accId` or `apiId`.
-   * @param {Object} params The object that contains parameters to get a community account.
-   * @param {string} [data.accId] The account id to find a community account.
-   * @param {string} [data.apiId] The api id to find a community account.
-   * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
-   */
-  public async getAccount(params: { apiId?: string, username?: string }): Promise<globalTypes.CADGetAccountPromiseResult> {
-    return new Promise(async (resolve, reject) => {
-      try {
-        const getAccountRequest: any = await this.rest?.request('GET_ACCOUNT', params.apiId, params.username);
-        resolve({ success: true, data: getAccountRequest });
-      } catch (err) {
-        if (err instanceof APIError) {
-          resolve({ success: false, reason: err.response });
-        } else {
-          reject(err);
-        }
-      }
-    });
-  }
+import { Instance } from '../instance/Instance';
+import { CADSubscriptionVersionEnum } from '../constants';
+import { APIError, DefaultCADRestOptions, REST } from '../libs/rest/src';
+import { BaseManager } from './BaseManager';
+import * as globalTypes from '../constants';
+import type { Mutable } from '../constants';
+import { CADServerManager } from './CADServerManager';
+
+/**
+ * Manages all Sonoran CAD data and methods to interact with the public API.
+ */
+export class CADManager extends BaseManager {
+  public readonly ready = false;
+  public readonly version: CADSubscriptionVersionEnum = 0;
+  public readonly failReason: unknown = null;
+  public rest: REST | undefined;
+  public servers: CADServerManager | undefined;
+
+  constructor(instance: Instance) {
+    super(instance);
+
+    this.rest = new REST(instance, this, globalTypes.productEnums.CAD, DefaultCADRestOptions);
+    this.buildManager(instance);
+  }
+
+  protected async buildManager(instance: Instance) {
+    const mutableThis = this as Mutable<CADManager>;
+    try {
+      const versionResp: any = await this.rest?.request('GET_VERSION');
+      mutableThis.version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i,'$1'));
+      if (this.version >= globalTypes.CADSubscriptionVersionEnum.STANDARD) {
+        this.servers = new CADServerManager(instance, this);
+      }
+      instance.isCADSuccessful = true;
+      instance.emit('CAD_SETUP_SUCCESSFUL');
+    } catch (err) {
+      mutableThis.failReason = err;
+      instance.emit('CAD_SETUP_UNSUCCESSFUL', err);
+      throw err;
+    }
+  }
+
+  /**
+   * Gets a community account by `accId` or `apiId`.
+   * @param {Object} params The object that contains parameters to get a community account.
+   * @param {string} [data.accId] The account id to find a community account.
+   * @param {string} [data.apiId] The api id to find a community account.
+   * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+   */
+  public async getAccount(params: { apiId?: string, username?: string }): Promise<globalTypes.CADGetAccountPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const getAccountRequest: any = await this.rest?.request('GET_ACCOUNT', params.apiId, params.username);
+        resolve({ success: true, data: getAccountRequest });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
 }

package/src/managers/CMSManager.ts

@@ -11,6 +11,7 @@ import { CMSServerManager } from './CMSServerManager';
 export class CMSManager extends BaseManager {
   public readonly ready: boolean = false;
   public readonly version: CMSSubscriptionVersionEnum = 0;
+  public readonly failReason: unknown = null;
   public rest: REST | undefined;
   public servers: CMSServerManager | undefined;
 
@@ -22,21 +23,19 @@ export class CMSManager extends BaseManager {
   }
 
   protected async buildManager(instance: Instance) {
+    const mutableThis = this as globalTypes.Mutable<CMSManager>;
     try {
       const versionResp: any = await this.rest?.request('GET_SUB_VERSION');
       const version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i,'$1'));
-      const mutableThis = this as globalTypes.Mutable<CMSManager>;
       if (version >= globalTypes.CMSSubscriptionVersionEnum.STANDARD) {
         this.servers = new CMSServerManager(instance, this);
       }
       mutableThis.ready = true;
       mutableThis.version = version;
-      console.log(mutableThis.version);
-      console.log(this.version);
-      console.log(version);
       instance.isCMSSuccessful = true;
       instance.emit('CMS_SETUP_SUCCESSFUL');
     } catch (err) {
+      mutableThis.failReason = err;
       instance.emit('CMS_SETUP_UNSUCCESSFUL', err);
       throw err;
     }