@futdevpro/nts-dynamo 1.6.43 → 1.6.45

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

@@ -62,8 +62,8 @@ export class DynamoNTS_SocketPresence {
         );
       }
 
-      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;
       });

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-server.service.ts

@@ -188,9 +188,13 @@ export abstract class DynamoNTS_SocketServerService<
                 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_SocketEventType.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);
@@ -243,7 +247,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);
       
@@ -261,41 +265,85 @@ export abstract class DynamoNTS_SocketServerService<
   private async removeSubscriptionOnDisconnect(socket: SocketIO.Socket, issuer?: string): Promise<void> {
     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.`);
-        }
+      
+      if (activePresenceIndex === -1) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings(
+            'sendEventForId', 
+            new Error(`closing Socket does not match any in the activePresences`), 
+            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.`);
-        }
+          errorCode: 'NTS-SSS-203',
+        });
+      }
 
-        if (activePresence.sockets.length === 0) {
-          this.presences.splice(activePresenceIndex);
-        }
+      const activePresence: DynamoNTS_SocketPresence = this.presences[activePresenceIndex];
+      if (activePresence.issuerId !== issuer) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings(
+            'sendEventForId',
+            new Error(`socket subscription for ${issuer} and ${activePresence.issuerId} does not match.`),
+            issuer
+          ),
+
+          errorCode: 'NTS-SSS-201',
+        });
+      }
+
+      const socketIndex = activePresence.sockets.findIndex((s: SocketIO.Socket) => s === socket);
+      if (socketIndex === -1) {
+        throw new Dynamo_Error({
+          ...this._getDefaultErrorSettings(
+            'sendEventForId',
+            new Error(`closing Socket does not match any in the activePresences`),
+            issuer
+          ),
+
+          errorCode: 'NTS-SSS-202',
+        });
+      }
+
+      activePresence.sockets.splice(socketIndex);
+      if (this.getSubscriptionCloseTasks) {
+        await Dynamo_Array.asyncForEach(this.getSubscriptionCloseTasks(), async (task: DynamoNTS_SocketEventTask<null>) => {
+          await task(null, issuer);
+        });
+      }
+
+      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);
-      throw error;
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          'sendEventForId',
+          error,
+          issuer
+        ),
+
+        errorCode: 'NTS-SSS-200',
+        message: `Socket Subscription Removal failed: ${this.params?.name} (${this.params?.port})`,
+      });
     }
   }
 
-  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) {
-      Dynamo_Log.error(`Socket Event Emit (${event}) failed: ${this.params?.name} (${this.params?.port})`, error);
-      throw error;
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          'emitEvent',
+          error
+        ),
+
+        errorCode: 'NTS-SSS-500',
+        message: `Socket Event Emit (${event}) failed: ${this.params?.name} (${this.params?.port})`,
+      });
     }
   }
 
@@ -303,8 +351,15 @@ export abstract class DynamoNTS_SocketServerService<
     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;
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          'idIsSubscribed',
+          error
+        ),
+
+        errorCode: 'NTS-SSS-600',
+        message: `Socket ID Subscription Check (${id}) failed: ${this.params?.name} (${this.params?.port})`,
+      });
     }
   }
 
@@ -312,8 +367,16 @@ export abstract class DynamoNTS_SocketServerService<
     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;
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          'emitError',
+          error,
+          presenceIssuerId
+        ),
+
+        errorCode: 'NTS-SSS-700',
+        message: `Socket Error Emit (id: ${presenceIssuerId}) failed: ${this.params?.name} (${this.params?.port})`,
+      });
     }
   }
 
@@ -322,8 +385,12 @@ export abstract class DynamoNTS_SocketServerService<
       const presence: DynamoNTS_SocketPresence = this.presences.find((pres: DynamoNTS_SocketPresence) => pres.issuerId === id);
 
       if (presence) {
-        Dynamo_Log.log(` <--- emitting socket event for presence: ${event} (${this.params.name}, presenceId: ${id})`);
         presence.emitEvent(event, content);
+        if (dynamoNTS_globalSettings.logSocketEventContent) {
+          Dynamo_Log.log(` <--- emitted socket event for presence: ${event} (${this.params.name}, presenceId: ${id}) \ncontent:`, content);
+        } else {
+          Dynamo_Log.log(` <--- emitted socket event for presence: ${event} (${this.params.name}, presenceId: ${id})`);
+        }
       } else {
         throw new Dynamo_Error({ 
           ...this._getDefaultErrorSettings(
@@ -342,13 +409,13 @@ export abstract class DynamoNTS_SocketServerService<
 
         errorCode: 'NTS-SSS-300',
         message: `Socket Event Emit for id (${id}, ${event}) failed: ${this.params?.name} (${this.params?.port})`,
-        error
       });
     }
   }
 
   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);
       });
@@ -359,7 +426,6 @@ export abstract class DynamoNTS_SocketServerService<
         
         errorCode: 'NTS-SSS-400',
         message: `Socket Event Broadcast (${event}) failed: ${this.params?.name} (${this.params?.port})`,
-        error
       });
     }
   }