@futdevpro/nts-dynamo 1.9.17 → 1.9.19

package/src/_services/socket/socket-server.service.ts

@@ -2,29 +2,29 @@
 import * as SocketIO from 'socket.io';
 
 import { 
-  DynamoFM_AnyError, DynamoFM_Array, DynamoFM_Error, DynamoFM_Error_Settings, DynamoFM_Log 
+  DyFM_AnyError, DyFM_Array, DyFM_Error, DyFM_Error_Settings, DyFM_Log 
 } from '@futdevpro/fsm-dynamo';
 
-import { DynamoNTS_SingletonService } from '../base/singleton.service';
-import { DynamoNTS_globalSettings } from '../../_constants/global-settings.const';
-import { DynamoNTS_SocketEventKey } from '../../_enums/http/socket-event-type.enum';
-import { DynamoNTS_SocketSecurity } from '../../_enums/socket-security.enum';
+import { DyNTS_SingletonService } from '../base/singleton.service';
+import { DyNTS_globalSettings } from '../../_constants/global-settings.const';
+import { DyNTS_SocketEventKey } from '../../_enums/http/socket-event-type.enum';
+import { DyNTS_SocketSecurity } from '../../_enums/socket-security.enum';
 import { 
-  DynamoNTS_SocketServerService_Params 
+  DyNTS_SocketServerService_Params 
 } from '../../_models/control-models/socket-server-service-params.control-model';
 import { 
-  DynamoNTS_SocketPresence 
+  DyNTS_SocketPresence 
 } from '../../_models/control-models/socket-presence.control-model';
 import { 
-  DynamoNTS_SocketEvent, DynamoNTS_SocketEventPreprocessTask, DynamoNTS_SocketEventTask 
+  DyNTS_SocketEvent, DyNTS_SocketEventPreprocessTask, DyNTS_SocketEventTask 
 } from '../../_models/control-models/socket-event.control-model';
 
 /**
  * You need to define the following functions:
  * ```ts
- * getServiceParams(): DynamoNTS_SocketServerServiceParams;
+ * getServiceParams(): DyNTS_SocketServerServiceParams;
  * 
- * getIncomingEvents(): DynamoNTS_SocketEvent<any>[];
+ * getIncomingEvents(): DyNTS_SocketEvent<any>[];
  * 
  * getPresenceFromSubscrioptionEventContent(  
  *  socketSubscription: T_SubscriptionContent,  
@@ -32,26 +32,26 @@ import {
  * ): Promise<T_Presence>;  
  * ```
  */
-export abstract class DynamoNTS_SocketServerService<
-      T_Presence extends DynamoNTS_SocketPresence = DynamoNTS_SocketPresence, 
+export abstract class DyNTS_SocketServerService<
+      T_Presence extends DyNTS_SocketPresence = DyNTS_SocketPresence, 
       T_SubscriptionContent = any, 
       T_ErrorContent = any
-    > extends DynamoNTS_SingletonService {
+    > extends DyNTS_SingletonService {
 
-  protected params: DynamoNTS_SocketServerService_Params;
+  protected params: DyNTS_SocketServerService_Params;
   get name(): string { return this.params.name; }
   get port(): number { return this.params.port; }
-  get security(): DynamoNTS_SocketSecurity { return this.params.security; }
+  get security(): DyNTS_SocketSecurity { return this.params.security; }
   get activeSubscriptionsCount(): number { return this.presences.length; }
 
   protected openSocketServer: SocketIO.Server;
   protected secureSocketServer: SocketIO.Server;
 
-  private connectEvent: DynamoNTS_SocketEvent<SocketIO.Socket>;
-  protected incomingEvents: DynamoNTS_SocketEvent<any>[];
+  private connectEvent: DyNTS_SocketEvent<SocketIO.Socket>;
+  protected incomingEvents: DyNTS_SocketEvent<any>[];
 
-  private subscriptionEvent: DynamoNTS_SocketEvent<any>;
-  private unsubscribeEvent: DynamoNTS_SocketEvent<any>;
+  private subscriptionEvent: DyNTS_SocketEvent<any>;
+  private unsubscribeEvent: DyNTS_SocketEvent<any>;
 
   /**
    * You need to setup a function that converts subscription event content to presence.
@@ -73,7 +73,7 @@ export abstract class DynamoNTS_SocketServerService<
     super();
 
     this.asyncConstructor().catch((error: any) => {
-      DynamoFM_Log.error(
+      DyFM_Log.error(
         `Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, 
         error
       );
@@ -82,7 +82,7 @@ export abstract class DynamoNTS_SocketServerService<
 
   private async asyncConstructor(): Promise<void> {
     try {
-      this.logSetup = DynamoNTS_globalSettings.logSetup;
+      this.logSetup = DyNTS_globalSettings.logSetup;
       this.params = this.getServiceParams();
       this.incomingEvents = this.getIncomingEvents() ?? [];
 
@@ -93,12 +93,12 @@ export abstract class DynamoNTS_SocketServerService<
         `serurity: ${this.params.security}\n`
       );
     } catch (error) {
-      DynamoFM_Log.error(
+      DyFM_Log.error(
         `Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, 
         error
       );
 
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         errorCode: 'NTS-SSS-001',
         error: error,        
       });
@@ -112,15 +112,15 @@ export abstract class DynamoNTS_SocketServerService<
     try {
       /** Setup connect event */
       const connectEventIndex = this.incomingEvents.findIndex(
-        (event: DynamoNTS_SocketEvent<any>) => 
-          event.eventKey === DynamoNTS_SocketEventKey.connection
+        (event: DyNTS_SocketEvent<any>) => 
+          event.eventKey === DyNTS_SocketEventKey.connection
       );
 
       if (0 <= connectEventIndex) {
         this.connectEvent = this.incomingEvents.splice(connectEventIndex)[0];
       } else {
-        this.connectEvent = new DynamoNTS_SocketEvent({
-          eventKey: DynamoNTS_SocketEventKey.connection,
+        this.connectEvent = new DyNTS_SocketEvent({
+          eventKey: DyNTS_SocketEventKey.connection,
         });
       }
       this.connectEvent.serviceName = this.params.name;
@@ -129,20 +129,20 @@ export abstract class DynamoNTS_SocketServerService<
       if (this.getPresenceFromSubscrioptionEventContent) {
         /** Setup subscription event */ 
         const subscriptionEventIndex = this.incomingEvents.findIndex(
-          (event: DynamoNTS_SocketEvent<any>) => 
-            event.eventKey === DynamoNTS_SocketEventKey.subscribe
+          (event: DyNTS_SocketEvent<any>) => 
+            event.eventKey === DyNTS_SocketEventKey.subscribe
         );
 
         if (0 <= subscriptionEventIndex) {
           this.subscriptionEvent = this.incomingEvents.splice(subscriptionEventIndex)[0];
-          DynamoFM_Log.error(
+          DyFM_Log.error(
             `You should not set the subscription event, but the subscriptions tasks, ` +
             `in case you need additional steps for your subscriptions.`,
             `${this.params.name} (${this.params.port})`
           );
         } else {
-          this.subscriptionEvent = new DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
-            eventKey: DynamoNTS_SocketEventKey.subscribe,
+          this.subscriptionEvent = new DyNTS_SocketEvent<T_SubscriptionContent>({ 
+            eventKey: DyNTS_SocketEventKey.subscribe,
           });
         }
 
@@ -157,20 +157,20 @@ export abstract class DynamoNTS_SocketServerService<
         
         /** Setup subscription event */ 
         const unsubscribeEventIndex = this.incomingEvents.findIndex(
-          (event: DynamoNTS_SocketEvent<any>) => 
-            event.eventKey === DynamoNTS_SocketEventKey.unsubscribe
+          (event: DyNTS_SocketEvent<any>) => 
+            event.eventKey === DyNTS_SocketEventKey.unsubscribe
         );
 
         if (0 <= unsubscribeEventIndex) {
           this.unsubscribeEvent = this.incomingEvents.splice(unsubscribeEventIndex)[0];
-          DynamoFM_Log.error(
+          DyFM_Log.error(
             `You should not set the unsubscribe event, but the unsubscribe tasks, ` +
             `in case you need additional steps for your unsubscribe.`,
             `${this.params.name} (${this.params.port})`
           );
         } else {
-          this.unsubscribeEvent = new DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
-            eventKey: DynamoNTS_SocketEventKey.unsubscribe,
+          this.unsubscribeEvent = new DyNTS_SocketEvent<T_SubscriptionContent>({ 
+            eventKey: DyNTS_SocketEventKey.unsubscribe,
           });
         }
 
@@ -185,8 +185,8 @@ export abstract class DynamoNTS_SocketServerService<
 
         /** Setup disconnect event */
         const disconnectEventIndex = this.incomingEvents.findIndex(
-          (event: DynamoNTS_SocketEvent<any>) => 
-            event.eventKey === DynamoNTS_SocketEventKey.disconnect
+          (event: DyNTS_SocketEvent<any>) => 
+            event.eventKey === DyNTS_SocketEventKey.disconnect
         );
 
         if (0 <= disconnectEventIndex) {
@@ -194,9 +194,9 @@ export abstract class DynamoNTS_SocketServerService<
           this.incomingEvents[disconnectEventIndex].tasks.push(this.disconnectBaseTask);
         } else {
           this.incomingEvents.push(
-            new DynamoNTS_SocketEvent({
+            new DyNTS_SocketEvent({
               serviceName: this.params.name,
-              eventKey: DynamoNTS_SocketEventKey.disconnect,
+              eventKey: DyNTS_SocketEventKey.disconnect,
               tasks: [
                 this.disconnectBaseTask,
               ],
@@ -206,13 +206,13 @@ export abstract class DynamoNTS_SocketServerService<
 
         /** Setup error event */
         const errorEventIndex = this.incomingEvents.findIndex(
-          (event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.error
+          (event: DyNTS_SocketEvent<any>) => event.eventKey === DyNTS_SocketEventKey.error
         );
 
         if (errorEventIndex == -1 && this.errorHandling) {
-          this.incomingEvents.push(new DynamoNTS_SocketEvent<T_ErrorContent>({
+          this.incomingEvents.push(new DyNTS_SocketEvent<T_ErrorContent>({
             serviceName: this.params.name,
-            eventKey: DynamoNTS_SocketEventKey.error,
+            eventKey: DyNTS_SocketEventKey.error,
             tasks: [
               this.errorHandling,
             ],
@@ -221,18 +221,18 @@ export abstract class DynamoNTS_SocketServerService<
 
         this.subscriptionEvent.socketName = this.params.name;
       } else {
-        DynamoFM_Log.error(
+        DyFM_Log.error(
           'getPresenceFromSubscrioptionEventContent is not set', 
           `${this.params.name} (${this.params.port})`
         );
       }
 
       /** Set incoming events serviceName */
-      this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
+      this.incomingEvents.forEach((event: DyNTS_SocketEvent<any>) => {
         event.serviceName = this.params.name;
       });
     } catch (error) {
-      DynamoFM_Log.error(
+      DyFM_Log.error(
         `Socket Server Service - Event Preparation setup failed: ` +
         `${this.params?.name} (${this.params?.port})`, 
         error
@@ -245,13 +245,13 @@ export abstract class DynamoNTS_SocketServerService<
   // eslint-disable-next-line max-lines-per-function
   async setupSocketServer(
     newSocketServer: SocketIO.Server, 
-    security: DynamoNTS_SocketSecurity.open | DynamoNTS_SocketSecurity.secure, 
+    security: DyNTS_SocketSecurity.open | DyNTS_SocketSecurity.secure, 
     successCallback: () => void
   ): Promise<SocketIO.Server> {
     try {
       if (this.logFn) console.log('\nfn:. setupSocketServer');
 
-      newSocketServer.on(DynamoNTS_SocketEventKey.connection, async (socket: SocketIO.Socket) => {
+      newSocketServer.on(DyNTS_SocketEventKey.connection, async (socket: SocketIO.Socket) => {
         try {
           let issuer: string;
 
@@ -259,7 +259,7 @@ export abstract class DynamoNTS_SocketServerService<
 
           if (this.getPresenceFromSubscrioptionEventContent) {
             socket.on(
-              DynamoNTS_SocketEventKey.subscribe, 
+              DyNTS_SocketEventKey.subscribe, 
               async (content: any) => {
                 try {
                   /** 
@@ -267,16 +267,16 @@ export abstract class DynamoNTS_SocketServerService<
                    * but subscribe event is an exception from this, 
                    * to be able to check content before getPresenceFromSubscrioptionEventContent 
                    */
-                  if (DynamoNTS_globalSettings.logSocketEventContent) {
-                    DynamoFM_Log.log(
+                  if (DyNTS_globalSettings.logSocketEventContent) {
+                    DyFM_Log.log(
                       `--=>   incoming socket(${this.params.name}) ` +
-                      `event: ${DynamoNTS_SocketEventKey.subscribe};` +
+                      `event: ${DyNTS_SocketEventKey.subscribe};` +
                       `\ncontent:`, content
                     );
                   } else {
-                    DynamoFM_Log.log(
+                    DyFM_Log.log(
                       `--=>   incoming socket(${this.params.name}) ` +
-                      `event: ${DynamoNTS_SocketEventKey.subscribe}`
+                      `event: ${DyNTS_SocketEventKey.subscribe}`
                     );
                   }
 
@@ -291,33 +291,33 @@ export abstract class DynamoNTS_SocketServerService<
                   await this.subscriptionEvent.executeEventTasks(content, issuer);
 
                   socket.emit(
-                    DynamoNTS_SocketEventKey.subscriptionSuccessful, 
+                    DyNTS_SocketEventKey.subscriptionSuccessful, 
                     'subscribe was successful', 
                     error => {
-                      DynamoFM_Log.error(
+                      DyFM_Log.error(
                         `Emitting subscriptionSuccessful event failed!` +
                         `\nerror:`, error
                       );
                     }
                   );
                   
-                  DynamoFM_Log.success(
+                  DyFM_Log.success(
                     `<-==>  socket(${this.params.name}) subscription successfull (${issuer})`
                   );
                 } catch (error) {
-                  DynamoFM_Log.error(
+                  DyFM_Log.error(
                     `Socket Subscription failed: ${this.params.name} ` ,
                     `(${this.params.port}) will disconnect now...`, 
                     error
                   );
-                  socket.emit(DynamoNTS_SocketEventKey.error, error);
+                  socket.emit(DyNTS_SocketEventKey.error, error);
                   socket.disconnect();
                 }
               }
             );
             
             socket.on(
-              DynamoNTS_SocketEventKey.unsubscribe, 
+              DyNTS_SocketEventKey.unsubscribe, 
               async (issuer: string) => {
                 try {
                   /** 
@@ -325,16 +325,16 @@ export abstract class DynamoNTS_SocketServerService<
                    * but unsubscribe event is an exception from this, 
                    * to be able to check content before getPresenceFromSubscrioptionEventContent 
                    */
-                  if (DynamoNTS_globalSettings.logSocketEventContent) {
-                    DynamoFM_Log.log(
+                  if (DyNTS_globalSettings.logSocketEventContent) {
+                    DyFM_Log.log(
                       `--=>   incoming socket(${this.params.name}) ` +
-                      `event: ${DynamoNTS_SocketEventKey.unsubscribe};` +
+                      `event: ${DyNTS_SocketEventKey.unsubscribe};` +
                       `\ncontent:`, issuer
                     );
                   } else {
-                    DynamoFM_Log.log(
+                    DyFM_Log.log(
                       `--=>   incoming socket(${this.params.name}) ` +
-                      `event: ${DynamoNTS_SocketEventKey.unsubscribe}`
+                      `event: ${DyNTS_SocketEventKey.unsubscribe}`
                     );
                   }
                   
@@ -343,72 +343,72 @@ export abstract class DynamoNTS_SocketServerService<
                   await this.subscriptionEvent.executeEventTasks(issuer, issuer);
 
                   socket.emit(
-                    DynamoNTS_SocketEventKey.unsubscribeSuccessful, 
+                    DyNTS_SocketEventKey.unsubscribeSuccessful, 
                     'unsubscribe was successful', 
                     error => {
-                      DynamoFM_Log.error(
+                      DyFM_Log.error(
                         `Emitting unsubscribeSuccessful event failed!` +
                         `\nerror:`, error
                       );
                     }
                   );
                   
-                  DynamoFM_Log.success(
+                  DyFM_Log.success(
                     `< x >  socket(${this.params.name}) unsubscribe successfull (${issuer})`
                   );
                 } catch (error) {
-                  DynamoFM_Log.error(
+                  DyFM_Log.error(
                     `Socket unsubscribe failed: ${this.params.name} ` ,
                     `(${this.params.port}) will disconnect now...`, 
                     error
                   );
-                  socket.emit(DynamoNTS_SocketEventKey.error, error);
+                  socket.emit(DyNTS_SocketEventKey.error, error);
                 }
               }
             );
           }
 
-          this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
+          this.incomingEvents.forEach((event: DyNTS_SocketEvent<any>) => {
             socket.on(
               event.eventKey, 
               async (content: any) => { 
                 try {
                   await event.executeEventTasks(content, issuer);
                 } catch (error) {
-                  DynamoFM_Log.error(
+                  DyFM_Log.error(
                     `Socket Event failed: ${this.params.name} (${this.params.port})`, 
                     error
                   );
-                  socket.emit(DynamoNTS_SocketEventKey.error, error);
+                  socket.emit(DyNTS_SocketEventKey.error, error);
                 }
               }
             );
           });
 
-          if (DynamoNTS_globalSettings.logMainSocketEvents) {
-            DynamoFM_Log.success(`<   >  socket(${this.params.name}): new CONNECTION established`);
+          if (DyNTS_globalSettings.logMainSocketEvents) {
+            DyFM_Log.success(`<   >  socket(${this.params.name}): new CONNECTION established`);
           }
         } catch (error) {
-          DynamoFM_Log.error(
+          DyFM_Log.error(
             `Socket Connection failed: ${this.params.name} ` +
             `(${this.params.port}) will disconnect now...`, 
             error
           );
-          socket.emit(DynamoNTS_SocketEventKey.error, error);
+          socket.emit(DyNTS_SocketEventKey.error, error);
           socket.disconnect();
         }
       });
         
       newSocketServer.listen(this.params.port);
       
-      DynamoFM_Log.success(
+      DyFM_Log.success(
         `\nsocket server setup finished: ${this.params.name}` + 
         `\nsocket server listening on port: ${this.params.port}`
       );
 
       successCallback();
       
-      if (security === DynamoNTS_SocketSecurity.open) {
+      if (security === DyNTS_SocketSecurity.open) {
         this.openSocketServer = newSocketServer;
 
         return this.openSocketServer;
@@ -418,7 +418,7 @@ export abstract class DynamoNTS_SocketServerService<
         return this.secureSocketServer;
       }
     } catch (error) {
-      DynamoFM_Log.error(
+      DyFM_Log.error(
         `Socket Server Service - Deep Setup failed: ${this.params?.name} ` +
         `(${this.params?.port})`, 
         error
@@ -440,7 +440,7 @@ export abstract class DynamoNTS_SocketServerService<
         this.presences.push(newPresence);
       }
     } catch (error) {
-      DynamoFM_Log.error(
+      DyFM_Log.error(
         `Socket Subscription failed: ${this.params?.name} (${this.params?.port})`, 
         error
       );
@@ -453,9 +453,9 @@ export abstract class DynamoNTS_SocketServerService<
     try {
       await this.removeSubscription(socket, issuer);
 
-      DynamoFM_Log.info(`< x >  socket(${this.params.name}) disconnected (${issuer})`);
+      DyFM_Log.info(`< x >  socket(${this.params.name}) disconnected (${issuer})`);
     } catch (error) {
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           'disconnectBaseTask',
           error,
@@ -470,11 +470,11 @@ export abstract class DynamoNTS_SocketServerService<
   private async removeSubscription(socket: SocketIO.Socket, issuer?: string): Promise<void> {
     try {
       const activePresenceIndex: number = this.presences.findIndex(
-        (pres: DynamoNTS_SocketPresence) => pres.sockets.includes(socket)
+        (pres: DyNTS_SocketPresence) => pres.sockets.includes(socket)
       );
       
       if (activePresenceIndex === -1) {
-        throw new DynamoFM_Error({
+        throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
             'sendEventForId', 
             new Error(
@@ -487,10 +487,10 @@ export abstract class DynamoNTS_SocketServerService<
         });
       }
 
-      const activePresence: DynamoNTS_SocketPresence = this.presences[activePresenceIndex];
+      const activePresence: DyNTS_SocketPresence = this.presences[activePresenceIndex];
 
       if (activePresence.issuerId !== issuer) {
-        throw new DynamoFM_Error({
+        throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
             'sendEventForId',
             new Error(
@@ -506,7 +506,7 @@ export abstract class DynamoNTS_SocketServerService<
       const socketIndex = activePresence.sockets.findIndex((s: SocketIO.Socket) => s === socket);
 
       if (socketIndex === -1) {
-        throw new DynamoFM_Error({
+        throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
             'sendEventForId',
             new Error(
@@ -522,9 +522,9 @@ export abstract class DynamoNTS_SocketServerService<
       activePresence.sockets.splice(socketIndex);
 
       if (this.getSubscriptionCloseTasks) {
-        await DynamoFM_Array.asyncForEach(
+        await DyFM_Array.asyncForEach(
           this.getSubscriptionCloseTasks(), 
-          async (task: DynamoNTS_SocketEventTask<null>) => {
+          async (task: DyNTS_SocketEventTask<null>) => {
             await task(null, issuer);
           }
         );
@@ -535,9 +535,9 @@ export abstract class DynamoNTS_SocketServerService<
       }
 
       socket.disconnect();
-      DynamoFM_Log.info(`<x==>  socket(${this.params.name}) unsubscription successfull (${issuer})`);
+      DyFM_Log.info(`<x==>  socket(${this.params.name}) unsubscription successfull (${issuer})`);
     } catch (error) {
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           'sendEventForId',
           error,
@@ -552,13 +552,13 @@ export abstract class DynamoNTS_SocketServerService<
 
   /* emitServerEvent(event: string, content: any): void {
     try {
-      DynamoFM_Log.log(` <=--  emitting server socket(${this.params.name}) event: ${event}`);
+      DyFM_Log.log(` <=--  emitting server socket(${this.params.name}) event: ${event}`);
 
       this.openSocketServer.emit(event, content, error => {
-        DynamoFM_Log.error(`Emitting server event '${event}' failed!\nerror:`, error);
+        DyFM_Log.error(`Emitting server event '${event}' failed!\nerror:`, error);
       });
     } catch (error) {
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           'emitEvent',
           error
@@ -573,10 +573,10 @@ export abstract class DynamoNTS_SocketServerService<
   idIsSubscribed(id: string): boolean {
     try {
       return !!this.presences.find(
-        (presence: DynamoNTS_SocketPresence) => presence.issuerId === id
+        (presence: DyNTS_SocketPresence) => presence.issuerId === id
       );
     } catch (error) {
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           'idIsSubscribed',
           error
@@ -590,9 +590,9 @@ export abstract class DynamoNTS_SocketServerService<
 
   async emitError(presenceIssuerId: string, error: any, issuer: string): Promise<void> {
     try {
-      await this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEventKey.error, error, issuer);
+      await this.sendEventForId(presenceIssuerId, DyNTS_SocketEventKey.error, error, issuer);
     } catch (error) {
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           'emitError',
           error,
@@ -607,12 +607,12 @@ export abstract class DynamoNTS_SocketServerService<
 
   async sendEventForId(id: string, event: string, content: any, issuer: string): Promise<void> {
     try {
-      const presence: DynamoNTS_SocketPresence = this.presences.find(
-        (pres: DynamoNTS_SocketPresence) => pres.issuerId === id
+      const presence: DyNTS_SocketPresence = this.presences.find(
+        (pres: DyNTS_SocketPresence) => pres.issuerId === id
       );
 
       if (!presence) {
-        throw new DynamoFM_Error({ 
+        throw new DyFM_Error({ 
           ...this._getDefaultErrorSettings(
             'sendEventForId',
             new Error(`No active socket with this specific ID: ${id}`),
@@ -626,14 +626,14 @@ export abstract class DynamoNTS_SocketServerService<
 
       presence.emitEvent(event, content, issuer);
 
-      if (DynamoNTS_globalSettings.logSocketEventContent) {
-        DynamoFM_Log.success(
+      if (DyNTS_globalSettings.logSocketEventContent) {
+        DyFM_Log.success(
           ` <--=  emitted socket(${this.params.name}) event for presence: ${event}, ` +
           `\n  presenceId: ${id}, sockets: ${presence.sockets.length}` +
           `\n  content:`, content
         );
       } else {
-        DynamoFM_Log.success(
+        DyFM_Log.success(
           ` <--=  emitted socket(${this.params.name}) event for presence: ${event}, ` +
           `\n  presenceId: ${id}, sockets: ${presence.sockets.length}`
         );
@@ -643,16 +643,16 @@ export abstract class DynamoNTS_SocketServerService<
         if (error.flag.includes('DYNAMO') && error?.accitionalInfo?.inactiveSockets) {
           const sockets: SocketIO.Socket[] = error.accitionalInfo.inactiveSockets;
 
-          await DynamoFM_Array.asyncForEach(sockets, async (socket: SocketIO.Socket) => {
+          await DyFM_Array.asyncForEach(sockets, async (socket: SocketIO.Socket) => {
             await this.removeSubscription(socket);
           });
 
-          const presence: DynamoNTS_SocketPresence = this.presences.find(
-            (pres: DynamoNTS_SocketPresence) => pres.issuerId === id
+          const presence: DyNTS_SocketPresence = this.presences.find(
+            (pres: DyNTS_SocketPresence) => pres.issuerId === id
           );
 
           if (!presence) {
-            throw new DynamoFM_Error({ 
+            throw new DyFM_Error({ 
               ...this._getDefaultErrorSettings(
                 'sendEventForId',
                 new Error(`No active socket(${this.params.name}) with this specific ID: ${id}`),
@@ -665,7 +665,7 @@ export abstract class DynamoNTS_SocketServerService<
           }
         }
       } catch (error) {
-        throw new DynamoFM_Error({
+        throw new DyFM_Error({
           ...this._getDefaultErrorSettings('sendEventForId', error, content?.source),
   
           errorCode: 'NTS-SSS-310',
@@ -675,7 +675,7 @@ export abstract class DynamoNTS_SocketServerService<
         });
       }
 
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings('sendEventForId', error, content?.source),
 
         errorCode: 'NTS-SSS-310',
@@ -686,15 +686,15 @@ export abstract class DynamoNTS_SocketServerService<
 
   broadcastEvent(event: string, content: any, issuer: string): void {
     try {
-      DynamoFM_Log.log(` <=-== broadcasting socket(${this.params.name}) event: ${event}`);
+      DyFM_Log.log(` <=-== broadcasting socket(${this.params.name}) event: ${event}`);
 
-      this.presences.forEach((presence: DynamoNTS_SocketPresence) => {
+      this.presences.forEach((presence: DyNTS_SocketPresence) => {
         presence.emitEvent(event, content, issuer);
       });
     } catch (error) {
-      DynamoFM_Log.error(`socket(${this.params.name}) Event Broadcast (${event}) failed`, error);
+      DyFM_Log.error(`socket(${this.params.name}) Event Broadcast (${event}) failed`, error);
       
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings('broadcastEvent', error),
         
         errorCode: 'NTS-SSS-400',
@@ -705,14 +705,14 @@ export abstract class DynamoNTS_SocketServerService<
 
   private _getDefaultErrorSettings(
     fnName: string, 
-    error: DynamoFM_AnyError, 
+    error: DyFM_AnyError, 
     issuer?: string
-  ): DynamoFM_Error_Settings {
+  ): DyFM_Error_Settings {
     return {
-      status: (error as DynamoFM_Error)?.___status ?? 500,
+      status: (error as DyFM_Error)?.___status ?? 500,
       message: (error as Error)?.message ?? `${fnName} was UNSUCCESFUL (NTS)`,
-      addECToUserMsg: !(error as DynamoFM_Error)?.__userMessage,
-      userMessage: (error as DynamoFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
+      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
+      userMessage: (error as DyFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
       issuer: issuer,
       issuerService: this.constructor?.name,
       error: error,
@@ -722,40 +722,40 @@ export abstract class DynamoNTS_SocketServerService<
   /**
    * You must setup params for the service in this function
    */
-  protected abstract getServiceParams(): DynamoNTS_SocketServerService_Params;
+  protected abstract getServiceParams(): DyNTS_SocketServerService_Params;
 
   /**
    * You must setup events and required services in this function
    */
-  protected abstract getIncomingEvents(): DynamoNTS_SocketEvent<any>[];
+  protected abstract getIncomingEvents(): DyNTS_SocketEvent<any>[];
 
   /**
    * You can setup tasks for the subscription event in this function
    */
-  protected getSubscriptionTasks?(): DynamoNTS_SocketEventTask<T_SubscriptionContent>[];
+  protected getSubscriptionTasks?(): DyNTS_SocketEventTask<T_SubscriptionContent>[];
   
   /**
    * You can setup tasks for the subscription event in this function
    */
-  protected getSubscriptionCloseTasks?(): DynamoNTS_SocketEventTask<null>[];
+  protected getSubscriptionCloseTasks?(): DyNTS_SocketEventTask<null>[];
 
   /**
    * You can setup preprocessess for the subscription event in this function
    */
-  protected getSubscriptionPreProcessess?(): DynamoNTS_SocketEventPreprocessTask[];
+  protected getSubscriptionPreProcessess?(): DyNTS_SocketEventPreprocessTask[];
 
   /**
    * You can setup tasks for the unsubscribe event in this function
    */
-  protected getUnsubscribeTasks?(): DynamoNTS_SocketEventTask<T_SubscriptionContent>[];
+  protected getUnsubscribeTasks?(): DyNTS_SocketEventTask<T_SubscriptionContent>[];
 
   /**
    * You can setup preprocessess for the unsubscribe event in this function
    */
-  protected getUnsubscribePreProcessess?(): DynamoNTS_SocketEventPreprocessTask[];
+  protected getUnsubscribePreProcessess?(): DyNTS_SocketEventPreprocessTask[];
 
   /**
    * You can setup tasks for the error event in this function
    */
-  protected errorHandling?: DynamoNTS_SocketEventTask<T_ErrorContent>;
+  protected errorHandling?: DyNTS_SocketEventTask<T_ErrorContent>;
 }