@futdevpro/nts-dynamo 1.7.23 → 1.7.25

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

@@ -1,15 +1,23 @@
 
 import * as SocketIO from 'socket.io';
 
-import { Dynamo_AnyError, Dynamo_Array, Dynamo_Error, Dynamo_Error_Settings, Dynamo_Log } from '@futdevpro/fsm-dynamo';
+import { 
+  Dynamo_AnyError, Dynamo_Array, Dynamo_Error, Dynamo_Error_Settings, Dynamo_Log 
+} from '@futdevpro/fsm-dynamo';
 
 import { DynamoNTS_SingletonService } from '../base/singleton.service';
 import { dynamoNTS_globalSettings } from '../../_constants/global-settings.const';
 import { DynamoNTS_SocketEventKey } from '../../_enums/http/socket-event-type.enum';
 import { DynamoNTS_SocketSecurity } from '../../_enums/socket-security.enum';
-import { DynamoNTS_SocketServerServiceParams } from '../../_models/control-models/socket-server-service-params.control-model';
-import { DynamoNTS_SocketPresence } from '../../_models/control-models/socket-presence.control-model';
-import { DynamoNTS_SocketEvent, DynamoNTS_SocketEventPreprocessTask, DynamoNTS_SocketEventTask } from '../../_models/control-models/socket-event.control-model';
+import { 
+  DynamoNTS_SocketServerServiceParams 
+} from '../../_models/control-models/socket-server-service-params.control-model';
+import { 
+  DynamoNTS_SocketPresence 
+} from '../../_models/control-models/socket-presence.control-model';
+import { 
+  DynamoNTS_SocketEvent, DynamoNTS_SocketEventPreprocessTask, DynamoNTS_SocketEventTask 
+} from '../../_models/control-models/socket-event.control-model';
 
 /**
  * You need to define the following functions:
@@ -43,12 +51,15 @@ export abstract class DynamoNTS_SocketServerService<
   protected incomingEvents: DynamoNTS_SocketEvent<any>[];
 
   private subscriptionEvent: DynamoNTS_SocketEvent<any>;
+  private unsubscribeEvent: DynamoNTS_SocketEvent<any>;
 
   /**
    * You need to setup a function that converts subscription event content to presence.
    * You should do authentication and authorization here.
    */
-  protected abstract getPresenceFromSubscrioptionEventContent(socketSubscription: T_SubscriptionContent, socket: SocketIO.Socket): Promise<T_Presence>;
+  protected abstract getPresenceFromSubscrioptionEventContent(
+    socketSubscription: T_SubscriptionContent, socket: SocketIO.Socket
+  ): Promise<T_Presence>;
   protected presences: T_Presence[] = [];
 
   protected logSetup: boolean;
@@ -62,7 +73,10 @@ export abstract class DynamoNTS_SocketServerService<
     super();
 
     this.asyncConstructor().catch((error: any) => {
-      Dynamo_Log.error(`Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, error);
+      Dynamo_Log.error(
+        `Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, 
+        error
+      );
     });
   }
 
@@ -74,9 +88,16 @@ export abstract class DynamoNTS_SocketServerService<
 
       await this.prepareEvents();
 
-      if (this.logSetup) console.log(`Socket Server Service setup done: ${this.params.name} (${this.params.port}) serurity: ${this.params.security}\n`);
+      if (this.logSetup) console.log(
+        `Socket Server Service setup done: ${this.params.name} (${this.params.port}) ` +
+        `serurity: ${this.params.security}\n`
+      );
     } catch (error) {
-      Dynamo_Log.error(`Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, error);
+      Dynamo_Log.error(
+        `Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, 
+        error
+      );
+
       throw new Dynamo_Error({
         errorCode: 'NTS-SSS-001',
         error: error,        
@@ -90,7 +111,11 @@ export abstract class DynamoNTS_SocketServerService<
   private async prepareEvents(): Promise<void> {
     try {
       /** Setup connect event */
-      const connectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.connection);
+      const connectEventIndex = this.incomingEvents.findIndex(
+        (event: DynamoNTS_SocketEvent<any>) => 
+          event.eventKey === DynamoNTS_SocketEventKey.connection
+      );
+
       if (0 <= connectEventIndex) {
         this.connectEvent = this.incomingEvents.splice(connectEventIndex)[0];
       } else {
@@ -100,31 +125,70 @@ export abstract class DynamoNTS_SocketServerService<
       }
       this.connectEvent.serviceName = this.params.name;
 
-      /** Setup subscription event */
+      /** Setup subscriptions events */
       if (this.getPresenceFromSubscrioptionEventContent) {
-        const subscriptionEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.subscribe);
+        /** Setup subscription event */ 
+        const subscriptionEventIndex = this.incomingEvents.findIndex(
+          (event: DynamoNTS_SocketEvent<any>) => 
+            event.eventKey === DynamoNTS_SocketEventKey.subscribe
+        );
+
         if (0 <= subscriptionEventIndex) {
           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 subscriptions.`,
-            `${this.params.name} (${this.params.port})`,
+            `${this.params.name} (${this.params.port})`
           );
         } else {
           this.subscriptionEvent = new DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
-            eventKey: DynamoNTS_SocketEventKey.subscribe 
+            eventKey: DynamoNTS_SocketEventKey.subscribe,
           });
         }
+
         if (this.getSubscriptionPreProcessess) {
           this.subscriptionEvent.preProcessess.push(...this.getSubscriptionPreProcessess());
         }
+
         if (this.getSubscriptionTasks) {
           this.subscriptionEvent.tasks.push(...this.getSubscriptionTasks());
         }
         this.subscriptionEvent.serviceName = this.params.name;
+        
+        /** Setup subscription event */ 
+        const unsubscribeEventIndex = this.incomingEvents.findIndex(
+          (event: DynamoNTS_SocketEvent<any>) => 
+            event.eventKey === DynamoNTS_SocketEventKey.unsubscribe
+        );
+
+        if (0 <= unsubscribeEventIndex) {
+          this.unsubscribeEvent = this.incomingEvents.splice(unsubscribeEventIndex)[0];
+          Dynamo_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 DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
+            eventKey: DynamoNTS_SocketEventKey.unsubscribe,
+          });
+        }
+
+        if (this.getUnsubscribePreProcessess) {
+          this.unsubscribeEvent.preProcessess.push(...this.getUnsubscribePreProcessess());
+        }
+
+        if (this.getUnsubscribeTasks) {
+          this.unsubscribeEvent.tasks.push(...this.getUnsubscribeTasks());
+        }
+        this.unsubscribeEvent.serviceName = this.params.name;
 
         /** Setup disconnect event */
-        const disconnectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.disconnect);
+        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.disconnectBaseTask);
@@ -134,27 +198,33 @@ export abstract class DynamoNTS_SocketServerService<
               serviceName: this.params.name,
               eventKey: DynamoNTS_SocketEventKey.disconnect,
               tasks: [
-                this.disconnectBaseTask
-              ]
+                this.disconnectBaseTask,
+              ],
             })
           );
         }
 
         /** Setup error event */
-        const errorEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.error);
+        const errorEventIndex = this.incomingEvents.findIndex(
+          (event: DynamoNTS_SocketEvent<any>) => event.eventKey === DynamoNTS_SocketEventKey.error
+        );
+
         if (errorEventIndex == -1 && this.errorHandling) {
           this.incomingEvents.push(new DynamoNTS_SocketEvent<T_ErrorContent>({
             serviceName: this.params.name,
             eventKey: DynamoNTS_SocketEventKey.error,
             tasks: [
-              this.errorHandling
-            ]
+              this.errorHandling,
+            ],
           }));
         }
 
         this.subscriptionEvent.socketName = this.params.name;
       } else {
-        Dynamo_Log.error('getPresenceFromSubscrioptionEventContent is not set', `${this.params.name} (${this.params.port})`);
+        Dynamo_Log.error(
+          'getPresenceFromSubscrioptionEventContent is not set', 
+          `${this.params.name} (${this.params.port})`
+        );
       }
 
       /** Set incoming events serviceName */
@@ -162,12 +232,22 @@ export abstract class DynamoNTS_SocketServerService<
         event.serviceName = this.params.name;
       });
     } catch (error) {
-      Dynamo_Log.error(`Socket Server Service - Event Preparation setup failed: ${this.params?.name} (${this.params?.port})`, error);
+      Dynamo_Log.error(
+        `Socket Server Service - Event Preparation setup failed: ` +
+        `${this.params?.name} (${this.params?.port})`, 
+        error
+      );
+
       throw error;
     }
   }
 
-  async setupSocketServer(newSocketServer: SocketIO.Server, security: DynamoNTS_SocketSecurity.open | DynamoNTS_SocketSecurity.secure, successCallback: () => void): Promise<SocketIO.Server> {
+  // eslint-disable-next-line max-lines-per-function
+  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');
 
@@ -178,61 +258,142 @@ export abstract class DynamoNTS_SocketServerService<
           await this.connectEvent.executeEventTasks(socket);
 
           if (this.getPresenceFromSubscrioptionEventContent) {
-            socket.on(DynamoNTS_SocketEventKey.subscribe, async (content: any) => {
-              try {
-                /** 
-                 * 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.logSocketEventContent) {
-                  Dynamo_Log.log(
-                    `--=>   incoming socket(${this.params.name}) event: ${DynamoNTS_SocketEventKey.subscribe};` +
-                    `\ncontent:`, content
+            socket.on(
+              DynamoNTS_SocketEventKey.subscribe, 
+              async (content: any) => {
+                try {
+                  /** 
+                   * 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.logSocketEventContent) {
+                    Dynamo_Log.log(
+                      `--=>   incoming socket(${this.params.name}) ` +
+                      `event: ${DynamoNTS_SocketEventKey.subscribe};` +
+                      `\ncontent:`, content
+                    );
+                  } else {
+                    Dynamo_Log.log(
+                      `--=>   incoming socket(${this.params.name}) ` +
+                      `event: ${DynamoNTS_SocketEventKey.subscribe}`
+                    );
+                  }
+
+                  const presence: T_Presence = await this.getPresenceFromSubscrioptionEventContent(
+                    content, socket
                   );
-                } else {
-                  Dynamo_Log.log(`--=>   incoming socket(${this.params.name}) event: ${DynamoNTS_SocketEventKey.subscribe}`);
-                }
-
-                const presence: T_Presence = await this.getPresenceFromSubscrioptionEventContent(content, socket);
-                presence.serviceName = this.params.name;
-                issuer = presence.issuerId;
-      
-                this.addSocketToPresence(presence);
-                await this.subscriptionEvent.executeEventTasks(content, issuer);
 
-                socket.emit(DynamoNTS_SocketEventKey.subscriptionSuccessful, 'subscribe was successful', error => {
+                  presence.serviceName = this.params.name;
+                  issuer = presence.issuerId;
+        
+                  this.addSocketToPresence(presence);
+                  await this.subscriptionEvent.executeEventTasks(content, issuer);
+
+                  socket.emit(
+                    DynamoNTS_SocketEventKey.subscriptionSuccessful, 
+                    'subscribe was successful', 
+                    error => {
+                      Dynamo_Log.error(
+                        `Emitting subscriptionSuccessful event failed!` +
+                        `\nerror:`, error
+                      );
+                    }
+                  );
+                  
+                  Dynamo_Log.success(
+                    `<-==>  socket(${this.params.name}) subscription successfull (${issuer})`
+                  );
+                } catch (error) {
                   Dynamo_Log.error(
-                    `Emitting subscriptionSuccessful event failed!` +
-                    `\nerror:`, error
+                    `Socket Subscription failed: ${this.params.name} ` ,
+                    `(${this.params.port}) will disconnect now...`, 
+                    error
                   );
-                });
-                
-                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);
-                socket.disconnect();
+                  socket.emit(DynamoNTS_SocketEventKey.error, error);
+                  socket.disconnect();
+                }
               }
-            })
+            );
+            
+            socket.on(
+              DynamoNTS_SocketEventKey.unsubscribe, 
+              async (issuer: string) => {
+                try {
+                  /** 
+                   * usually socket logs are in event.executeEventTasks(), 
+                   * but unsubscribe event is an exception from this, 
+                   * to be able to check content before getPresenceFromSubscrioptionEventContent 
+                   */
+                  if (dynamoNTS_globalSettings.logSocketEventContent) {
+                    Dynamo_Log.log(
+                      `--=>   incoming socket(${this.params.name}) ` +
+                      `event: ${DynamoNTS_SocketEventKey.unsubscribe};` +
+                      `\ncontent:`, issuer
+                    );
+                  } else {
+                    Dynamo_Log.log(
+                      `--=>   incoming socket(${this.params.name}) ` +
+                      `event: ${DynamoNTS_SocketEventKey.unsubscribe}`
+                    );
+                  }
+                  
+                  this.removeSubscription(socket, issuer);
+
+                  await this.subscriptionEvent.executeEventTasks(issuer, issuer);
+
+                  socket.emit(
+                    DynamoNTS_SocketEventKey.unsubscribeSuccessful, 
+                    'unsubscribe was successful', 
+                    error => {
+                      Dynamo_Log.error(
+                        `Emitting unsubscribeSuccessful event failed!` +
+                        `\nerror:`, error
+                      );
+                    }
+                  );
+                  
+                  Dynamo_Log.success(
+                    `< x >  socket(${this.params.name}) unsubscribe successfull (${issuer})`
+                  );
+                } catch (error) {
+                  Dynamo_Log.error(
+                    `Socket unsubscribe failed: ${this.params.name} ` ,
+                    `(${this.params.port}) will disconnect now...`, 
+                    error
+                  );
+                  socket.emit(DynamoNTS_SocketEventKey.error, error);
+                }
+              }
+            );
           }
 
           this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
-            socket.on(event.eventKey, 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_SocketEventKey.error, error);
+            socket.on(
+              event.eventKey, 
+              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_SocketEventKey.error, error);
+                }
               }
-            });
+            );
           });
 
           if (dynamoNTS_globalSettings.logMainSocketEvents) {
             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);
+          Dynamo_Log.error(
+            `Socket Connection failed: ${this.params.name} ` +
+            `(${this.params.port}) will disconnect now...`, 
+            error
+          );
           socket.emit(DynamoNTS_SocketEventKey.error, error);
           socket.disconnect();
         }
@@ -249,20 +410,29 @@ export abstract class DynamoNTS_SocketServerService<
       
       if (security === DynamoNTS_SocketSecurity.open) {
         this.openSocketServer = newSocketServer;
+
         return this.openSocketServer;
       } else {
         this.secureSocketServer = newSocketServer;
+
         return this.secureSocketServer;
       }
     } catch (error) {
-      Dynamo_Log.error(`Socket Server Service - Deep Setup failed: ${this.params?.name} (${this.params?.port})`, error);
+      Dynamo_Log.error(
+        `Socket Server Service - Deep Setup failed: ${this.params?.name} ` +
+        `(${this.params?.port})`, 
+        error
+      );
+
       throw error;
     }
   }
 
   protected async addSocketToPresence(newPresence: T_Presence): Promise<void> {
     try {
-      const activePresence: T_Presence = this.presences.find((pres: T_Presence) => pres.issuerId === newPresence.issuerId);
+      const activePresence: T_Presence = this.presences.find(
+        (pres: T_Presence) => pres.issuerId === newPresence.issuerId
+      );
       
       if (activePresence) {
         activePresence.sockets.push(...newPresence.sockets);
@@ -270,7 +440,11 @@ export abstract class DynamoNTS_SocketServerService<
         this.presences.push(newPresence);
       }
     } catch (error) {
-      Dynamo_Log.error(`Socket Subscription failed: ${this.params?.name} (${this.params?.port})`, error);
+      Dynamo_Log.error(
+        `Socket Subscription failed: ${this.params?.name} (${this.params?.port})`, 
+        error
+      );
+
       throw error;
     }
   }
@@ -285,23 +459,27 @@ export abstract class DynamoNTS_SocketServerService<
         ...this._getDefaultErrorSettings(
           'disconnectBaseTask',
           error,
-          issuer,
+          issuer
         ),
 
-        errorCode: 'NTS-SSS-109'
+        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));
+      const activePresenceIndex: number = this.presences.findIndex(
+        (pres: DynamoNTS_SocketPresence) => pres.sockets.includes(socket)
+      );
       
       if (activePresenceIndex === -1) {
         throw new Dynamo_Error({
           ...this._getDefaultErrorSettings(
             'sendEventForId', 
-            new Error(`closing socket(${this.params.name}) does not match any in the activePresences`), 
+            new Error(
+              `closing socket(${this.params.name}) does not match any in the activePresences`
+            ), 
             issuer
           ),
 
@@ -310,11 +488,14 @@ export abstract class DynamoNTS_SocketServerService<
       }
 
       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.`),
+            new Error(
+              `socket subscription for ${issuer} and ${activePresence.issuerId} does not match.`
+            ),
             issuer
           ),
 
@@ -323,11 +504,14 @@ export abstract class DynamoNTS_SocketServerService<
       }
 
       const socketIndex = activePresence.sockets.findIndex((s: SocketIO.Socket) => s === socket);
+
       if (socketIndex === -1) {
         throw new Dynamo_Error({
           ...this._getDefaultErrorSettings(
             'sendEventForId',
-            new Error(`closing socket(${this.params.name}) does not match any in the activePresences`),
+            new Error(
+              `closing socket(${this.params.name}) does not match any in the activePresences`
+            ),
             issuer
           ),
 
@@ -336,10 +520,14 @@ export abstract class DynamoNTS_SocketServerService<
       }
 
       activePresence.sockets.splice(socketIndex);
+
       if (this.getSubscriptionCloseTasks) {
-        await Dynamo_Array.asyncForEach(this.getSubscriptionCloseTasks(), async (task: DynamoNTS_SocketEventTask<null>) => {
-          await task(null, issuer);
-        });
+        await Dynamo_Array.asyncForEach(
+          this.getSubscriptionCloseTasks(), 
+          async (task: DynamoNTS_SocketEventTask<null>) => {
+            await task(null, issuer);
+          }
+        );
       }
 
       if (activePresence.sockets.length === 0) {
@@ -384,7 +572,9 @@ export abstract class DynamoNTS_SocketServerService<
 
   idIsSubscribed(id: string): boolean {
     try {
-      return !!this.presences.find((presence: DynamoNTS_SocketPresence) => presence.issuerId === id);
+      return !!this.presences.find(
+        (presence: DynamoNTS_SocketPresence) => presence.issuerId === id
+      );
     } catch (error) {
       throw new Dynamo_Error({
         ...this._getDefaultErrorSettings(
@@ -417,7 +607,9 @@ export abstract class DynamoNTS_SocketServerService<
 
   async sendEventForId(id: string, event: string, content: any, issuer: string): Promise<void> {
     try {
-      const presence: DynamoNTS_SocketPresence = this.presences.find((pres: DynamoNTS_SocketPresence) => pres.issuerId === id);
+      const presence: DynamoNTS_SocketPresence = this.presences.find(
+        (pres: DynamoNTS_SocketPresence) => pres.issuerId === id
+      );
 
       if (!presence) {
         throw new Dynamo_Error({ 
@@ -435,9 +627,16 @@ export abstract class DynamoNTS_SocketServerService<
       presence.emitEvent(event, content, issuer);
 
       if (dynamoNTS_globalSettings.logSocketEventContent) {
-        Dynamo_Log.success(` <--=  emitted socket(${this.params.name}) event for presence: ${event}, presenceId: ${id}) \ncontent:`, content);
+        Dynamo_Log.success(
+          ` <--=  emitted socket(${this.params.name}) event for presence: ${event}, ` +
+          `presenceId: ${id}, sockets: ${presence.sockets.length}` +
+          `\ncontent:`, content
+        );
       } else {
-        Dynamo_Log.success(` <--=  emitted socket(${this.params.name}) event for presence: ${event}, presenceId: ${id})`);
+        Dynamo_Log.success(
+          ` <--=  emitted socket(${this.params.name}) event for presence: ${event}, ` +
+          `presenceId: ${id}, sockets: ${presence.sockets.length}`
+        );
       }
     } catch (error) {
       try {
@@ -448,7 +647,10 @@ export abstract class DynamoNTS_SocketServerService<
             await this.removeSubscription(socket);
           });
 
-          const presence: DynamoNTS_SocketPresence = this.presences.find((pres: DynamoNTS_SocketPresence) => pres.issuerId === id);
+          const presence: DynamoNTS_SocketPresence = this.presences.find(
+            (pres: DynamoNTS_SocketPresence) => pres.issuerId === id
+          );
+
           if (!presence) {
             throw new Dynamo_Error({ 
               ...this._getDefaultErrorSettings(
@@ -535,13 +737,23 @@ export abstract class DynamoNTS_SocketServerService<
   /**
    * You can setup tasks for the subscription event in this function
    */
-   protected getSubscriptionCloseTasks?(): DynamoNTS_SocketEventTask<null>[];
+  protected getSubscriptionCloseTasks?(): DynamoNTS_SocketEventTask<null>[];
 
   /**
    * You can setup preprocessess for the subscription event in this function
    */
   protected getSubscriptionPreProcessess?(): DynamoNTS_SocketEventPreprocessTask[];
 
+  /**
+   * You can setup tasks for the unsubscribe event in this function
+   */
+  protected getUnsubscribeTasks?(): DynamoNTS_SocketEventTask<T_SubscriptionContent>[];
+
+  /**
+   * You can setup preprocessess for the unsubscribe event in this function
+   */
+  protected getUnsubscribePreProcessess?(): DynamoNTS_SocketEventPreprocessTask[];
+
   /**
    * You can setup tasks for the error event in this function
    */