@futdevpro/nts-dynamo 1.6.44 → 1.6.46

package/src/_constants/mocks/socket-client.mock.ts

@@ -1,4 +1,4 @@
-import { DynamoNTS_SocketEventType } from '../../_enums';
+import { DynamoNTS_SocketEventKey } from '../../_enums';
 import { DynamoNTS_SocketClientServiceParams, DynamoNTS_SocketEvent } from '../../_models';
 import { DynamoNTS_SocketClientService } from '../../_modules/app-extended.index';
 
@@ -18,7 +18,7 @@ export class SocketClient_Mock extends DynamoNTS_SocketClientService {
     return [
       new DynamoNTS_SocketEvent({
         name: 'connect',
-        eventType: DynamoNTS_SocketEventType.connect,
+        eventKey: DynamoNTS_SocketEventKey.connect,
         tasks: [
           async (content: any, issuer: string) => {
             console.log('SocketClient_Mock: connect event received');

package/src/_enums/http/socket-event-type.enum.ts

@@ -1,9 +1,10 @@
 
-export enum DynamoNTS_SocketEventType {
+export enum DynamoNTS_SocketEventKey {
   /** incoming connection */
   connection = 'connection',
   /** outgoing connection */
   connect = 'connect',
+
   subscribe = 'subscribe',
   subscriptionSuccessful = 'subscriptionSuccessful',
   unsubscribe = 'unsubscribe',

package/src/_models/control-models/socket-event.control-model.ts

@@ -1,7 +1,7 @@
 
 import { Dynamo_Array, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 import { dynamoNTS_globalSettings } from '../../_constants/global-settings.const';
-import { DynamoNTS_SocketEventType } from '../../_enums/http/socket-event-type.enum';
+import { DynamoNTS_SocketEventKey } from '../../_enums/http/socket-event-type.enum';
 
 
 export type DynamoNTS_SocketEventPreprocessTask<T = any, R = any> = (content?: T, issuer?: string) => Promise<R>;
@@ -12,7 +12,7 @@ export type DynamoNTS_SocketEventTask<T> = (content?: T, issuer?: string) => Pro
  */
 export class DynamoNTS_SocketEvent<T>{
   socketName?: string;
-  eventType: DynamoNTS_SocketEventType | string;
+  eventKey: DynamoNTS_SocketEventKey | string;
   
   preProcessess?: DynamoNTS_SocketEventPreprocessTask<any, any>[];
   tasks?: DynamoNTS_SocketEventTask<T>[];
@@ -23,14 +23,15 @@ export class DynamoNTS_SocketEvent<T>{
   constructor(
     set: {
       /**
-       * naming the socket will help to follow events on service
+       * naming the socket will help to follow events on service,
+       * if not set, the eventKey will be used
        */
-      name: string,
+      name?: string,
       /**
        * define socket event type such as; 
        * connection, connect, disconnect, message, error, or anything else
        */
-      eventType: DynamoNTS_SocketEventType | string,
+      eventKey: DynamoNTS_SocketEventKey | string,
       /**
        * preprocesses are the functions the service needs to run before the actual function,
        * these can be used for authentications, or translating data
@@ -53,36 +54,31 @@ export class DynamoNTS_SocketEvent<T>{
     }
   ) {
     try {
-      this.socketName = set.name;
-      this.eventType = set.eventType;
+      this.socketName = set.name ?? set.eventKey;
+      this.eventKey = set.eventKey;
 
       this.preProcessess = set.preProcessess ?? [];
       this.tasks = set.tasks ?? [];
 
       if (set.logEvent !== undefined) {
         this.logEvent = set.logEvent;
-      } else if (this.eventType === DynamoNTS_SocketEventType.subscribe) {
+      } else if (this.eventKey === DynamoNTS_SocketEventKey.subscribe) {
         this.logEvent = false;
       } else if (
         ([ 
-          DynamoNTS_SocketEventType.connection, 
-          DynamoNTS_SocketEventType.connect,
-          /* DynamoNTS_SocketEventType.subscribe, */
-          DynamoNTS_SocketEventType.disconnect,
-        ] as string[]).includes(this.eventType)
+          DynamoNTS_SocketEventKey.connection, 
+          DynamoNTS_SocketEventKey.connect,
+          DynamoNTS_SocketEventKey.disconnect,
+        ] as string[]).includes(this.eventKey)
       ) {
         this.logEvent = dynamoNTS_globalSettings.logMainSocketEvents || dynamoNTS_globalSettings.logAllSocketEvent;
       } else {
         this.logEvent = dynamoNTS_globalSettings.logAllSocketEvent;
       }
       this.logEventContent = set.logEventContent !== undefined ? set.logEventContent : dynamoNTS_globalSettings.logSocketEventContent;
-
-      /* if (this.logEvent) {
-        this.preProcessess.unshift(this.getPreLog());
-      } */
     } catch (error) {
       Dynamo_Log.error(
-        `\nSocket Event params setup failed (${this.socketName}): ${set.eventType}`, error);
+        `\nSocket Event params setup failed (${this.socketName}): ${set.eventKey}`, error);
       throw error;
     }
   }
@@ -93,10 +89,10 @@ export class DynamoNTS_SocketEvent<T>{
    */
   private async getPreLog(content: T, issuer?: string): Promise<void> {
     try {
-      if (this.logEventContent && this.eventType !== DynamoNTS_SocketEventType.connection) {
-        Dynamo_Log.log(`---> incoming socket(${this.socketName}) event: ${this.eventType};\ncontent:`, content);
+      if (this.logEventContent && this.eventKey !== DynamoNTS_SocketEventKey.connection) {
+        Dynamo_Log.log(`---> incoming socket(${this.socketName}) event: ${this.eventKey};\ncontent:`, content);
       } else {
-        Dynamo_Log.log(`---> incoming socket(${this.socketName}) event: ${this.eventType}...`);
+        Dynamo_Log.log(`---> incoming socket(${this.socketName}) event: ${this.eventKey}...`);
       }
     } catch (error) {
       Dynamo_Log.error(`PreLog failed... (socket:  ${this.socketName})`, error);
@@ -121,7 +117,7 @@ export class DynamoNTS_SocketEvent<T>{
         await task(content, issuer);
       });
     } catch (error) {
-      Dynamo_Log.error(`Socket Event tasks failed to execute on ${this.socketName}.... (${this.eventType})`, error, 'content:', content);
+      Dynamo_Log.error(`Socket Event tasks failed to execute on ${this.socketName}.... (${this.eventKey})`, error, 'content:', content);
     }
   }
 }

package/src/_models/control-models/socket-presence.control-model.ts

@@ -47,23 +47,26 @@ export class DynamoNTS_SocketPresence {
   emitEvent?(event: string, content: any) {
     let anyFailed: boolean = false;
     const errors = [];
+    const inactiveSockets: SocketIO.Socket[] = [];
 
     this.sockets.forEach((socket: SocketIO.Socket, index: number) => {
       if (!socket.connected) {
-        Dynamo_Log.error(`Emitting event '${event}' on socket(${index}) failed! socket[${socket}] is not connected!`);
+        Dynamo_Log.error(`Emitting event '${event}' on socket(${index}) failed! socket[${socket.id}] is not connected!`);
+        anyFailed = true;
         errors.push(
           new Dynamo_Error({
             status: 500,
             errorCode: 'NTS-SPC-EE1',
             addECToUserMsg: true,
-            message: `Emitting event '${event}' on socket(${index}) failed! socket[${socket}] is not connected!`,
+            message: `Emitting event '${event}' on socket(${index}) failed! socket[${socket.id}] is not connected!`,
             userMessage: 'We encountered an unhandled Server Error, please contact the responsible development team.',
           })
         );
+        inactiveSockets.push(socket);
       }
 
-      const success: boolean = socket.emit(event, content, (error) => {
-        Dynamo_Log.error(`Emitting event '${event}' on socket(${index}) failed! (0)`, error);
+      const success: boolean = socket.emit(event, content, error => {
+        Dynamo_Log.error(`Emitting event '${event}' on socket(${index}) failed! (0)\nerror:`, error);
         errors.push(error);
         anyFailed = true;
       });
@@ -74,6 +77,8 @@ export class DynamoNTS_SocketPresence {
     });
 
     if (anyFailed) {
+      /* this.sockets = this.sockets.filter(socket => !inactiveSockets.includes(socket)); */
+
       throw new Dynamo_Error({
         status: 500,
         errorCode: 'NTS-SPC-EE2',
@@ -81,6 +86,10 @@ export class DynamoNTS_SocketPresence {
         message: `Emitting event '${event}' on socket(s) failed!`,
         userMessage: 'We encountered an unhandled Server Error, please contact the responsible development team.',
         /* errors: errors, */
+        additionalContent: {
+          inactiveSockets: inactiveSockets,
+          errors: errors,
+        }
       });
     }
   }

package/src/_services/core/api.service.ts

@@ -55,7 +55,7 @@ export class DynamoNTS_ApiService {
                 if (callParams.httpOptions.headers[headerKey]) {
                     privateAxiosInstance.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
                 } else {
-                    Dynamo_Log.error('DYNAMOBE ERROR: \n missing header:', headerKey, '\n\n', new Error());
+                    Dynamo_Log.error('DYNAMOBE ERROR: \n missing header:', headerKey/* , '\n\n', new Error() */);
                 }
             }
         }
@@ -76,7 +76,7 @@ export class DynamoNTS_ApiService {
                         break;
                     }
                 } else {
-                    Dynamo_Log.error('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey, '\n\n', new Error());
+                    Dynamo_Log.error('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey/* , '\n\n', new Error() */);
                 }
             }
         }
@@ -160,7 +160,7 @@ export class DynamoNTS_ApiService {
                 });
             break;
             default:
-                Dynamo_Log.error('DYNAMOBE ERROR: \n wrong api call type', '\n\n', new Error());
+                Dynamo_Log.error('DYNAMOBE ERROR: \n wrong api call type'/* , '\n\n', new Error() */);
             break;
         }
 
@@ -171,14 +171,14 @@ export class DynamoNTS_ApiService {
         }
     } catch (error) {
         Dynamo_Log.error(`\nAPI ERROR: ${callParams?.name} failed...` +
-        `\n${callParams?.baseUrl}${callParams?.endPoint}\n`, callParams);
+        `\n${callParams?.baseUrl}${callParams?.endPoint}\ncallParams:`, callParams);
 
         if (callParams?.httpOptions?.responseType === DynamoNTS_HttpResponseType.text) {
             error.error = JSON.parse(error.error);
         }
         
         if (error?.response?.data?.flag?.includes('DYNAMO')) {
-            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`/* , new Error() */);
 
             throw new Dynamo_Error({
                 errorCode: 'NTS-API-002',
@@ -190,7 +190,7 @@ export class DynamoNTS_ApiService {
             });
 
         } else if (error.code === 'ENOTFOUND') {
-            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`/* , new Error() */);
 
             throw new Dynamo_Error({ 
                 status: 404, 
@@ -203,7 +203,7 @@ export class DynamoNTS_ApiService {
             });
 
         } else if (error.code === 'ECONNREFUSED') {
-            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`/* , new Error() */);
 
             throw new Dynamo_Error({ 
                 status: 404, 
@@ -222,11 +222,11 @@ export class DynamoNTS_ApiService {
                 errorCode: 'NTS-API-005',
                 addECToUserMsg: true,
                 userMessage: this.defaultErrorUserMsg, 
-                issuerService: this.name,
+                issuerService: this/* .constructor */.name,
                 error 
             });
         } else {
-            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`, error, '\n\n', new Error());
+            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`, error/*, '\n\n' , new Error() */);
 
             throw error;
         }

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

@@ -9,7 +9,7 @@ import { delay, Dynamo_Array } from '@futdevpro/fsm-dynamo/utils';
 import { DynamoNTS_SocketClientServiceParams } from '../../_models/control-models/socket-client-service-params.control-model';
 import { dynamoNTS_globalSettings } from '../../_constants/global-settings.const';
 import { DynamoNTS_SocketEvent } from '../../_models/control-models/socket-event.control-model';
-import { DynamoNTS_SocketEventType } from '../../_enums/http/socket-event-type.enum';
+import { DynamoNTS_SocketEventKey } from '../../_enums/http/socket-event-type.enum';
 
 export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonService {
 
@@ -30,7 +30,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
   private defaultEvents: DynamoNTS_SocketEvent<any>[] = [
     new DynamoNTS_SocketEvent<any>({
       name: 'connect',
-      eventType: DynamoNTS_SocketEventType.connect,
+      eventKey: DynamoNTS_SocketEventKey.connect,
       tasks: [
         async () => {
           this._connected = true;
@@ -40,7 +40,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
     }),
     new DynamoNTS_SocketEvent<any>({
       name: 'disconnect',
-      eventType: DynamoNTS_SocketEventType.disconnect,
+      eventKey: DynamoNTS_SocketEventKey.disconnect,
       tasks: [
         async () => {
           this._connected = false;
@@ -55,7 +55,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
     }),
     new DynamoNTS_SocketEvent<any>({
       name: 'error',
-      eventType: DynamoNTS_SocketEventType.error,
+      eventKey: DynamoNTS_SocketEventKey.error,
       tasks: [
         async (content: any) => {
           Dynamo_Log.error(`Socket Client error: ${this.params.name}`, content);
@@ -98,7 +98,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
     try {
       if (this.logFn) console.log('\nFn:. setupDefaultEvents')
       this.defaultEvents.forEach((defaultEvent: DynamoNTS_SocketEvent<any>) => {
-        const eventDeclared = this.incomingEvents.find((event: DynamoNTS_SocketEvent<any>) => event.eventType === defaultEvent.eventType);
+        const eventDeclared = this.incomingEvents.find((event: DynamoNTS_SocketEvent<any>) => event.eventKey === defaultEvent.eventKey);
         if (!eventDeclared) {
           this.incomingEvents.push(defaultEvent);
         } else {
@@ -119,12 +119,12 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
         if (!event.socketName) {
           event.socketName = this.name;
         }
-        this.socket.on(event.eventType, async (content: any) => { 
+        this.socket.on(event.eventKey, async (content: any) => { 
           try {
             await event.executeEventTasks(content, this.params.service);
           } catch (error) {
             Dynamo_Log.error(`Socket Event failed: ${this.params.name} (${this.params.port})`, error);
-            await this.emitEvent(DynamoNTS_SocketEventType.error, error);
+            await this.emitEvent(DynamoNTS_SocketEventKey.error, error);
           }
         });
       });

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

@@ -5,7 +5,7 @@ import { Dynamo_Array, Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
 import { DynamoNTS_SingletonService } from '../base/singleton.service';
 import { dynamoNTS_globalSettings } from '../../_constants/global-settings.const';
-import { DynamoNTS_SocketEventType } from '../../_enums/http/socket-event-type.enum';
+import { DynamoNTS_SocketEventKey } from '../../_enums/http/socket-event-type.enum';
 import { DynamoNTS_SocketSecurity } from '../../_enums/socket-security.enum';
 import { DynamoNTS_SocketServerServiceParams } from '../../_models/control-models/socket-server-service-params.control-model';
 import { DynamoNTS_SocketPresence } from '../../_models/control-models/socket-presence.control-model';
@@ -88,19 +88,18 @@ export abstract class DynamoNTS_SocketServerService<
    */
   private async prepareEvents(): Promise<void> {
     try {
-      const connectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.connection);
+      const connectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.connection);
       if (0 <= connectEventIndex) {
         this.connectEvent = this.incomingEvents.splice(connectEventIndex)[0];
       } else {
         this.connectEvent = new DynamoNTS_SocketEvent({
-          name: 'connect',
-          eventType: DynamoNTS_SocketEventType.connection,
+          eventKey: DynamoNTS_SocketEventKey.connection,
         });
       }
       this.connectEvent.socketName = this.params.name;
 
       if (this.getPresenceFromSubscrioptionEventContent) {
-        const subscriptionEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.subscribe);
+        const subscriptionEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.subscribe);
         if (0 <= subscriptionEventIndex) {
           this.subscriptionEvent = this.incomingEvents.splice(subscriptionEventIndex)[0];
           Dynamo_Log.error(
@@ -110,8 +109,7 @@ export abstract class DynamoNTS_SocketServerService<
           );
         } else {
           this.subscriptionEvent = new DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
-            name: 'subscribe',
-            eventType: DynamoNTS_SocketEventType.subscribe 
+            eventKey: DynamoNTS_SocketEventKey.subscribe 
           });
         }
         if (this.getSubscriptionPreProcessess) {
@@ -121,26 +119,24 @@ export abstract class DynamoNTS_SocketServerService<
           this.subscriptionEvent.tasks.push(...this.getSubscriptionTasks());
         }
 
-        const disconnectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.disconnect);
+        const disconnectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.disconnect);
         if (0 <= disconnectEventIndex) {
-          this.incomingEvents[disconnectEventIndex].tasks.push(this.removeSubscriptionOnDisconnect);
+          this.incomingEvents[disconnectEventIndex].tasks.push(this.removeSubscription);
         } else {
           this.incomingEvents.push(
             new DynamoNTS_SocketEvent({
-              name: 'disconnect',
-              eventType: DynamoNTS_SocketEventType.disconnect,
+              eventKey: DynamoNTS_SocketEventKey.disconnect,
               tasks: [
-                this.removeSubscriptionOnDisconnect
+                this.removeSubscription
               ]
             })
           );
         }
 
-        const errorEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.error);
+        const errorEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.error);
         if (errorEventIndex == -1 && this.errorHandling) {
           this.incomingEvents.push(new DynamoNTS_SocketEvent<T_ErrorContent>({
-            name: 'error',
-            eventType: DynamoNTS_SocketEventType.error,
+            eventKey: DynamoNTS_SocketEventKey.error,
             tasks: [
               this.errorHandling
             ]
@@ -165,14 +161,14 @@ export abstract class DynamoNTS_SocketServerService<
     try {
       if (this.logFn) console.log('\nfn:. setupSocketServer');
 
-      newSocketServer.on(DynamoNTS_SocketEventType.connection, async (socket: SocketIO.Socket) => {
+      newSocketServer.on(DynamoNTS_SocketEventKey.connection, async (socket: SocketIO.Socket) => {
         try {
           let issuer: string;
 
           await this.connectEvent.executeEventTasks(socket);
 
           if (this.getPresenceFromSubscrioptionEventContent) {
-            socket.on(DynamoNTS_SocketEventType.subscribe, async (content: any) => {
+            socket.on(DynamoNTS_SocketEventKey.subscribe, async (content: any) => {
               try {
                 /** 
                  * usually socket logs are in event.executeEventTasks(), 
@@ -180,33 +176,37 @@ export abstract class DynamoNTS_SocketServerService<
                  * to be able to check content before getPresenceFromSubscrioptionEventContent 
                  */
                 if (dynamoNTS_globalSettings.logMainSocketEvents || dynamoNTS_globalSettings.logAllSocketEvent || dynamoNTS_globalSettings.logSocketEventContent) {
-                  Dynamo_Log.log(`---> incoming socket(${this.params.name}) event: ${DynamoNTS_SocketEventType.subscribe};\ncontent:`, content);
+                  Dynamo_Log.log(`---> incoming socket(${this.params.name}) event: ${DynamoNTS_SocketEventKey.subscribe};\ncontent:`, content);
                 } else {
-                  Dynamo_Log.log(`---> incoming socket(${this.params.name}) event: ${DynamoNTS_SocketEventType.subscribe}`);
+                  Dynamo_Log.log(`---> incoming socket(${this.params.name}) event: ${DynamoNTS_SocketEventKey.subscribe}`);
                 }
 
                 const presence: T_Presence = await this.getPresenceFromSubscrioptionEventContent(content, socket);
                 issuer = presence.issuerId;
       
-                this.socketSubscription(presence);
+                this.addSocketToPresence(presence);
                 await this.subscriptionEvent.executeEventTasks(content, issuer);
 
+                socket.emit(DynamoNTS_SocketEventKey.subscriptionSuccessful, 'subscribe was successful', error => {
+                  Dynamo_Log.error(`Emitting subscriptionSuccessful event failed!\nerror:`, error);
+                });
+                
                 Dynamo_Log.success(`<===> socket subscription successfull (${issuer})`);
               } catch (error) {
                 Dynamo_Log.error(`Socket Subscription failed: ${this.params.name} (${this.params.port}) will disconnect now...`, error);
-                socket.emit(DynamoNTS_SocketEventType.error, error);
+                socket.emit(DynamoNTS_SocketEventKey.error, error);
                 socket.disconnect();
               }
             })
           }
 
           this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
-            socket.on(event.eventType, async (content: any) => { 
+            socket.on(event.eventKey, async (content: any) => { 
               try {
                 await event.executeEventTasks(content, issuer);
               } catch (error) {
                 Dynamo_Log.error(`Socket Event failed: ${this.params.name} (${this.params.port})`, error);
-                socket.emit(DynamoNTS_SocketEventType.error, error);
+                socket.emit(DynamoNTS_SocketEventKey.error, error);
               }
             });
           });
@@ -216,7 +216,7 @@ export abstract class DynamoNTS_SocketServerService<
           }
         } catch (error) {
           Dynamo_Log.error(`Socket Connection failed: ${this.params.name} (${this.params.port}) will disconnect now...`, error);
-          socket.emit(DynamoNTS_SocketEventType.error, error);
+          socket.emit(DynamoNTS_SocketEventKey.error, error);
           socket.disconnect();
         }
       });
@@ -243,7 +243,7 @@ export abstract class DynamoNTS_SocketServerService<
     }
   }
 
-  protected async socketSubscription(newPresence: T_Presence): Promise<void> {
+  protected async addSocketToPresence(newPresence: T_Presence): Promise<void> {
     try {
       const activePresence: T_Presence = this.presences.find((pres: T_Presence) => pres.issuerId === newPresence.issuerId);
       
@@ -258,7 +258,7 @@ export abstract class DynamoNTS_SocketServerService<
     }
   }
 
-  private async removeSubscriptionOnDisconnect(socket: SocketIO.Socket, issuer?: string): Promise<void> {
+  private async removeSubscription(socket: SocketIO.Socket, issuer?: string): Promise<void> {
     try {
       const activePresenceIndex: number = this.presences.findIndex((pres: DynamoNTS_SocketPresence) => pres.sockets.includes(socket));
       
@@ -310,6 +310,8 @@ export abstract class DynamoNTS_SocketServerService<
       if (activePresence.sockets.length === 0) {
         this.presences.splice(activePresenceIndex);
       }
+      
+      socket.disconnect();
     } catch (error) {
       throw new Dynamo_Error({
         ...this._getDefaultErrorSettings(
@@ -324,10 +326,12 @@ export abstract class DynamoNTS_SocketServerService<
     }
   }
 
-  emitEvent(event: string, content: any): void {
+  emitServerEvent(event: string, content: any): void {
     try {
-      Dynamo_Log.log(` <--- emitting socket event: ${event} (${this.params.name})`);
-      this.openSocketServer.emit(event, content);
+      Dynamo_Log.log(` <=-- emitting server socket event: ${event} (${this.params.name})`);
+      this.openSocketServer.emit(event, content, error => {
+        Dynamo_Log.error(`Emitting server event '${event}' failed!\nerror:`, error);
+      });
     } catch (error) {
       throw new Dynamo_Error({
         ...this._getDefaultErrorSettings(
@@ -359,7 +363,7 @@ export abstract class DynamoNTS_SocketServerService<
 
   emitError(presenceIssuerId: string, error: any): void {
     try {
-      this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEventType.error, error);
+      this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEventKey.error, error);
     } catch (error) {
       throw new Dynamo_Error({
         ...this._getDefaultErrorSettings(
@@ -398,10 +402,30 @@ export abstract class DynamoNTS_SocketServerService<
         });
       }
     } catch (error) {
+
+      try {
+        if (error.flag.includes('DYNAMO') && error?.accitionalInfo?.inactiveSockets) {
+          const sockets: SocketIO.Socket[] = error.accitionalInfo.inactiveSockets;
+
+          await Dynamo_Array.asyncForEach(sockets, async (socket: SocketIO.Socket) => {
+            await this.removeSubscription(socket);
+          });
+        }
+      } catch (error) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings('sendEventForId', error, content?.source),
+  
+          errorCode: 'NTS-SSS-310',
+          message: 
+            `Error handling of inactive sockets failed!` +
+            `\n(Socket Event Emit for id (${id}, ${event}) failed: ${this.params?.name} (${this.params?.port}))`,
+        });
+      }
+
       throw new Dynamo_Error({
         ...this._getDefaultErrorSettings('sendEventForId', error, content?.source),
 
-        errorCode: 'NTS-SSS-300',
+        errorCode: 'NTS-SSS-310',
         message: `Socket Event Emit for id (${id}, ${event}) failed: ${this.params?.name} (${this.params?.port})`,
       });
     }
@@ -409,6 +433,7 @@ export abstract class DynamoNTS_SocketServerService<
 
   broadcastEvent(event: string, content: any): void {
     try {
+      Dynamo_Log.log(` <==-- broadcasting socket event: ${event} (${this.params.name})`);
       this.presences.forEach((presence: DynamoNTS_SocketPresence) => {
         presence.emitEvent(event, content);
       });