@futdevpro/nts-dynamo 1.6.37 → 1.6.38

package/src/_constants/mocks/app-server.mock.ts

@@ -13,7 +13,6 @@ import { DynamoNTS_RoutingModule } from '../../_services/route/routing-module.se
 import { DynamoNTS_App } from '../../_services/server/app.server';
 import { DynamoNTS_Controller_Mock } from './controller.mock';
 import { AuthService_Mock } from './auth-service.mock';
-import { dynamoNTS_globalSettings } from '../global-settings.const';
 import { dependency_mock_DataParams, dependent_mock_DataParams } from './data-model.mock';
 import { getCustomDataRoutingModule } from '../../_modules/custom-data';
 

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

@@ -17,6 +17,7 @@ export class SocketClient_Mock extends DynamoNTS_SocketClientService {
   getIncomingEvents(): DynamoNTS_SocketEvent<any>[] {
     return [
       new DynamoNTS_SocketEvent({
+        name: 'connect',
         eventType: DynamoNTS_SocketEventType.connect,
         tasks: [
           async (content: any, issuer: string) => {

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

@@ -21,10 +21,39 @@ export class DynamoNTS_SocketEvent<T>{
   logEventContent?: boolean;
 
   constructor(
-    set: DynamoNTS_SocketEvent<T>
+    set: {
+      /**
+       * naming the socket will help to follow events on service
+       */
+      name: string,
+      /**
+       * define socket event type such as; 
+       * connection, connect, disconnect, message, error, or anything else
+       */
+      eventType: DynamoNTS_SocketEventType | string,
+      /**
+       * preprocesses are the functions the service needs to run before the actual function,
+       * these can be used for authentications, or translating data
+       * 
+       * the last function in the array should return the content in the type(T) of the socket<T>
+       */
+      preProcessess?: DynamoNTS_SocketEventPreprocessTask<any, any>[],
+      /**
+       * tasks are the functions the service needs to run
+       */
+      tasks?: DynamoNTS_SocketEventTask<T>[],
+      /**
+       * logEvent will create a log for the event triggered
+       */
+      logEvent?: boolean,
+      /**
+       * logEventContent will create a log for the event triggered with the content
+       */
+      logEventContent?: boolean,
+    }
   ) {
     try {
-      this.socketName = set.socketName;
+      this.socketName = set.name;
       this.eventType = set.eventType;
 
       this.preProcessess = set.preProcessess ?? [];
@@ -32,16 +61,25 @@ export class DynamoNTS_SocketEvent<T>{
 
       if (set.logEvent !== undefined) {
         this.logEvent = set.logEvent;
-      } else if (([ DynamoNTS_SocketEventType.connection, DynamoNTS_SocketEventType.connect, DynamoNTS_SocketEventType.disconnect ] as string[]).includes(this.eventType)) {
-        this.logEvent = dynamoNTS_globalSettings.logMainSocketEvent;
+      } else if (this.eventType === DynamoNTS_SocketEventType.subscribe) {
+        this.logEvent = false;
+      } else if (
+        ([ 
+          DynamoNTS_SocketEventType.connection, 
+          DynamoNTS_SocketEventType.connect,
+          /* DynamoNTS_SocketEventType.subscribe, */
+          DynamoNTS_SocketEventType.disconnect,
+        ] as string[]).includes(this.eventType)
+      ) {
+        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) {
+      /* if (this.logEvent) {
         this.preProcessess.unshift(this.getPreLog());
-      }
+      } */
     } catch (error) {
       Dynamo_Log.error(
         `\nSocket Event params setup failed (${this.socketName}): ${set.eventType}`, error);
@@ -53,45 +91,37 @@ export class DynamoNTS_SocketEvent<T>{
    * 
    * @returns 
    */
-  getPreLog?(): DynamoNTS_SocketEventPreprocessTask {
-    return async (content: T, issuer?: string) => {
-      try {
-        if (this.logEvent) {
-          if (this.logEventContent) {
-            console.log(`\n==> incoming ${this.socketName} socket event: ${this.eventType} content:`, content);
-          } else {
-            console.log(`\n==> incoming ${this.socketName} socket event: ${this.eventType}...`);
-          }
-        }
-        
-        return content;
-      } catch (error) {
-        console.error(`PreLog failed... (socket:  ${this.socketName})`, error);
+  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}; content:`, content);
+      } else {
+        Dynamo_Log.log(`--> incoming socket(${this.socketName}) event: ${this.eventType}...`);
       }
-    };
+    } catch (error) {
+      Dynamo_Log.error(`PreLog failed... (socket:  ${this.socketName})`, error);
+    }
   }
 
   /**
    * 
    * @returns 
    */
-  async executeEventTasks?(content?: T, issuer?: string): Promise<void> {
+  async executeEventTasks(content?: T, issuer?: string): Promise<void> {
     try {        
+      if (this.logEvent || this.logEventContent) {
+        await this.getPreLog(content, issuer);
+      }
+
       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);
-      } */
 
       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);
+      Dynamo_Log.error(`Socket Event tasks failed to execute on ${this.socketName}.... (${this.eventType})`, error, 'content:', content);
     }
   }
 }

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

@@ -45,7 +45,7 @@ export interface DynamoNTS_GlobalSettings {
   /**
    * this is an application wide default setting for socket debug logs
    */
-  logMainSocketEvent?: boolean;
+  logMainSocketEvents?: boolean;
   /**
    * this is an application wide default setting for socket debug logs
    */

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

@@ -29,6 +29,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
 
   private defaultEvents: DynamoNTS_SocketEvent<any>[] = [
     new DynamoNTS_SocketEvent<any>({
+      name: 'connect',
       eventType: DynamoNTS_SocketEventType.connect,
       tasks: [
         async () => {
@@ -38,6 +39,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
       ]
     }),
     new DynamoNTS_SocketEvent<any>({
+      name: 'disconnect',
       eventType: DynamoNTS_SocketEventType.disconnect,
       tasks: [
         async () => {
@@ -52,6 +54,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
       ]
     }),
     new DynamoNTS_SocketEvent<any>({
+      name: 'error',
       eventType: DynamoNTS_SocketEventType.error,
       tasks: [
         async (content: any) => {
@@ -79,7 +82,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
 
       await this.setupSocketEvents();
 
-      console.log(`\n${this.params?.name} Socket Client Service setup finished`);
+      Dynamo_Log.log(`\n${this.params?.name} Socket Client Service setup finished`);
       
       await this.connectSocket();
     } catch (error) {
@@ -133,7 +136,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
   
   private async connectSocket(): Promise<void> {
     try {
-      console.log(`${this.params.name} Socket Client connecting to ${this.params.address}:${this.params.port} ...`);
+      Dynamo_Log.log(`${this.params.name} Socket Client connecting to ${this.params.address}:${this.params.port} ...`);
 
       this.socket.connect();
 
@@ -167,7 +170,7 @@ export abstract class DynamoNTS_SocketClientService extends DynamoNTS_SingletonS
    */
   protected async emitEvent(eventType: string, content: any): Promise<void> {
     try {
-      console.log(`\n<== outgoing ${this.name} socket event: ${eventType}`);
+      Dynamo_Log.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);

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

@@ -93,8 +93,8 @@ export abstract class DynamoNTS_SocketServerService<
         this.connectEvent = this.incomingEvents.splice(connectEventIndex)[0];
       } else {
         this.connectEvent = new DynamoNTS_SocketEvent({
+          name: 'connect',
           eventType: DynamoNTS_SocketEventType.connection,
-          tasks: []
         });
       }
       this.connectEvent.socketName = this.params.name;
@@ -110,6 +110,7 @@ export abstract class DynamoNTS_SocketServerService<
           );
         } else {
           this.subscriptionEvent = new DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
+            name: 'subscribe',
             eventType: DynamoNTS_SocketEventType.subscribe 
           });
         }
@@ -126,6 +127,7 @@ export abstract class DynamoNTS_SocketServerService<
         } else {
           this.incomingEvents.push(
             new DynamoNTS_SocketEvent({
+              name: 'disconnect',
               eventType: DynamoNTS_SocketEventType.disconnect,
               tasks: [
                 this.removeSubscriptionOnDisconnect
@@ -137,6 +139,7 @@ export abstract class DynamoNTS_SocketServerService<
         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>({
+            name: 'error',
             eventType: DynamoNTS_SocketEventType.error,
             tasks: [
               this.errorHandling
@@ -161,44 +164,25 @@ export abstract class DynamoNTS_SocketServerService<
   async setupSocketServer(newSocketServer: SocketIO.Server, security: DynamoNTS_SocketSecurity.open | DynamoNTS_SocketSecurity.secure, successCallback: () => void): Promise<SocketIO.Server> {
     try {
       if (this.logFn) console.log('\nfn:. setupSocketServer');
-      /* if (security === DynamoNTS_SocketSecurity.open) {
-        this.openSocketServer = newSocketServer;
-      } else {
-        this.secureSocketServer = newSocketServer;
-      } */
-      /* (security === DynamoNTS_SocketSecurity.open ? this.openSocketServer : this.secureSocketServer) */
+
       newSocketServer.on(DynamoNTS_SocketEventType.connection, async (socket: SocketIO.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);
-          } */
-
-          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);        
-          } */
+
+          await this.connectEvent.executeEventTasks(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);
+                /** 
+                 * usually socket logs are in event.executeEventTasks(), 
+                 * but subscribe event is an exception from this, 
+                 * 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}; content:`, content);
                 } else {
-                  console.log(`---> incoming socket event: ${DynamoNTS_SocketEventType.subscribe} (${this.params.name}, presenceId: ${issuer})`);
+                  Dynamo_Log.log(`---> incoming socket(${this.params.name}) event: ${DynamoNTS_SocketEventType.subscribe}`);
                 }
 
                 const presence: T_Presence = await this.getPresenceFromSubscrioptionEventContent(content, socket);
@@ -219,12 +203,6 @@ export abstract class DynamoNTS_SocketServerService<
           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);
@@ -233,7 +211,7 @@ export abstract class DynamoNTS_SocketServerService<
             });
           });
 
-          if (dynamoNTS_globalSettings.logMainSocketEvent) {
+          if (dynamoNTS_globalSettings.logMainSocketEvents) {
             console.log(`Socket (${this.params.name}): new CONNECTION established`);
           }
         } catch (error) {
@@ -244,13 +222,6 @@ export abstract class DynamoNTS_SocketServerService<
       });
         
       newSocketServer.listen(this.params.port);
-      /* if (security === DynamoNTS_SocketSecurity.open) {
-        this.openSocketServer = newSocketServer;
-        this.openSocketServer.listen(this.params.port);
-      } else {
-        this.secureSocketServer = newSocketServer;
-        this.secureSocketServer.listen(this.params.port);
-      } */
       
       Dynamo_Log.success(
         `\nsocket server setup finished: ${this.params.name}` + 
@@ -320,7 +291,7 @@ export abstract class DynamoNTS_SocketServerService<
 
   emitEvent(event: string, content: any): void {
     try {
-      console.log(` <--- emitting socket event: ${event} (${this.params.name})`);
+      Dynamo_Log.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);
@@ -350,7 +321,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})`);
+        Dynamo_Log.log(` <--- emitting socket event for presence: ${event} (${this.params.name}, presenceId: ${id})`);
         presence.emitEvent(event, content);
       } else {
         if (error) {