@futdevpro/nts-dynamo 1.10.8 → 1.10.9

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

@@ -32,7 +32,7 @@ export abstract class DyNTS_SocketClient_ServiceBase extends DyNTS_SingletonServ
 
   private readonly defaultEvents: DyFM_SocketEvent<any>[] = [
     new DyFM_SocketEvent<any>({
-      eventKey: DyFM_SocketEvent_Key.connect,
+      eventKey: DyFM_SocketEvent_Key.outgoingNewConnection,
       tasks: [
         async () => {
           this._connected = true;
@@ -69,7 +69,11 @@ export abstract class DyNTS_SocketClient_ServiceBase extends DyNTS_SingletonServ
       eventKey: DyFM_SocketEvent_Key.error,
       tasks: [
         async (content: any) => {
-          DyFM_Log.error(`=-->   socket-client(${this.params.name}) ERROR!:`, content);
+          if (content instanceof DyFM_Error) {
+            content.logSimple(`=-->   socket-client(${this.params.name}) ERROR`);
+          } else {
+            DyFM_Log.error(`=-->   socket-client(${this.params.name}) ERROR:`, content);
+          }
         },
       ],
     }),
@@ -226,7 +230,7 @@ export abstract class DyNTS_SocketClient_ServiceBase extends DyNTS_SingletonServ
    * @param eventType event name
    * @param content event content
    */
-  protected async emitEvent(eventType: string, content: any): Promise<void> {
+  async emitEvent(eventType: string, content: any): Promise<void> {
     try {
       DyFM_Log.log(`<=--   outgoing socket-client(${this.params.name}) event: ${eventType}`);
       this.socket.emit(eventType, content);

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

@@ -50,11 +50,11 @@ export abstract class DyNTS_SocketServerService<
   protected openSocketServer: SocketIO.Server;
   protected secureSocketServer: SocketIO.Server;
 
-  private connectEvent: DyFM_SocketEvent<SocketIO.Socket>;
+  /* private connectEvent: DyFM_SocketEvent<SocketIO.Socket>; */
   protected incomingEvents: DyFM_SocketEvent<any>[];
 
-  private subscriptionEvent: DyFM_SocketEvent<any>;
-  private unsubscribeEvent: DyFM_SocketEvent<any>;
+  /* private subscriptionEvent: DyFM_SocketEvent<any>; */
+  /* private unsubscribeEvent: DyFM_SocketEvent<any>; */
   
   protected presences: T_Presence[] = [];
 
@@ -119,7 +119,7 @@ export abstract class DyNTS_SocketServerService<
   private async prepareEvents(): Promise<void> {
     try {
       /** Setup connect event */
-      const connectEventIndex = this.incomingEvents.findIndex(
+      /* const connectEventIndex = this.incomingEvents.findIndex(
         (event: DyFM_SocketEvent<any>) => 
           event.eventKey === DyFM_SocketEvent_Key.connection
       );
@@ -131,111 +131,128 @@ export abstract class DyNTS_SocketServerService<
           eventKey: DyFM_SocketEvent_Key.connection,
         });
       }
-      this.connectEvent.serviceName = this.params.name;
+      this.connectEvent.serviceName = this.params.name; */
 
-      /** Setup subscriptions events */
-      if (this.getPresenceFromSubscriptionEventContent) {
-        /** Setup subscription event */ 
-        const subscriptionEventIndex = this.incomingEvents.findIndex(
-          (event: DyFM_SocketEvent<any>) => 
-            event.eventKey === DyFM_SocketEvent_Key.subscribe
-        );
-
-        if (0 <= subscriptionEventIndex) {
-          this.subscriptionEvent = this.incomingEvents.splice(subscriptionEventIndex)[0];
-          DyFM_Log.error(
-            `You should not set the subscription event, but the subscriptions tasks, ` +
-            `in case you need additional steps for your subscriptions.`,
-            `${this.params.name} (${this.params.port})`
-          );
-        } else {
-          this.subscriptionEvent = new DyFM_SocketEvent<T_SubscriptionContent>({ 
-            eventKey: DyFM_SocketEvent_Key.subscribe,
-          });
-        }
-
-        if (this.getSubscriptionPreProcesses) {
-          this.subscriptionEvent.preProcesses.push(...this.getSubscriptionPreProcesses());
-        }
+      if (!this.getPresenceFromSubscriptionEventContent) {
+        throw new DyFM_Error({
+          error: new Error('getPresenceFromSubscriptionEventContent must be set'),
+          errorCode: 'NTS-SSS-PPE1',
+        });
+      }
 
-        if (this.getSubscriptionTasks) {
-          this.subscriptionEvent.tasks.push(...this.getSubscriptionTasks());
-        }
-        this.subscriptionEvent.serviceName = this.params.name;
-        
-        /** Setup subscription event */ 
-        const unsubscribeEventIndex = this.incomingEvents.findIndex(
-          (event: DyFM_SocketEvent<any>) => 
-            event.eventKey === DyFM_SocketEvent_Key.unsubscribe
+      if (!this.getSubscriptionTasks) {
+        DyFM_Log.warn(
+          `You should not set the subscription event, ` +
+          `in case you need additional steps for your subscriptions.`,
+          `${this.params.name} (${this.params.port})`
         );
+      }
 
-        if (0 <= unsubscribeEventIndex) {
-          this.unsubscribeEvent = this.incomingEvents.splice(unsubscribeEventIndex)[0];
-          DyFM_Log.error(
-            `You should not set the unsubscribe event, but the unsubscribe tasks, ` +
-            `in case you need additional steps for your unsubscribe.`,
-            `${this.params.name} (${this.params.port})`
-          );
-        } else {
-          this.unsubscribeEvent = new DyFM_SocketEvent<T_SubscriptionContent>({ 
-            eventKey: DyFM_SocketEvent_Key.unsubscribe,
-          });
-        }
-
-        if (this.getUnsubscribePreProcesses) {
-          this.unsubscribeEvent.preProcesses.push(...this.getUnsubscribePreProcesses());
-        }
-
-        if (this.getUnsubscribeTasks) {
-          this.unsubscribeEvent.tasks.push(...this.getUnsubscribeTasks());
-        }
-        this.unsubscribeEvent.serviceName = this.params.name;
+      if (this.incomingEvents.find(
+        (event: DyFM_SocketEvent<any>) => 
+          event.eventKey === DyFM_SocketEvent_Key.subscribe
+      )) {
+        DyFM_Log.warn(
+          `You need to use getSubscriptionTasks() ` +
+          `instead of setting the subscribe event in getIncomingEvents().`,
+          `${this.params.name} (${this.params.port})`
+        );
+      }
 
-        /** Setup disconnect event */
-        const disconnectEventIndex = this.incomingEvents.findIndex(
-          (event: DyFM_SocketEvent<any>) => 
-            event.eventKey === DyFM_SocketEvent_Key.disconnect
+      if (!this.incomingEvents.find(
+        (event: DyFM_SocketEvent<any>) => 
+          event.eventKey === DyFM_SocketEvent_Key.unsubscribe
+      )) {
+        DyFM_Log.warn(
+          `You should not set the unsubscribe event, ` +
+          `in case you need additional steps for your unsubscribe.`,
+          `${this.params.name} (${this.params.port})`
         );
+      }
 
-        if (0 <= disconnectEventIndex) {
-          this.incomingEvents[disconnectEventIndex].serviceName = this.params.name;
-          this.incomingEvents[disconnectEventIndex].tasks.push(this.disconnectBaseTask);
-        } else {
-          this.incomingEvents.push(
-            new DyFM_SocketEvent({
-              serviceName: this.params.name,
-              eventKey: DyFM_SocketEvent_Key.disconnect,
-              tasks: [
-                this.disconnectBaseTask,
-              ],
-            })
-          );
-        }
+      if (this.incomingEvents.find(
+        (event: DyFM_SocketEvent<any>) => !event.eventKey
+      )) {
+        throw new DyFM_Error({
+          error: new Error('eventKey must be set'),
+          errorCode: 'NTS-SSS-PPE2',
+        });
+      }
 
-        /** Setup error event */
-        const errorEventIndex = this.incomingEvents.findIndex(
-          (event: DyFM_SocketEvent<any>) => event.eventKey === DyFM_SocketEvent_Key.error
+      this.incomingEvents.push(
+        new DyFM_SocketEvent({
+          eventKey: DyFM_SocketEvent_Key.disconnect,
+          tasks: [
+            async (socket: SocketIO.Socket, issuer: string) => 
+              this.disconnectBaseTask(socket, issuer),
+          ],
+        })
+      );
+      
+      if (this.errorHandling) {
+        this.incomingEvents.push(new DyFM_SocketEvent<T_ErrorContent>({
+          serviceName: this.params.name,
+          eventKey: DyFM_SocketEvent_Key.error,
+          tasks: [
+            async (content: any) => this.errorHandling(content),
+          ],
+        }));
+      } else {
+        DyFM_Log.warn(
+          `You should not set the error event, ` +
+          `in case you need additional steps for your error.`,
+          `${this.params.name} (${this.params.port})`
         );
 
-        if (errorEventIndex == -1 && this.errorHandling) {
-          this.incomingEvents.push(new DyFM_SocketEvent<T_ErrorContent>({
-            serviceName: this.params.name,
-            eventKey: DyFM_SocketEvent_Key.error,
-            tasks: [
-              this.errorHandling,
-            ],
-          }));
-        }
+        this.incomingEvents.push(new DyFM_SocketEvent<T_ErrorContent>({
+          serviceName: this.params.name,
+          eventKey: DyFM_SocketEvent_Key.error,
+          tasks: [
+            async (content: any) => {
+              if (content instanceof DyFM_Error) {
+                content.logSimple(`=-->   socket-client(${this.params.name}) ERROR`);
+              } else {
+                DyFM_Log.error(`=-->   socket-client(${this.params.name}) ERROR:`, content);
+              }
+            }
+          ],
+        }));
+      }
+      
+      // Merge incoming events of the same eventKey
+      const eventKeys = this.incomingEvents.map(
+        (event: DyFM_SocketEvent<any>) => event.eventKey
+      ).filter(
+        (eventKey: string, index: number, self: string[]) => 
+          self.indexOf(eventKey) === index
+      );
+      const mergedEvents: DyFM_SocketEvent<any>[] = [];
+      eventKeys.forEach((eventKey: string) => {
+        const events = this.incomingEvents.filter(
+          (event: DyFM_SocketEvent<any>) => event.eventKey === eventKey
+        );
 
-        this.subscriptionEvent.name = this.params.name;
-      } else {
-        DyFM_Log.error(
-          'getPresenceFromSubscriptionEventContent is not set', 
-          `"${this.params.name}" (${this.params.port})`
+        mergedEvents.push(new DyFM_SocketEvent({
+          eventKey: eventKey,
+          preProcesses: events.map((event: DyFM_SocketEvent<any>) => event.preProcesses).flat(),
+          tasks: events.map((event: DyFM_SocketEvent<any>) => event.tasks).flat(),
+        }));
+      });
+      this.incomingEvents = mergedEvents;
+        
+      if (DyNTS_global_settings.log_settings.setup) {
+        DyFM_Log.log(
+          `Socket Server Service - Event Preparation setup done: ` +
+          `"${this.params?.name}" (${this.params?.port})` + 
+          `\nincomingEvents:`, this.incomingEvents.map(
+            (event: DyFM_SocketEvent<any>) => 
+              `\n\t"${event.eventKey}": preProcesses: ${event.preProcesses?.length} ` +
+                `tasks: ${event.tasks?.length}`
+          )
         );
       }
 
-      /** Set incoming events serviceName */
+      // Set incoming events serviceName
       this.incomingEvents.forEach((event: DyFM_SocketEvent<any>) => {
         event.serviceName = this.params.name;
       });
@@ -259,16 +276,29 @@ export abstract class DyNTS_SocketServerService<
     try {
       if (this.highDetailedLogs) console.log('\nfn:. setupSocketServer');
 
-      newSocketServer.on(DyFM_SocketEvent_Key.connection, async (socket: SocketIO.Socket) => {
+      newSocketServer.on(DyFM_SocketEvent_Key.incomingNewConnection, async (socket: SocketIO.Socket) => {
         try {
           let issuer: string;
 
-          await this.connectEvent.executeEventTasks(socket);
+          /* await this.connectEvent.executeEventTasks(socket); */
+          
+          await DyFM_Array.asyncForEach(
+            this.incomingEvents.filter(
+              (event: DyFM_SocketEvent<any>) => 
+                event.eventKey === DyFM_SocketEvent_Key.incomingNewConnection
+            ),
+            async (event: DyFM_SocketEvent<any>) => {
+              await event.executeEventTasks(socket);
+            }
+          );
+
 
           if (this.getPresenceFromSubscriptionEventContent) {
             socket.on(
               DyFM_SocketEvent_Key.subscribe, 
               async (content: any) => {
+                let presence: T_Presence;
+
                 try {
                   /** 
                    * usually socket logs are in event.executeEventTasks(), 
@@ -288,7 +318,7 @@ export abstract class DyNTS_SocketServerService<
                     );
                   }
 
-                  const presence: T_Presence = await this.getPresenceFromSubscriptionEventContent(
+                  presence = await this.getPresenceFromSubscriptionEventContent(
                     content, socket
                   );
 
@@ -296,7 +326,16 @@ export abstract class DyNTS_SocketServerService<
                   issuer = presence.issuerLocalId;
         
                   this.addSocketToPresence(presence);
-                  await this.subscriptionEvent.executeEventTasks(content, issuer);
+                  /* await this.subscriptionEvent.executeEventTasks(content, issuer); */
+                  
+                  if (this.getSubscriptionTasks) {
+                    await DyFM_Array.asyncForEach(
+                      this.getSubscriptionTasks(), 
+                      async (task: DyFM_SocketEventTask<T_SubscriptionContent>) => {
+                        await task(content, issuer);
+                      }
+                    );
+                  }
 
                   socket.emit(
                     DyFM_SocketEvent_Key.subscriptionSuccessful, 
@@ -332,9 +371,7 @@ export abstract class DyNTS_SocketServerService<
                       /* `${this.thisLocationStack}` */
                     );
                   }
-                  socket.emit(DyFM_SocketEvent_Key.error, error);
-                  socket.emit(DyFM_SocketEvent_Key.disconnect);
-                  socket.disconnect();
+                  await this.closeSocket(socket, issuer, error);
                 }
               }
             );
@@ -360,11 +397,20 @@ export abstract class DyNTS_SocketServerService<
                       `event: ${DyFM_SocketEvent_Key.unsubscribe}`
                     );
                   }
+
+                  /* await this.unsubscribeEvent.executeEventTasks(null, issuer); */
+                  await DyFM_Array.asyncForEach(
+                    this.incomingEvents.filter(
+                      (event: DyFM_SocketEvent<any>) => 
+                        event.eventKey === DyFM_SocketEvent_Key.unsubscribe
+                    ),
+                    async (event: DyFM_SocketEvent<any>) => {
+                      await event.executeEventTasks(null, issuer);
+                    }
+                  );
                   
                   this.removeSubscription(socket, issuer);
 
-                  await this.unsubscribeEvent.executeEventTasks(issuer, issuer);
-
                   socket.emit(
                     DyFM_SocketEvent_Key.unsubscribeSuccessful, 
                     'unsubscribe was successful', 
@@ -398,12 +444,18 @@ export abstract class DyNTS_SocketServerService<
                     );
                   }
                   socket.emit(DyFM_SocketEvent_Key.error, error);
+                  this.removeSubscription(socket, issuer);
                 }
               }
             );
           }
 
-          this.incomingEvents.forEach((event: DyFM_SocketEvent<any>) => {
+          this.incomingEvents.filter(
+            (event: DyFM_SocketEvent<any>) => 
+              event.eventKey !== DyFM_SocketEvent_Key.incomingNewConnection &&
+              event.eventKey !== DyFM_SocketEvent_Key.subscribe &&
+              event.eventKey !== DyFM_SocketEvent_Key.unsubscribe
+          ).forEach((event: DyFM_SocketEvent<any>) => {
             socket.on(
               event.eventKey, 
               async (content: any) => { 
@@ -442,8 +494,8 @@ export abstract class DyNTS_SocketServerService<
               error
             );
           }
-          socket.emit(DyFM_SocketEvent_Key.error, error);
-          socket.disconnect();
+
+          await this.closeSocket(socket, `${this.params.name} on connection error`, error);
         }
       });
         
@@ -516,8 +568,83 @@ export abstract class DyNTS_SocketServerService<
     }
   }
 
+  protected async closeSocket(socket: SocketIO.Socket, issuer: string, withError?: DyFM_AnyError): Promise<void> {
+    try {
+      if (withError) {
+        socket.emit(DyFM_SocketEvent_Key.error, withError);
+      }
+
+      await DyFM_Array.asyncForEach(
+        this.incomingEvents.filter(
+          (event: DyFM_SocketEvent<any>) => 
+            event.eventKey === DyFM_SocketEvent_Key.disconnect
+        ), 
+        async (event: DyFM_SocketEvent<any>) => {
+          await event.executeEventTasks(null, issuer);
+        }
+      );
+
+      /* if (this.getSubscriptionCloseTasks) {
+        await DyFM_Array.asyncForEach(
+          this.getSubscriptionCloseTasks(), 
+          async (task: DyFM_SocketEventTask<null>) => {
+            await task(null, issuer);
+          }
+        );
+      } */
+
+      socket.emit(DyFM_SocketEvent_Key.disconnect);
+      socket.disconnect();
+
+      await this.removeSocketFromPresence(socket);
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings('closeSocket', error),
+        errorCode: 'NTS-SSS-CS0',
+      });
+    }
+  }
+
+  protected async removeSocketFromPresence(socket: SocketIO.Socket): Promise<void> {
+    try {
+      const presence: T_Presence = this.presences.find(
+        (pres: T_Presence) => pres.sockets.includes(socket)
+      );
+   
+      if (presence) {
+        const socketIndex: number = presence.sockets.indexOf(socket);
+
+        if (socketIndex !== -1) {
+          presence.sockets.splice(socketIndex, 1);
+        }
+        
+        if (presence.sockets.length === 0) {
+          const presenceIndex: number = this.presences.indexOf(presence); 
+          
+          if (presenceIndex !== -1) {
+            this.presences.splice(presenceIndex, 1);
+          }
+        }
+      }
+    } catch (error) {
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings('removeSocketFromPresence', error),
+        errorCode: 'NTS-SSS-RSO0',
+      });
+    }
+  }
+
   private async disconnectBaseTask(socket: SocketIO.Socket, issuer: string): Promise<void> {
     try {
+      if (!(socket instanceof SocketIO.Socket)) {
+        throw new DyFM_Error({
+          ...this._getDefaultErrorSettings(
+            'disconnectBaseTask',
+            new Error('Socket is not a SocketIO.Socket'),
+          ),
+        });
+      }
+
       await this.removeSubscription(socket, issuer);
 
       DyFM_Log.info(`< x >  socket(${this.params.name}) disconnected (${issuer})`);
@@ -547,7 +674,7 @@ export abstract class DyNTS_SocketServerService<
             new Error(
               `closing socket(${this.params.name}) does not match any in the activePresences`
             ), 
-            issuer
+            issuer ?? 'unknown issuer'
           ),
 
           errorCode: 'NTS-SSS-RS1',
@@ -556,12 +683,12 @@ export abstract class DyNTS_SocketServerService<
 
       const activePresence: DyNTS_SocketPresence = this.presences[activePresenceIndex];
 
-      if (activePresence.issuerLocalId !== issuer) {
+      if (issuer && activePresence.issuerLocalId !== issuer) {
         throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
             'sendEventForId',
             new Error(
-              `socket subscription for "${issuer}" and ` +
+              `socket unsubscription for "${issuer}" and ` +
               `"${activePresence.issuerLocalId}" does not match.`
             ),
             issuer
@@ -580,7 +707,7 @@ export abstract class DyNTS_SocketServerService<
             new Error(
               `closing socket(${this.params.name}) does not match any in the activePresences`
             ),
-            issuer
+            activePresence.issuerLocalId
           ),
 
           errorCode: 'NTS-SSS-RS3',
@@ -588,20 +715,31 @@ export abstract class DyNTS_SocketServerService<
       }
 
       activePresence.sockets.splice(socketIndex);
+      
+      await DyFM_Array.asyncForEach(
+        this.incomingEvents.filter(
+          (event: DyFM_SocketEvent<any>) => 
+            event.eventKey === DyFM_SocketEvent_Key.unsubscribeSuccessful
+        ), 
+        async (event: DyFM_SocketEvent<any>) => {
+          await event.executeEventTasks(null, issuer);
+        }
+      );
 
-      if (this.getSubscriptionCloseTasks) {
+      /* if (this.getSubscriptionCloseTasks) {
         await DyFM_Array.asyncForEach(
           this.getSubscriptionCloseTasks(), 
           async (task: DyFM_SocketEventTask<null>) => {
             await task(null, issuer);
           }
         );
-      }
+      } */
 
       if (activePresence.sockets.length === 0) {
         this.presences.splice(activePresenceIndex);
       }
 
+      socket.emit(DyFM_SocketEvent_Key.unsubscribeSuccessful, 'unsubscribe was successful');
       socket.disconnect();
       DyFM_Log.info(`<x==>  socket(${this.params.name}) unsubscription successful (${issuer})`);
     } catch (error) {
@@ -609,7 +747,7 @@ export abstract class DyNTS_SocketServerService<
         ...this._getDefaultErrorSettings(
           'sendEventForId',
           error,
-          issuer
+          issuer ?? 'unknown issuer'
         ),
 
         errorCode: 'NTS-SSS-RS0',
@@ -775,8 +913,14 @@ export abstract class DyNTS_SocketServerService<
         presence.emitEvent(event, content, issuer);
       });
     } catch (error) {
-      DyFM_Log.error(`socket(${this.params.name}) Event Broadcast (${event}) failed`, error);
-      
+      if (DyNTS_global_settings.log_settings.detailedErrors) {
+        if (error instanceof DyFM_Error) {
+          error.logSimple(`socket(${this.params.name}) Event Broadcast (${event}) failed`);
+        } else {
+          DyFM_Log.error(`socket(${this.params.name}) Event Broadcast (${event}) failed`, error);
+        }
+      }
+
       throw new DyFM_Error({
         ...this._getDefaultErrorSettings('broadcastEvent', error),
         
@@ -813,31 +957,33 @@ export abstract class DyNTS_SocketServerService<
    * You must setup events and required services in this function
    */
   protected abstract getIncomingEvents(): DyFM_SocketEvent<any>[];
-
-  /**
-   * You can setup tasks for the subscription event in this function
-   */
-  protected getSubscriptionTasks?(): DyFM_SocketEventTask<T_SubscriptionContent>[];
   
   /**
    * You can setup tasks for the subscription event in this function
    */
-  protected getSubscriptionCloseTasks?(): DyFM_SocketEventTask<null>[];
+  /* protected getSubscriptionCloseTasks?(): DyFM_SocketEventTask<null>[]; */
 
   /**
    * You can setup preprocesses for the subscription event in this function
    */
-  protected getSubscriptionPreProcesses?(): DyFM_SocketEventPreprocessTask[];
+  /* protected getSubscriptionPreProcesses?(): DyFM_SocketEventPreprocessTask[]; */
+
+  /**
+   * You can setup tasks for the subscription event in this function
+   * This will happen after the presence is created
+   * If this throws an error, the socket will be closed
+   */
+  protected getSubscriptionTasks?(): DyFM_SocketEventTask<T_SubscriptionContent>[];
 
   /**
    * You can setup tasks for the unsubscribe event in this function
    */
-  protected getUnsubscribeTasks?(): DyFM_SocketEventTask<T_SubscriptionContent>[];
+  /* protected getUnsubscribeTasks?(): DyFM_SocketEventTask<T_SubscriptionContent>[]; */
 
   /**
    * You can setup preprocesses for the unsubscribe event in this function
    */
-  protected getUnsubscribePreProcesses?(): DyFM_SocketEventPreprocessTask[];
+  /* protected getUnsubscribePreProcesses?(): DyFM_SocketEventPreprocessTask[]; */
 
   /**
    * You can setup tasks for the error event in this function