@futdevpro/nts-dynamo 1.6.14 → 1.6.15

package/src/_services/app-extended.server.ts

@@ -133,7 +133,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
       if (this.socketServices?.length) {
         this.setSocketSecurity();
 
-        this.mountSocketServerServices();
+        this.setupSocketServerServices();
 
         if (this.debugLog) console.log(`\nAll sockets setted up.... sockets using security: ${this.socketSecurity}`);
       } else {
@@ -163,7 +163,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
   /**
    * 
    */
-  private mountSocketServerServices(): void {
+  private setupSocketServerServices(): void {
     try {
       let httpSocketServer: Http.Server;
       if (this.socketSecurity !== DynamoNTS_RouteSecurity.secure) {
@@ -206,38 +206,43 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
       }
 
       this.socketServices.forEach((service: DynamoNTS_SocketServerService<any>) => {
-        const existingPorts: DynamoNTS_SocketServerService<any>[] = this.socketServices.filter(
-          (mod: DynamoNTS_SocketServerService<any>) => mod.port === service.port
-        );
+        try {
+          const existingPorts: DynamoNTS_SocketServerService<any>[] = this.socketServices.filter(
+            (mod: DynamoNTS_SocketServerService<any>) => mod.port === service.port
+          );
 
-        if (1 < existingPorts.length || this.ports.httpPort === service.port || this.ports.httpsPort === service.port) {
-          let error = new Error(`PORT DUPLICATION: ${service.port}`);
-          let errorStack: string[] = error.stack.split('\n');
-          errorStack.splice(1, 4);
-          error.stack = errorStack.join('\n');
+          if (1 < existingPorts.length || this.ports.httpPort === service.port || this.ports.httpsPort === service.port) {
+            let error = new Error(`PORT DUPLICATION: ${service.port}`);
+            let errorStack: string[] = error.stack.split('\n');
+            errorStack.splice(1, 4);
+            error.stack = errorStack.join('\n');
 
-          throw error;
-        }
+            throw error;
+          }
 
-        if (service.security === DynamoNTS_SocketSecurity.open) {
-          if (this.debugLog) console.log(`\nsocket setup (open): ${service.name}:${service.port}`);
-          service.setupSocketServer(new SocketIO.Server(httpSocketServer));
+          if (service.security === DynamoNTS_SocketSecurity.open) {
+            if (this.debugLog) console.log(`\nsocket setup (open): ${service.name}:${service.port}`);
+            service.setupSocketServer(new SocketIO.Server(httpSocketServer));
 
-        } else if (service.security === DynamoNTS_SocketSecurity.secure) {
-          if (this.debugLog) console.log(`\nsocket setup (secure): ${service.name}:${service.port}`);
-          service.setupSocketServer(new SocketIO.Server(this.httpsServer));
-          
-        } else {
-          let error = new Error(`INVALID Socket Service security: ${service.security} on ${service.name}`);
-          let errorStack: string[] = error.stack.split('\n');
-          errorStack.splice(1, 4);
-          error.stack = errorStack.join('\n');
+          } else if (service.security === DynamoNTS_SocketSecurity.secure) {
+            if (this.debugLog) console.log(`\nsocket setup (secure): ${service.name}:${service.port}`);
+            service.setupSocketServer(new SocketIO.Server(this.httpsServer));
+            
+          } else {
+            let error = new Error(`INVALID Socket Service security: ${service.security} on ${service.name}`);
+            let errorStack: string[] = error.stack.split('\n');
+            errorStack.splice(1, 4);
+            error.stack = errorStack.join('\n');
 
+            throw error;
+          }
+        } catch (error) {
+          Dynamo_Log.error(`\nSocket Server service setup failed. (${service.name})\n`, error, '\n');
           throw error;
         }
       });
     } catch (error) {
-      Dynamo_Log.error('\nSocket Server setup failed.\n', error, '\n');
+      Dynamo_Log.error(`\nSocket Server services setup failed. (${this.socketServices?.length} services)\n`, error, '\n');
       throw error;
     } 
   }

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

@@ -77,54 +77,70 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
       
       this.connectSocket();
     } catch (error) {
-      Dynamo_Log.error(`${this.params.name} Socket Client Service setup failed!`, error);
+      Dynamo_Log.error(`${this.params?.name} Socket Client Service setup failed!`, error);
     }
   }
 
   private setupDefaultEvents(): void {
-    this.defaultEvents.forEach((defaultEvent: DynamoNTS_SocketEvent<any>) => {
-      const eventDeclared = this.incomingEvents.find((event: DynamoNTS_SocketEvent<any>) => event.eventType === defaultEvent.eventType);
-      if (!eventDeclared) {
-        this.incomingEvents.push(defaultEvent);
-      } else {
-        eventDeclared.tasks.unshift(...defaultEvent.tasks);
-      }
-    });
+    try {
+      this.defaultEvents.forEach((defaultEvent: DynamoNTS_SocketEvent<any>) => {
+        const eventDeclared = this.incomingEvents.find((event: DynamoNTS_SocketEvent<any>) => event.eventType === defaultEvent.eventType);
+        if (!eventDeclared) {
+          this.incomingEvents.push(defaultEvent);
+        } else {
+          eventDeclared.tasks.unshift(...defaultEvent.tasks);
+        }
+      });
+    } catch (error) {
+      Dynamo_Log.error(`Socket Client Service Setup Default Events failed: ${this.params?.name} (${this.params?.port})`, error);
+    }
   }
 
   private setupSocketEvents(): void {
-    if (this.log) console.log(`Setup Socket Events... (${this.params.name})`);
+    try {
+      if (this.log) console.log(`Setup Socket Events... (${this.params.name})`);
 
-    this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
-      if (!event.socketName) {
-        event.socketName = this.name;
-      }
-      this.socket.on(event.eventType, 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);
-          this.emitEvent(DynamoNTS_SocketEventType.error, error);
+      this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
+        if (!event.socketName) {
+          event.socketName = this.name;
         }
+        this.socket.on(event.eventType, 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);
+            this.emitEvent(DynamoNTS_SocketEventType.error, error);
+          }
+        });
       });
-    });
+    } catch (error) {
+      Dynamo_Log.error(`Socket Client Service Setup Socket Events failed: ${this.params?.name} (${this.params?.port})`, error);
+    }
   }
   
   private connectSocket(): void {
-    console.log(`${this.params.name} Socket Client connecting to ${this.params.address}:${this.params.port} ...`);
+    try {
+      console.log(`${this.params.name} Socket Client connecting to ${this.params.address}:${this.params.port} ...`);
 
-    this.socket.connect();
+      this.socket.connect();
 
-    if (this.params.reconnect) {
-      this.tryReconnectIfNeeded();
+      if (this.params.reconnect) {
+        this.tryReconnectIfNeeded();
+      }
+    } catch (error) {
+      Dynamo_Log.error(`Socket Client Service Connect Socket failed: ${this.params?.name} (${this.params?.port})`, error);
     }
   }
 
   private async tryReconnectIfNeeded(): Promise<void> {
-    await delay(this._params.reconnectDelay);
-    
-    if (!this._connected) {
-      this.connectSocket();
+    try {
+      await delay(this._params.reconnectDelay);
+      
+      if (!this._connected) {
+        this.connectSocket();
+      }
+    } catch (error) {
+      Dynamo_Log.error(`Socket Client Service Try Reconnect failed: ${this.params?.name} (${this.params?.port})`, error);
     }
   }
 
@@ -134,8 +150,13 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
    * @param content event content
    */
   protected emitEvent(eventType: string, content: any): void {
-    console.log(`\n<== outgoing ${this.name} socket event: ${eventType}`);
-    this.socket.emit(eventType, content);
+    try {
+      console.log(`\n<== outgoing ${this.name} socket event: ${eventType}`);
+      this.socket.emit(eventType, content);
+    } catch (error) {
+      Dynamo_Log.error(`Socket Client Service Emit Event failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
+    }
   }
   
   /**

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

@@ -64,9 +64,9 @@ export abstract class DynamoNTS_SocketServerService<
       
       this.prepareEvents();
 
-      if (this.log) console.log(`Socket Controller setup done: ${this.params.name} (${this.params.port}) serurity: ${this.params.security}\n`);
+      if (this.log) console.log(`Socket Server Service setup done: ${this.params.name} (${this.params.port}) serurity: ${this.params.security}\n`);
     } catch (error) {
-      Dynamo_Log.error(`Socket Controller setup failed: ${this.params?.name} (${this.params?.port})`, error);
+      Dynamo_Log.error(`Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, error);
     }
   }
 
@@ -74,191 +74,235 @@ export abstract class DynamoNTS_SocketServerService<
    * You must setup events and required services for this function
    */
   private prepareEvents(): void {
-    const connectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.connection);
-    if (0 <= connectEventIndex) {
-      this.connectEvent = this.incomingEvents.splice(connectEventIndex)[0];
-    } else {
-      this.connectEvent = new DynamoNTS_SocketEvent({
-        eventType: DynamoNTS_SocketEventType.connection,
-        tasks: []
-      });
-    }
-    this.connectEvent.socketName = this.params.name;
-
-    if (this.getPresenceFromSubscrioptionEventContent) {
-      const subscriptionEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.subscribe);
-      if (0 <= subscriptionEventIndex) {
-        this.subscriptionEvent = this.incomingEvents.splice(subscriptionEventIndex)[0];
-        Dynamo_Log.error(
-          `You should not set the subscription event, but the subscriptions tasks, ` +
-          `in case you need additional steps for your subscripotions.`,
-          `${this.params.name} (${this.params.port})`,
-        );
+    try {
+      const connectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.connection);
+      if (0 <= connectEventIndex) {
+        this.connectEvent = this.incomingEvents.splice(connectEventIndex)[0];
       } else {
-        this.subscriptionEvent = new DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
-          eventType: DynamoNTS_SocketEventType.subscribe 
+        this.connectEvent = new DynamoNTS_SocketEvent({
+          eventType: DynamoNTS_SocketEventType.connection,
+          tasks: []
         });
       }
-      if (this.getSubscriptionPreProcessess) {
-        this.subscriptionEvent.preProcessess.push(...this.getSubscriptionPreProcessess());
-      }
-      if (this.getSubscriptionTasks) {
-        this.subscriptionEvent.tasks.push(...this.getSubscriptionTasks());
-      }
+      this.connectEvent.socketName = this.params.name;
 
-      const disconnectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.disconnect);
-      if (0 <= disconnectEventIndex) {
-        this.incomingEvents[disconnectEventIndex].tasks.push(this.removeSubscriptionOnDisconnect);
-      } else {
-        this.incomingEvents.push(
-          new DynamoNTS_SocketEvent({
-            eventType: DynamoNTS_SocketEventType.disconnect,
+      if (this.getPresenceFromSubscrioptionEventContent) {
+        const subscriptionEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.subscribe);
+        if (0 <= subscriptionEventIndex) {
+          this.subscriptionEvent = this.incomingEvents.splice(subscriptionEventIndex)[0];
+          Dynamo_Log.error(
+            `You should not set the subscription event, but the subscriptions tasks, ` +
+            `in case you need additional steps for your subscripotions.`,
+            `${this.params.name} (${this.params.port})`,
+          );
+        } else {
+          this.subscriptionEvent = new DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
+            eventType: DynamoNTS_SocketEventType.subscribe 
+          });
+        }
+        if (this.getSubscriptionPreProcessess) {
+          this.subscriptionEvent.preProcessess.push(...this.getSubscriptionPreProcessess());
+        }
+        if (this.getSubscriptionTasks) {
+          this.subscriptionEvent.tasks.push(...this.getSubscriptionTasks());
+        }
+
+        const disconnectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.disconnect);
+        if (0 <= disconnectEventIndex) {
+          this.incomingEvents[disconnectEventIndex].tasks.push(this.removeSubscriptionOnDisconnect);
+        } else {
+          this.incomingEvents.push(
+            new DynamoNTS_SocketEvent({
+              eventType: DynamoNTS_SocketEventType.disconnect,
+              tasks: [
+                this.removeSubscriptionOnDisconnect
+              ]
+            })
+          );
+        }
+
+        const errorEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.error);
+        if (errorEventIndex == -1 && this.errorHandling) {
+          this.incomingEvents.push(new DynamoNTS_SocketEvent<T_ErrorContent>({
+            eventType: DynamoNTS_SocketEventType.error,
             tasks: [
-              this.removeSubscriptionOnDisconnect
+              this.errorHandling
             ]
-          })
-        );
-      }
+          }));
+        }
 
-      const errorEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventType === DynamoNTS_SocketEventType.error);
-      if (errorEventIndex == -1 && this.errorHandling) {
-        this.incomingEvents.push(new DynamoNTS_SocketEvent<T_ErrorContent>({
-          eventType: DynamoNTS_SocketEventType.error,
-          tasks: [
-            this.errorHandling
-          ]
-        }));
+        this.subscriptionEvent.socketName = this.params.name;
       }
 
-      this.subscriptionEvent.socketName = this.params.name;
+      this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
+        event.socketName = this.params.name;
+      });
+    } catch (error) {
+      Dynamo_Log.error(`Socket Server Service - Event Preparation setup failed: ${this.params?.name} (${this.params?.port})`, error);
     }
-
-    this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
-      event.socketName = this.params.name;
-    });
   }
 
   async setupSocketServer(newSocketServer: SocketIO.Server): Promise<void> {
-    this.socketServer = newSocketServer;
-    this.socketServer.on(DynamoNTS_SocketEventType.connection, async (socket: SocketIO.Socket) => {
-      let issuer: string;
-      
-      for (let i = 0; i < this.connectEvent.preProcessess.length; i++) {
-        await this.connectEvent.preProcessess[i](socket);
-      }
+    try {
+      this.socketServer = newSocketServer;
+      this.socketServer.on(DynamoNTS_SocketEventType.connection, async (socket: SocketIO.Socket) => {
+        let issuer: string;
+        
+        for (let i = 0; i < this.connectEvent.preProcessess.length; i++) {
+          await this.connectEvent.preProcessess[i](socket);
+        }
 
-      for (let i = 0; i < this.connectEvent.tasks.length; i++) {
-        await this.connectEvent.tasks[i](socket);        
-      }
+        for (let i = 0; i < this.connectEvent.tasks.length; i++) {
+          await this.connectEvent.tasks[i](socket);        
+        }
 
-      if (this.getPresenceFromSubscrioptionEventContent) {
-        socket.on(DynamoNTS_SocketEventType.subscribe, async (content: any) => {
-          try {
-            const presence: T_Presence = await this.getPresenceFromSubscrioptionEventContent(content, socket);
-            issuer = presence.issuerId;
-  
-            this.socketSubscription(presence);
-            await this.subscriptionEvent.executeEventTasks(content, issuer);
-
-            console.log(`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.disconnect();
-          }
-        })
-      }
+        if (this.getPresenceFromSubscrioptionEventContent) {
+          socket.on(DynamoNTS_SocketEventType.subscribe, async (content: any) => {
+            try {
+              const presence: T_Presence = await this.getPresenceFromSubscrioptionEventContent(content, socket);
+              issuer = presence.issuerId;
+    
+              this.socketSubscription(presence);
+              await this.subscriptionEvent.executeEventTasks(content, issuer);
+
+              console.log(`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.disconnect();
+            }
+          })
+        }
 
-      this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
-        socket.on(event.eventType, 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);
-          }
+        this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
+          socket.on(event.eventType, 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);
+            }
+          });
         });
-      });
 
-    });
+      });
 
-    this.socketServer.listen(this.params.port);
+      this.socketServer.listen(this.params.port);
 
-    console.log(
-      `\nsocket service setup finished: ${this.params.name}` + 
-      `\nsocket server listening on port: ${this.params.port}`
-    );
+      console.log(
+        `\nsocket service setup finished: ${this.params.name}` + 
+        `\nsocket server listening on port: ${this.params.port}`
+      );
+    } catch (error) {
+      Dynamo_Log.error(`Socket Server Service - Deep Setup failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
+    }
   }
 
   protected async socketSubscription(newPresence: T_Presence): Promise<void> {
-    const activePresence: T_Presence = this.presences.find((pres: T_Presence) => pres.issuerId === newPresence.issuerId);
-    if (activePresence) {
-      activePresence.sockets.push(newPresence.sockets[0]);
-    } else {
-      this.presences.push(newPresence);
+    try {
+      const activePresence: T_Presence = this.presences.find((pres: T_Presence) => pres.issuerId === newPresence.issuerId);
+      
+      if (activePresence) {
+        activePresence.sockets.push(newPresence.sockets[0]);
+      } else {
+        this.presences.push(newPresence);
+      }
+    } catch (error) {
+      Dynamo_Log.error(`Socket Subscription failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
     }
   }
 
   private async removeSubscriptionOnDisconnect(socket: SocketIO.Socket, issuer?: string): Promise<void> {
-    const activePresenceIndex: number = this.presences.findIndex((pres: DynamoNTS_SocketPresence) => pres.sockets.includes(socket));
-    if (0 <= activePresenceIndex) {
-      const activePresence: DynamoNTS_SocketPresence = this.presences[activePresenceIndex];
-      if (activePresence.issuerId !== issuer) {
-        Dynamo_Log.error(`Socket subscription for ${issuer} and ${activePresence.issuerId} does not match.`);
-      }
+    try {
+      const activePresenceIndex: number = this.presences.findIndex((pres: DynamoNTS_SocketPresence) => pres.sockets.includes(socket));
+      if (0 <= activePresenceIndex) {
+        const activePresence: DynamoNTS_SocketPresence = this.presences[activePresenceIndex];
+        if (activePresence.issuerId !== issuer) {
+          Dynamo_Log.error(`Socket subscription for ${issuer} and ${activePresence.issuerId} does not match.`);
+        }
 
-      const socketIndex = activePresence.sockets.findIndex((s: SocketIO.Socket) => s === socket);
-      if (0 <= socketIndex) {
-        activePresence.sockets.splice(socketIndex);
-        if (this.getSubscriptionCloseTasks) {
-          await Dynamo_Array.asyncForEach(this.getSubscriptionCloseTasks(), async (task: DynamoNTS_SocketEventTask<null>) => {
-            await task(null, issuer);
-          });
+        const socketIndex = activePresence.sockets.findIndex((s: SocketIO.Socket) => s === socket);
+        if (0 <= socketIndex) {
+          activePresence.sockets.splice(socketIndex);
+          if (this.getSubscriptionCloseTasks) {
+            await Dynamo_Array.asyncForEach(this.getSubscriptionCloseTasks(), async (task: DynamoNTS_SocketEventTask<null>) => {
+              await task(null, issuer);
+            });
+          }
+        } else {
+          Dynamo_Log.error(`Socket does not match present in presence.`);
         }
-      } else {
-        Dynamo_Log.error(`Socket does not match present in presence.`);
-      }
 
-      if (activePresence.sockets.length === 0) {
-        this.presences.splice(activePresenceIndex);
+        if (activePresence.sockets.length === 0) {
+          this.presences.splice(activePresenceIndex);
+        }
       }
+    } catch (error) {
+      Dynamo_Log.error(`Socket Subscription Removal failed: ${this.params?.name} (${this.params?.port})`, error);
     }
   }
 
   emitEvent(event: string, content: any): void {
-    this.socketServer.emit(event, content);
+    try {
+      this.socketServer.emit(event, content);
+    } catch (error) {
+      Dynamo_Log.error(`Socket Event Emit (${event}) failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
+    }
   }
 
   idIsSubscribed(id: string): boolean {
-    return !!this.presences.find((presence: DynamoNTS_SocketPresence) => presence.issuerId === id);
+    try {
+      return !!this.presences.find((presence: DynamoNTS_SocketPresence) => presence.issuerId === id);
+    } catch (error) {
+      Dynamo_Log.error(`Socket ID Subscription Check (${id}) failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
+    }
   }
 
   emitError(presenceIssuerId: string, error: any): void {
-    this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEventType.error, error);
+    try {
+      this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEventType.error, error);
+    } catch (error) {
+      Dynamo_Log.error(`Socket Error Emit (id: ${presenceIssuerId}) failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
+    }
   }
 
   async sendEventForId(id: string, event: string, content: any, error?: (err: any) => void): Promise<void> {
-    const presence: DynamoNTS_SocketPresence = this.presences.find((pres: DynamoNTS_SocketPresence) => pres.issuerId === id);
-    if (presence) {
-      presence.emitEvent(event, content);
-    } else {
-      if (error) {
-
-        throw new Dynamo_Error({ 
-          status: 404, 
-          errorCode: 'NTS-S99-001',
-          addECToUserMsg: true,
-          message: `No active socket whit this specific ID: ${id}`,
-          userMessage: this.defaultErrorUserMsg
-        });
+    try {
+      const presence: DynamoNTS_SocketPresence = this.presences.find((pres: DynamoNTS_SocketPresence) => pres.issuerId === id);
+      if (presence) {
+        presence.emitEvent(event, content);
+      } else {
+        if (error) {
+
+          throw new Dynamo_Error({ 
+            status: 404, 
+            errorCode: 'NTS-S99-001',
+            addECToUserMsg: true,
+            message: `No active socket whit this specific ID: ${id}`,
+            userMessage: this.defaultErrorUserMsg
+          });
+        }
       }
+    } catch (error) {
+      Dynamo_Log.error(`Socket Event Emit for id (${id}, ${event}) failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
     }
   }
 
   broadcastEvent(event: string, content: any): void {
-    this.presences.forEach((presence: DynamoNTS_SocketPresence) => {
-      presence.emitEvent(event, content);
-    })
+    try {
+      this.presences.forEach((presence: DynamoNTS_SocketPresence) => {
+        presence.emitEvent(event, content);
+      });
+    } catch (error) {
+      Dynamo_Log.error(`Socket Event Broadcast (${event}) failed: ${this.params?.name} (${this.params?.port})`, error);
+      throw error;
+    }
   }
 
   /**