@futdevpro/nts-dynamo 1.6.35 → 1.6.36

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

@@ -1,5 +1,5 @@
 
-import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
+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';
 
@@ -37,7 +37,7 @@ export class DynamoNTS_SocketEvent<T>{
       } else {
         this.logEvent = dynamoNTS_globalSettings.logAllSocketEvent;
       }
-      this.logEventContent = set.logEventContent !== undefined ? set.logEventContent : dynamoNTS_globalSettings.logEventContent;
+      this.logEventContent = set.logEventContent !== undefined ? set.logEventContent : dynamoNTS_globalSettings.logSocketEventContent;
 
       if (this.logEvent) {
         this.preProcessess.unshift(this.getPreLog());
@@ -63,6 +63,7 @@ export class DynamoNTS_SocketEvent<T>{
             console.log(`\n==> incoming ${this.socketName} socket event: ${this.eventType}...`);
           }
         }
+        
         return content;
       } catch (error) {
         console.error(`PreLog failed... (socket:  ${this.socketName})`, error);
@@ -75,14 +76,20 @@ export class DynamoNTS_SocketEvent<T>{
    * @returns 
    */
   async executeEventTasks?(content?: T, issuer?: string): Promise<void> {
-    try {          
-      for (let i = 0; i < this.preProcessess.length; i++) {
+    try {        
+      await Dynamo_Array.asyncForEach(this.preProcessess, async (preProcess: DynamoNTS_SocketEventPreprocessTask<any, any>) => {
+        content = await preProcess(content);
+      });
+      /* for (let i = 0; i < this.preProcessess.length; i++) {
         content = await this.preProcessess[i](content);
-      }
+      } */
 
-      for (let i = 0; i < this.tasks.length; i++) {
+      await Dynamo_Array.asyncForEach(this.tasks, async (task: DynamoNTS_SocketEventTask<T>) => {
+        await task(content, issuer);
+      });
+      /* for (let i = 0; i < this.tasks.length; i++) {
         await this.tasks[i](content, issuer);
-      }
+      } */
     } catch (error) {
       console.error(`Socket Event tasks failed to execute on ${this.socketName}.... (${this.eventType})`, error, 'content:', content);
     }

package/src/_models/interfaces/global-settings.interface.ts

@@ -53,5 +53,10 @@ export interface DynamoNTS_GlobalSettings {
   /**
    * this is an application wide default setting for socket debug logs
    */
-  logEventContent?: boolean;
+  logSocketEventContent?: boolean;
+
+  /**
+   * this is an application wide default setting for api debug logs
+   */
+  logDetailedApiEvents?: boolean;
 }

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

@@ -5,6 +5,7 @@ import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 import { DynamoNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
 import { DynamoNTS_HttpResponseType } from '../../_enums/http/http-response-type.enum';
 import { DynamoNTS_ApiCallParams } from '../../_models/control-models/api-call-params.control-model';
+import { dynamoNTS_globalSettings } from '../../_constants';
 
 /**
  * This predefined Api service contains the basic API call function which can be used in various ways
@@ -111,7 +112,12 @@ export class DynamoNTS_ApiService {
                     } else {
                         a = res.data;
                     }
-                    Dynamo_Log.success(`${callParams.name} was successful`, res.data);
+
+                    if (dynamoNTS_globalSettings.logDetailedApiEvents) {
+                        Dynamo_Log.success(`${callParams.name} was successful`, res.data);
+                    } else {
+                        Dynamo_Log.success(`${callParams.name} was successful`);
+                    }
                 });
             break;
             case DynamoNTS_HttpCallType.delete:
@@ -122,7 +128,12 @@ export class DynamoNTS_ApiService {
                     if (callParams.getFullResponse) {
                         a = res;
                     }
-                    Dynamo_Log.success(`${callParams.name} was successful`, res.data);
+
+                    if (dynamoNTS_globalSettings.logDetailedApiEvents) {
+                        Dynamo_Log.success(`${callParams.name} was successful`, res.data);
+                    } else {
+                        Dynamo_Log.success(`${callParams.name} was successful`);
+                    }
                 });
             break;
             case DynamoNTS_HttpCallType.post:
@@ -140,7 +151,12 @@ export class DynamoNTS_ApiService {
                     } else {
                         a = res.data;
                     }
-                    Dynamo_Log.success(`${callParams.name} api call was successful`, res.data);
+
+                    if (dynamoNTS_globalSettings.logDetailedApiEvents) {
+                        Dynamo_Log.success(`${callParams.name} api call was successful`, res.data);
+                    } else {
+                        Dynamo_Log.success(`${callParams.name} api call was successful`);
+                    }
                 });
             break;
             default:

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

@@ -145,6 +145,8 @@ export abstract class DynamoNTS_SocketServerService<
         }
 
         this.subscriptionEvent.socketName = this.params.name;
+      } else {
+        Dynamo_Log.error('getPresenceFromSubscrioptionEventContent is not set', `${this.params.name} (${this.params.port})`);
       }
 
       this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
@@ -166,44 +168,79 @@ export abstract class DynamoNTS_SocketServerService<
       } */
       /* (security === DynamoNTS_SocketSecurity.open ? this.openSocketServer : this.secureSocketServer) */
       newSocketServer.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);        
-        }
+        try {
+          let issuer: string;
+          if (dynamoNTS_globalSettings.logMainSocketEvent) {
+            console.log(`Socket (${this.params.name}): new incoming CONNECTION...`);
+          }
+          
+          await Dynamo_Array.asyncForEach(this.connectEvent.preProcessess, 
+            async (preProcess: (content: SocketIO.Socket) => Promise<void>) => {
+              await preProcess(socket);
+            } 
+          );
+          /* for (let i = 0; i < this.connectEvent.preProcessess.length; i++) {
+            await this.connectEvent.preProcessess[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();
+          await Dynamo_Array.asyncForEach(this.connectEvent.tasks, 
+            async (task: (content: SocketIO.Socket) => Promise<void>) => {
+              await task(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 {
+                if (dynamoNTS_globalSettings.logMainSocketEvent || dynamoNTS_globalSettings.logAllSocketEvent || dynamoNTS_globalSettings.logSocketEventContent) {
+                  console.log(`---> incoming socket event: ${DynamoNTS_SocketEventType.subscribe} (${this.params.name}, presenceId: ${issuer})`, content);
+                } else {
+                  console.log(`---> incoming socket event: ${DynamoNTS_SocketEventType.subscribe} (${this.params.name}, presenceId: ${issuer})`);
+                }
+
+                const presence: T_Presence = await this.getPresenceFromSubscrioptionEventContent(content, socket);
+                issuer = presence.issuerId;
+      
+                this.socketSubscription(presence);
+                await this.subscriptionEvent.executeEventTasks(content, issuer);
+
+                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.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 {
+                if (dynamoNTS_globalSettings.logAllSocketEvent || dynamoNTS_globalSettings.logSocketEventContent) {
+                  console.log(`---> incoming socket event: ${event.eventType} (${this.params.name}, presenceId: ${issuer})`, content);
+                } else {
+                  console.log(`---> incoming socket event: ${event.eventType} (${this.params.name}, presenceId: ${issuer})`);
+                }
+
+                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);
+              }
+            });
           });
-        });
+
+          if (dynamoNTS_globalSettings.logMainSocketEvent) {
+            console.log(`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);
+          socket.emit(DynamoNTS_SocketEventType.error, error);
+          socket.disconnect();
+        }
       });
         
       newSocketServer.listen(this.params.port);
@@ -283,6 +320,7 @@ export abstract class DynamoNTS_SocketServerService<
 
   emitEvent(event: string, content: any): void {
     try {
+      console.log(` <--- emitting socket event: ${event} (${this.params.name})`);
       this.openSocketServer.emit(event, content);
     } catch (error) {
       Dynamo_Log.error(`Socket Event Emit (${event}) failed: ${this.params?.name} (${this.params?.port})`, error);
@@ -312,6 +350,7 @@ export abstract class DynamoNTS_SocketServerService<
     try {
       const presence: DynamoNTS_SocketPresence = this.presences.find((pres: DynamoNTS_SocketPresence) => pres.issuerId === id);
       if (presence) {
+        console.log(` <--- emitting socket event for presence: ${event} (${this.params.name}, presenceId: ${id})`);
         presence.emitEvent(event, content);
       } else {
         if (error) {