@futdevpro/nts-dynamo 1.6.50 → 1.6.51

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

@@ -53,6 +53,7 @@ export class DynamoNTS_SocketPresence {
       if (!socket.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,
@@ -62,7 +63,9 @@ export class DynamoNTS_SocketPresence {
             userMessage: 'We encountered an unhandled Server Error, please contact the responsible development team.',
           })
         );
+
         inactiveSockets.push(socket);
+        socket.disconnect(true);
       }
 
       const success: boolean = socket.emit(event, content, error => {
@@ -70,6 +73,7 @@ export class DynamoNTS_SocketPresence {
         errors.push(error);
         anyFailed = true;
       });
+
       if (!success) {
         Dynamo_Log.error(`Emitting event '${event}' on socket(${index}) failed! (1)`);
         anyFailed = true;
@@ -77,7 +81,7 @@ export class DynamoNTS_SocketPresence {
     });
 
     if (anyFailed) {
-      /* this.sockets = this.sockets.filter(socket => !inactiveSockets.includes(socket)); */
+      this.sockets = this.sockets.filter(socket => !inactiveSockets.includes(socket) && socket?.connected);
 
       throw new Dynamo_Error({
         status: 500,

package/src/_services/base/db.service.ts

@@ -337,12 +337,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
 
     if (0 < dataList.length && typeof dataList[0]._id === 'object') {
       dataList.forEach((data: T) => {
-        if (data && (typeof data._id !== 'string' || typeof data._id === 'object')) {
-          data._id = `${data._id}`;
-          if (typeof data._id !== 'string' || typeof data._id === 'object') {
-            Dynamo_Log.error('data._id stringifying failed! Please notfiy the developer! (DynamoNTS_DBService.getAll)')
-          }
-        }
+        data = this.stringifyDataId(data, 'getAll');
       });
     }
 
@@ -533,7 +528,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
       });
     });
 
-    data = this.stringifyDataId(data);
+    data = this.stringifyDataId(data, 'findOne');
 
     return data;
   }
@@ -827,7 +822,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
   // ----------------------------------------------------------------------------------
   // PRIVATE FUNCTIONS
 
-  private stringifyDataId(data: T): T {
+  private stringifyDataId(data: T, fnName: string): T {
     if (data && (typeof data._id !== 'string' || typeof data._id === 'object')) {
       data._id = `${data._id}`;
 
@@ -835,7 +830,7 @@ export class DynamoNTS_DBService<T extends Dynamo_Metadata> {
         data = JSON.parse(JSON.stringify(data));
 
         if (typeof data._id !== 'string' || typeof data._id === 'object') {
-          Dynamo_Log.error('data._id stringifying failed! Please notfiy the developers!', new Error());
+          Dynamo_Log.error(`data._id stringifying failed! Please notfiy the developers! (${fnName})`, new Error());
         }
       }  
     }

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

@@ -106,7 +106,7 @@ export abstract class DynamoNTS_SocketServerService<
           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.`,
+            `in case you need additional steps for your subscriptions.`,
             `${this.params.name} (${this.params.port})`,
           );
         } else {
@@ -126,14 +126,14 @@ export abstract class DynamoNTS_SocketServerService<
         const disconnectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.disconnect);
         if (0 <= disconnectEventIndex) {
           this.incomingEvents[disconnectEventIndex].serviceName = this.params.name;
-          this.incomingEvents[disconnectEventIndex].tasks.push(this.removeSubscription);
+          this.incomingEvents[disconnectEventIndex].tasks.push(this.disconnectBaseTask);
         } else {
           this.incomingEvents.push(
             new DynamoNTS_SocketEvent({
               serviceName: this.params.name,
               eventKey: DynamoNTS_SocketEventKey.disconnect,
               tasks: [
-                this.removeSubscription
+                this.disconnectBaseTask
               ]
             })
           );
@@ -200,7 +200,7 @@ export abstract class DynamoNTS_SocketServerService<
                   Dynamo_Log.error(`Emitting subscriptionSuccessful event failed!\nerror:`, error);
                 });
                 
-                Dynamo_Log.success(`<===>  socket subscription successfull (${issuer})`);
+                Dynamo_Log.success(`<===>  socket(${this.params.name}) subscription successfull (${issuer})`);
               } catch (error) {
                 Dynamo_Log.error(`Socket Subscription failed: ${this.params.name} (${this.params.port}) will disconnect now...`, error);
                 socket.emit(DynamoNTS_SocketEventKey.error, error);
@@ -221,7 +221,7 @@ export abstract class DynamoNTS_SocketServerService<
           });
 
           if (dynamoNTS_globalSettings.logMainSocketEvents) {
-            Dynamo_Log.success(`<   >  Socket (${this.params.name}): new CONNECTION established`);
+            Dynamo_Log.success(`<   >  socket(${this.params.name}): new CONNECTION established`);
           }
         } catch (error) {
           Dynamo_Log.error(`Socket Connection failed: ${this.params.name} (${this.params.port}) will disconnect now...`, error);
@@ -267,6 +267,24 @@ export abstract class DynamoNTS_SocketServerService<
     }
   }
 
+  private async disconnectBaseTask(socket: SocketIO.Socket, issuer: string): Promise<void> {
+    try {
+      await this.removeSubscription(socket, issuer);
+
+      Dynamo_Log.info(`< x >  socket(${this.params.name}) disconnected (${issuer})`);
+    } catch (error) {
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          'disconnectBaseTask',
+          error,
+          issuer,
+        ),
+
+        errorCode: 'NTS-SSS-109'
+      });
+    }
+  }
+
   private async removeSubscription(socket: SocketIO.Socket, issuer?: string): Promise<void> {
     try {
       const activePresenceIndex: number = this.presences.findIndex((pres: DynamoNTS_SocketPresence) => pres.sockets.includes(socket));
@@ -275,7 +293,7 @@ export abstract class DynamoNTS_SocketServerService<
         throw new Dynamo_Error({
           ...this._getDefaultErrorSettings(
             'sendEventForId', 
-            new Error(`closing Socket does not match any in the activePresences`), 
+            new Error(`closing socket(${this.params.name}) does not match any in the activePresences`), 
             issuer
           ),
 
@@ -301,7 +319,7 @@ export abstract class DynamoNTS_SocketServerService<
         throw new Dynamo_Error({
           ...this._getDefaultErrorSettings(
             'sendEventForId',
-            new Error(`closing Socket does not match any in the activePresences`),
+            new Error(`closing socket(${this.params.name}) does not match any in the activePresences`),
             issuer
           ),
 
@@ -321,6 +339,7 @@ export abstract class DynamoNTS_SocketServerService<
       }
 
       socket.disconnect();
+      Dynamo_Log.info(`<=x=>  socket(${this.params.name}) unsubscription successfull (${issuer})`);
     } catch (error) {
       throw new Dynamo_Error({
         ...this._getDefaultErrorSettings(
@@ -330,14 +349,14 @@ export abstract class DynamoNTS_SocketServerService<
         ),
 
         errorCode: 'NTS-SSS-200',
-        message: `Socket Subscription Removal failed: ${this.params?.name} (${this.params?.port})`,
+        message: `socket(${this.params.name}) Subscription Removal failed: ${this.params?.name}`,
       });
     }
   }
 
   emitServerEvent(event: string, content: any): void {
     try {
-      Dynamo_Log.log(` <=--  emitting server socket event: ${event} (${this.params.name})`);
+      Dynamo_Log.log(` <=--  emitting server socket(${this.params.name}) event: ${event}`);
       this.openSocketServer.emit(event, content, error => {
         Dynamo_Log.error(`Emitting server event '${event}' failed!\nerror:`, error);
       });
@@ -349,7 +368,7 @@ export abstract class DynamoNTS_SocketServerService<
         ),
 
         errorCode: 'NTS-SSS-500',
-        message: `Socket Event Emit (${event}) failed: ${this.params?.name} (${this.params?.port})`,
+        message: `socket(${this.params.name}) Event Emit (${event}) failed: ${this.params?.name}`,
       });
     }
   }
@@ -365,7 +384,7 @@ export abstract class DynamoNTS_SocketServerService<
         ),
 
         errorCode: 'NTS-SSS-600',
-        message: `Socket ID Subscription Check (${id}) failed: ${this.params?.name} (${this.params?.port})`,
+        message: `socket(${this.params.name}) ID Subscription Check (${id}) failed`,
       });
     }
   }
@@ -382,7 +401,7 @@ export abstract class DynamoNTS_SocketServerService<
         ),
 
         errorCode: 'NTS-SSS-700',
-        message: `Socket Error Emit (id: ${presenceIssuerId}) failed: ${this.params?.name} (${this.params?.port})`,
+        message: `socket(${this.params.name}) Error Emit (id: ${presenceIssuerId}) failed`,
       });
     }
   }
@@ -407,9 +426,9 @@ export abstract class DynamoNTS_SocketServerService<
       presence.emitEvent(event, content);
 
       if (dynamoNTS_globalSettings.logSocketEventContent) {
-        Dynamo_Log.log(` <---  emitted socket event for presence: ${event} (${this.params.name}, presenceId: ${id}) \ncontent:`, content);
+        Dynamo_Log.success(` <---  emitted socket(${this.params.name}) event for presence: ${event}, presenceId: ${id}) \ncontent:`, content);
       } else {
-        Dynamo_Log.log(` <---  emitted socket event for presence: ${event} (${this.params.name}, presenceId: ${id})`);
+        Dynamo_Log.success(` <---  emitted socket(${this.params.name}) event for presence: ${event}, presenceId: ${id})`);
       }
     } catch (error) {
       try {
@@ -425,7 +444,7 @@ export abstract class DynamoNTS_SocketServerService<
             throw new Dynamo_Error({ 
               ...this._getDefaultErrorSettings(
                 'sendEventForId',
-                new Error(`No active socket with this specific ID: ${id}`),
+                new Error(`No active socket(${this.params.name}) with this specific ID: ${id}`),
                 content?.source
               ),
 
@@ -440,8 +459,8 @@ export abstract class DynamoNTS_SocketServerService<
   
           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}))`,
+            `Error handling of inactive sockets(${this.params.name}) failed!` +
+            `\n(Socket Event Emit for id (${id}, ${event}) failed)`,
         });
       }
 
@@ -449,24 +468,24 @@ export abstract class DynamoNTS_SocketServerService<
         ...this._getDefaultErrorSettings('sendEventForId', error, content?.source),
 
         errorCode: 'NTS-SSS-310',
-        message: `Socket Event Emit for id (${id}, ${event}) failed: ${this.params?.name} (${this.params?.port})`,
+        message: `socket(${this.params.name}) Event Emit for id (${id}, ${event}) failed`,
       });
     }
   }
 
   broadcastEvent(event: string, content: any): void {
     try {
-      Dynamo_Log.log(` <==-- broadcasting socket event: ${event} (${this.params.name})`);
+      Dynamo_Log.log(` <==-- broadcasting socket(${this.params.name}) event: ${event}`);
       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);
+      Dynamo_Log.error(`socket(${this.params.name}) Event Broadcast (${event}) failed`, error);
       throw new Dynamo_Error({
         ...this._getDefaultErrorSettings('broadcastEvent', error),
         
         errorCode: 'NTS-SSS-400',
-        message: `Socket Event Broadcast (${event}) failed: ${this.params?.name} (${this.params?.port})`,
+        message: `socket(${this.params.name}) Event Broadcast (${event}) failed`,
       });
     }
   }