@sonoransoftware/sonoran.js 1.0.34 → 1.0.35

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

@@ -14,6 +14,7 @@ import type { RequestInit, Response } from 'node-fetch';
 import { Instance } from '../../../../instance/Instance';
 import { CADManager } from '../../../../managers/CADManager';
 import { CMSManager } from '../../../../managers/CMSManager';
+import { RadioManager } from '../../../../managers/RadioManager';
 
 /**
  * Options to be passed when creating the REST instance
@@ -106,7 +107,7 @@ export interface REST {
 		(<S extends string | symbol>(event?: Exclude<S, keyof RestEvents>) => this);
 }
 
-export type RestManagerTypes = CADManager | CMSManager;
+export type RestManagerTypes = CADManager | CMSManager | RadioManager;
 
 export class REST extends EventEmitter {
 	public readonly requestManager: RequestManager;
@@ -150,6 +151,11 @@ export class REST extends EventEmitter {
 				apiKey = this.instance.cmsApiKey;
 				break;
 			}
+			case productEnums.RADIO: {
+				communityId = this.instance.radioCommunityId;
+				apiKey = this.instance.radioApiKey;
+				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)}`);  // Verifies API Subscription Level Requirement which is deprecated currently
@@ -179,6 +185,9 @@ export class REST extends EventEmitter {
 					serverId: args[0]
 				}
 			}
+			case 'SET_GAME_SERVERS': {
+				return args[0] ?? [];
+			}
 			case 'RSVP': {
 				return {
 					eventId: args[0],
@@ -206,6 +215,62 @@ export class REST extends EventEmitter {
 					uniqueId: args[4]
 				};
 			}
+			case 'GET_CURRENT_CLOCK_IN': {
+				return {
+					apiId: args[0],
+					username: args[1],
+					accId: args[2],
+					discord: args[3],
+					uniqueId: args[4]
+				};
+			}
+			case 'GET_ACCOUNTS': {
+				return args[0] ?? {};
+			}
+			case 'GET_PROFILE_FIELDS': {
+				return {};
+			}
+			case 'SET_CLOCK': {
+				if (args[0] && typeof args[0] === 'object' && !Array.isArray(args[0])) {
+					return args[0];
+				}
+				return {
+					serverId: args[0],
+					currentUtc: args[1],
+					currentGame: args[2],
+					secondsPerHour: args[3]
+				};
+			}
+			case 'JOIN_COMMUNITY':
+			case 'LEAVE_COMMUNITY': {
+				const payload = args[0] && typeof args[0] === 'object' && !Array.isArray(args[0]) && 'internalKey' in args[0]
+					? args[0]
+					: null;
+				const internalKey = payload ? payload.internalKey : args[0];
+				const accountsInput = payload ? payload.accounts : args[1];
+				let accounts: Array<{ account: string }> = [];
+				if (Array.isArray(accountsInput)) {
+					accounts = accountsInput.map((entry) => {
+						if (typeof entry === 'string') {
+							return { account: entry };
+						}
+						if (entry && typeof entry === 'object' && 'account' in entry) {
+							return entry as { account: string };
+						}
+						return { account: String(entry) };
+					});
+				} else if (accountsInput) {
+					if (typeof accountsInput === 'string') {
+						accounts = [{ account: accountsInput }];
+					} else if (typeof accountsInput === 'object' && 'account' in accountsInput) {
+						accounts = [accountsInput as { account: string }];
+					}
+				}
+				return {
+					internalKey,
+					accounts
+				};
+			}
 			case 'CLOCK_IN_OUT': {
 				return {
 					apiId: args[0],
@@ -237,6 +302,13 @@ export class REST extends EventEmitter {
 					secret: args[0],
 				};
 			}
+			case 'GET_FORM_TEMPLATE_SUBMISSIONS': {
+				return {
+					templateId: args[0],
+					skip: args[1],
+					take: args[2],
+				};
+			}
 			case 'CHANGE_FORM_STAGE': {
 				return {
 					accId: args[0],
@@ -322,6 +394,40 @@ export class REST extends EventEmitter {
 					points: args[6],
 				}
 			}
+			case 'RADIO_GET_COMMUNITY_CHANNELS':
+			case 'RADIO_GET_CONNECTED_USERS':
+			case 'RADIO_GET_SERVER_SUBSCRIPTION_FROM_IP': {
+				return undefined;
+			}
+			case 'RADIO_GET_CONNECTED_USER': {
+				return {
+					roomId: args[0],
+					identity: args[1]
+				}
+			}
+			case 'RADIO_SET_USER_CHANNELS': {
+				return {
+					identity: args[0],
+					options: args[1] ?? {}
+				}
+			}
+			case 'RADIO_SET_USER_DISPLAY_NAME': {
+				return {
+					accId: args[0],
+					displayName: args[1]
+				}
+			}
+			case 'RADIO_SET_SERVER_IP': {
+				return {
+					pushUrl: args[0]
+				}
+			}
+			case 'RADIO_SET_IN_GAME_SPEAKER_LOCATIONS': {
+				return {
+					locations: args[0],
+					token: args[1]
+				}
+			}
 			default: {
 				return args;
 			}

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

@@ -5,7 +5,8 @@ import { EventEmitter } from 'events';
 
 import type { Instance } from '../../../../instance/Instance';
 import { RESTOptions, RateLimitData, RestEvents } from './REST';
-import { DefaultCADRestOptions, DefaultCMSRestOptions, AllAPITypes/**, RESTTypedAPIDataStructs, PossibleRequestData*/ } from './utils/constants';
+import { DefaultCADRestOptions, DefaultCMSRestOptions, DefaultRadioRestOptions, AllAPITypes/**, RESTTypedAPIDataStructs, PossibleRequestData*/ } from './utils/constants';
+import type { AllAPITypeData } from './utils/constants';
 import { productEnums } from '../../../../constants';
 // import { APIError, HTTPError } from './errors';
 import { IHandler } from './handlers/IHandler';
@@ -29,6 +30,7 @@ export interface RequestData {
   key: string;
   type: string;
   data: any;
+  internalKey?: string;
 }
 
 export interface InternalRequestData extends RequestData {
@@ -87,6 +89,10 @@ export class RequestManager extends EventEmitter {
         this.options = { ...DefaultCMSRestOptions, ...options };
         break;
       }
+      case productEnums.RADIO: {
+        this.options = { ...DefaultRadioRestOptions, ...options };
+        break;
+      }
       default: {
         throw new Error('No Product provided for RequestManager initialization');
       }
@@ -134,10 +140,16 @@ export class RequestManager extends EventEmitter {
       case productEnums.CMS:
         apiURL = instance.cmsApiUrl;
         break;
+      case productEnums.RADIO:
+        apiURL = instance.radioApiUrl;
+        break;
     }
 
     const findType = AllAPITypes.find((_type) => _type.type === type);
     if (findType) {
+      if (product === productEnums.RADIO) {
+        return RequestManager.resolveRadioRequest(instance, apiURL, findType, data, apiData);
+      }
       apiData.fullUrl = `${apiURL}/${findType.path}`;
       apiData.method = findType.method;
       apiData.fetchOptions.method = findType.method;
@@ -150,6 +162,10 @@ export class RequestManager extends EventEmitter {
           apiData.data.data = clonedData;
           break;
         }
+        case 'SET_GAME_SERVERS': {
+          apiData.data.data = clonedData;
+          break;
+        }
         case 'SET_PENAL_CODES': {
           apiData.data.data = [clonedData[0]];
           break;
@@ -186,14 +202,37 @@ export class RequestManager extends EventEmitter {
           apiData.data.data = clonedData;
           break;
         }
-        case 'SET_POSTALS': {
-          apiData.data.data = [clonedData[0]];
-          break;
-        }
-        case 'NEW_CHARACTER': {
-          apiData.data.data = [clonedData[0]];
-          break;
-        }
+		case 'SET_POSTALS': {
+		  apiData.data.data = [clonedData[0]];
+		  break;
+		}
+		case 'SET_CLOCK': {
+		  apiData.data.data = Array.isArray(clonedData) ? clonedData : [clonedData];
+		  break;
+		}
+		case 'JOIN_COMMUNITY':
+		case 'LEAVE_COMMUNITY': {
+		  const internalKey = clonedData?.internalKey;
+		  if (internalKey !== undefined) {
+		    apiData.data.internalKey = internalKey;
+		  }
+		  const accountsSource = clonedData?.accounts;
+		  const accountsArray = Array.isArray(accountsSource) ? accountsSource : accountsSource ? [accountsSource] : [];
+		  apiData.data.data = accountsArray.map((entry: any) => {
+		    if (typeof entry === 'string') {
+		      return { account: entry };
+		    }
+		    if (entry && typeof entry === 'object' && 'account' in entry) {
+		      return entry;
+		    }
+		    return { account: String(entry) };
+		  });
+		  break;
+		}
+		case 'NEW_CHARACTER': {
+		  apiData.data.data = [clonedData[0]];
+		  break;
+		}
         case 'EDIT_CHARACTER': {
           apiData.data.data = [clonedData[0]];
           break;
@@ -255,7 +294,179 @@ export class RequestManager extends EventEmitter {
     return apiData;
   }
 
+  private static resolveRadioRequest(instance: Instance, apiURL: string | boolean, apiType: AllAPITypeData, request: RequestData, apiData: APIData): APIData {
+    if (!apiURL || typeof apiURL !== 'string') {
+      throw new Error('Radio API URL could not be resolved for request.');
+    }
+
+    const rawData = request.data;
+    const payload: any =
+      rawData == null ? {} : (typeof rawData === 'object' ? cloneObject(rawData) : rawData);
+    const headers: Record<string, string> = {
+      Accept: 'application/json'
+    };
+
+    const applyHeaders = (source: unknown) => {
+      if (!source) return;
+      if (Array.isArray(source)) {
+        for (const [key, value] of source) {
+          headers[key] = value;
+        }
+        return;
+      }
+      if (typeof source === 'object' && source !== null && 'forEach' in source && typeof (source as any).forEach === 'function') {
+        (source as any).forEach((value: string, key: string) => {
+          headers[key] = value;
+        });
+        return;
+      }
+      Object.assign(headers, source as Record<string, string>);
+    };
+
+    applyHeaders(instance.apiHeaders);
+
+    let method = apiType.method;
+    let path = apiType.path;
+    let body: unknown;
+
+    const ensureAuth = () => {
+      if (!request.id || !request.key) {
+        throw new Error('Community ID or API Key could not be found for request.');
+      }
+      return {
+        id: request.id,
+        key: request.key,
+        encodedId: encodeURIComponent(request.id),
+        encodedKey: encodeURIComponent(request.key)
+      };
+    };
+
+    const encodeSegment = (value: string | number) => encodeURIComponent(String(value));
+
+    switch (apiType.type) {
+      case 'RADIO_GET_COMMUNITY_CHANNELS': {
+        const auth = ensureAuth();
+        path = `${apiType.path}/${auth.encodedId}/${auth.encodedKey}`;
+        method = 'GET';
+        break;
+      }
+      case 'RADIO_GET_CONNECTED_USERS': {
+        const auth = ensureAuth();
+        path = `${apiType.path}/${auth.encodedId}/${auth.encodedKey}`;
+        method = 'GET';
+        break;
+      }
+      case 'RADIO_GET_CONNECTED_USER': {
+        const auth = ensureAuth();
+        const roomIdRaw = payload?.roomId ?? payload?.roomID;
+        if (roomIdRaw === undefined) {
+          throw new Error('roomId is required for RADIO_GET_CONNECTED_USER requests.');
+        }
+        const roomIdNumeric = typeof roomIdRaw === 'number' ? roomIdRaw : Number(roomIdRaw);
+        if (Number.isNaN(roomIdNumeric)) {
+          throw new Error('roomId must be a number for RADIO_GET_CONNECTED_USER requests.');
+        }
+        const identity = payload?.identity;
+        if (!identity) {
+          throw new Error('identity is required for RADIO_GET_CONNECTED_USER requests.');
+        }
+        path = `${apiType.path}/${auth.encodedId}/${auth.encodedKey}/${encodeSegment(roomIdNumeric)}/${encodeSegment(identity)}`;
+        method = 'GET';
+        break;
+      }
+      case 'RADIO_SET_USER_CHANNELS': {
+        const auth = ensureAuth();
+        const identity = payload?.identity;
+        if (!identity) {
+          throw new Error('identity is required for RADIO_SET_USER_CHANNELS requests.');
+        }
+        const options = payload?.options ?? {};
+        path = `${apiType.path}/${auth.encodedId}/${auth.encodedKey}/${encodeSegment(identity)}`;
+        method = 'POST';
+        const requestBody: Record<string, unknown> = {};
+        if (options?.transmit !== undefined) {
+          requestBody.transmit = options.transmit;
+        }
+        if (options?.scan !== undefined) {
+          requestBody.scan = options.scan;
+        }
+        body = requestBody;
+        break;
+      }
+      case 'RADIO_SET_USER_DISPLAY_NAME': {
+        const auth = ensureAuth();
+        const accId = payload?.accId;
+        const displayName = payload?.displayName;
+        if (!accId || !displayName) {
+          throw new Error('accId and displayName are required for RADIO_SET_USER_DISPLAY_NAME requests.');
+        }
+        method = 'POST';
+        body = {
+          id: auth.id,
+          key: auth.key,
+          accId,
+          displayName
+        };
+        path = apiType.path;
+        break;
+      }
+      case 'RADIO_GET_SERVER_SUBSCRIPTION_FROM_IP': {
+        method = 'GET';
+        path = apiType.path;
+        break;
+      }
+      case 'RADIO_SET_SERVER_IP': {
+        const auth = ensureAuth();
+        const pushUrl = payload?.pushUrl;
+        if (!pushUrl) {
+          throw new Error('pushUrl is required for RADIO_SET_SERVER_IP requests.');
+        }
+        method = 'POST';
+        body = {
+          id: auth.id,
+          key: auth.key,
+          pushUrl
+        };
+        path = apiType.path;
+        break;
+      }
+      case 'RADIO_SET_IN_GAME_SPEAKER_LOCATIONS': {
+        const auth = ensureAuth();
+        const locations = payload?.locations;
+        if (!Array.isArray(locations)) {
+          throw new Error('locations array is required for RADIO_SET_IN_GAME_SPEAKER_LOCATIONS requests.');
+        }
+        method = 'POST';
+        body = {
+          id: auth.id,
+          key: auth.key,
+          locations
+        };
+        const token = payload?.token ?? auth.key;
+        if (token) {
+          headers.Authorization = `Bearer ${token}`;
+        }
+        path = apiType.path;
+        break;
+      }
+      default: {
+        throw new Error(`Unsupported radio API type received: ${apiType.type}`);
+      }
+    }
+
+    apiData.typePath = path;
+    apiData.fullUrl = `${apiURL}/${path}`;
+    apiData.method = method;
+    apiData.fetchOptions.method = method;
+    if (body !== undefined) {
+      headers['Content-Type'] = 'application/json';
+      apiData.fetchOptions.body = JSON.stringify(body);
+    }
+    apiData.fetchOptions.headers = headers;
+    return apiData;
+  }
+
   debug(log: string) {
     return this.instance._debugLog(log);
   }
-}
+}

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

@@ -16,6 +16,24 @@ export class RateLimitError extends Error implements RateLimitData {
 	 * 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}']`;
+		let productName: string;
+		switch (this.product) {
+			case productEnums.CAD: {
+				productName = 'Sonoran CAD';
+				break;
+			}
+			case productEnums.CMS: {
+				productName = 'Sonoran CMS';
+				break;
+			}
+			case productEnums.RADIO: {
+				productName = 'Sonoran Radio';
+				break;
+			}
+			default: {
+				productName = 'Invalid Product';
+			}
+		}
+		return `Ratelimit Hit - [${productName} '${this.type}']`;
 	}
-}
+}