@futdevpro/nts-dynamo 1.9.15 → 1.9.16

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

@@ -1,761 +1,761 @@
-
-import * as SocketIO from 'socket.io';
-
-import { 
-  DynamoFM_AnyError, DynamoFM_Array, DynamoFM_Error, DynamoFM_Error_Settings, DynamoFM_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_SocketServerService_Params 
-} 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:
- * ```ts
- * getServiceParams(): DynamoNTS_SocketServerServiceParams;
- * 
- * getIncomingEvents(): DynamoNTS_SocketEvent<any>[];
- * 
- * getPresenceFromSubscrioptionEventContent(  
- *  socketSubscription: T_SubscriptionContent,  
- *  socket: SocketIO.Socket  
- * ): Promise<T_Presence>;  
- * ```
- */
-export abstract class DynamoNTS_SocketServerService<
-      T_Presence extends DynamoNTS_SocketPresence = DynamoNTS_SocketPresence, 
-      T_SubscriptionContent = any, 
-      T_ErrorContent = any
-    > extends DynamoNTS_SingletonService {
-
-  protected params: DynamoNTS_SocketServerService_Params;
-  get name(): string { return this.params.name; }
-  get port(): number { return this.params.port; }
-  get security(): DynamoNTS_SocketSecurity { return this.params.security; }
-  get activeSubscriptionsCount(): number { return this.presences.length; }
-
-  protected openSocketServer: SocketIO.Server;
-  protected secureSocketServer: SocketIO.Server;
-
-  private connectEvent: DynamoNTS_SocketEvent<SocketIO.Socket>;
-  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 presences: T_Presence[] = [];
-
-  protected logSetup: boolean;
-  protected logFn: boolean;
-
-  defaultErrorUserMsg = 
-    `We encountered an unhandled Socket Server Error, ` +
-    `\nplease contact the responsible development team.`;
-
-  constructor(){
-    super();
-
-    this.asyncConstructor().catch((error: any) => {
-      DynamoFM_Log.error(
-        `Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, 
-        error
-      );
-    });
-  }
-
-  private async asyncConstructor(): Promise<void> {
-    try {
-      this.logSetup = DynamoNTS_globalSettings.logSetup;
-      this.params = this.getServiceParams();
-      this.incomingEvents = this.getIncomingEvents() ?? [];
-
-      await this.prepareEvents();
-
-      if (this.logSetup) console.log(
-        `Socket Server Service setup done: ${this.params.name} (${this.params.port}) ` +
-        `serurity: ${this.params.security}\n`
-      );
-    } catch (error) {
-      DynamoFM_Log.error(
-        `Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, 
-        error
-      );
-
-      throw new DynamoFM_Error({
-        errorCode: 'NTS-SSS-001',
-        error: error,        
-      });
-    }
-  }
-
-  /**
-   * You must setup events and required services for this function
-   */
-  private async prepareEvents(): Promise<void> {
-    try {
-      /** Setup connect event */
-      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 {
-        this.connectEvent = new DynamoNTS_SocketEvent({
-          eventKey: DynamoNTS_SocketEventKey.connection,
-        });
-      }
-      this.connectEvent.serviceName = this.params.name;
-
-      /** Setup subscriptions events */
-      if (this.getPresenceFromSubscrioptionEventContent) {
-        /** 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];
-          DynamoFM_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 DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
-            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];
-          DynamoFM_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
-        );
-
-        if (0 <= disconnectEventIndex) {
-          this.incomingEvents[disconnectEventIndex].serviceName = this.params.name;
-          this.incomingEvents[disconnectEventIndex].tasks.push(this.disconnectBaseTask);
-        } else {
-          this.incomingEvents.push(
-            new DynamoNTS_SocketEvent({
-              serviceName: this.params.name,
-              eventKey: DynamoNTS_SocketEventKey.disconnect,
-              tasks: [
-                this.disconnectBaseTask,
-              ],
-            })
-          );
-        }
-
-        /** Setup error event */
-        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.subscriptionEvent.socketName = this.params.name;
-      } else {
-        DynamoFM_Log.error(
-          'getPresenceFromSubscrioptionEventContent is not set', 
-          `${this.params.name} (${this.params.port})`
-        );
-      }
-
-      /** Set incoming events serviceName */
-      this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
-        event.serviceName = this.params.name;
-      });
-    } catch (error) {
-      DynamoFM_Log.error(
-        `Socket Server Service - Event Preparation setup failed: ` +
-        `${this.params?.name} (${this.params?.port})`, 
-        error
-      );
-
-      throw error;
-    }
-  }
-
-  // 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');
-
-      newSocketServer.on(DynamoNTS_SocketEventKey.connection, async (socket: SocketIO.Socket) => {
-        try {
-          let issuer: string;
-
-          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) {
-                    DynamoFM_Log.log(
-                      `--=>   incoming socket(${this.params.name}) ` +
-                      `event: ${DynamoNTS_SocketEventKey.subscribe};` +
-                      `\ncontent:`, content
-                    );
-                  } else {
-                    DynamoFM_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 => {
-                      DynamoFM_Log.error(
-                        `Emitting subscriptionSuccessful event failed!` +
-                        `\nerror:`, error
-                      );
-                    }
-                  );
-                  
-                  DynamoFM_Log.success(
-                    `<-==>  socket(${this.params.name}) subscription successfull (${issuer})`
-                  );
-                } catch (error) {
-                  DynamoFM_Log.error(
-                    `Socket Subscription failed: ${this.params.name} ` ,
-                    `(${this.params.port}) will disconnect now...`, 
-                    error
-                  );
-                  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) {
-                    DynamoFM_Log.log(
-                      `--=>   incoming socket(${this.params.name}) ` +
-                      `event: ${DynamoNTS_SocketEventKey.unsubscribe};` +
-                      `\ncontent:`, issuer
-                    );
-                  } else {
-                    DynamoFM_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 => {
-                      DynamoFM_Log.error(
-                        `Emitting unsubscribeSuccessful event failed!` +
-                        `\nerror:`, error
-                      );
-                    }
-                  );
-                  
-                  DynamoFM_Log.success(
-                    `< x >  socket(${this.params.name}) unsubscribe successfull (${issuer})`
-                  );
-                } catch (error) {
-                  DynamoFM_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) {
-                  DynamoFM_Log.error(
-                    `Socket Event failed: ${this.params.name} (${this.params.port})`, 
-                    error
-                  );
-                  socket.emit(DynamoNTS_SocketEventKey.error, error);
-                }
-              }
-            );
-          });
-
-          if (DynamoNTS_globalSettings.logMainSocketEvents) {
-            DynamoFM_Log.success(`<   >  socket(${this.params.name}): new CONNECTION established`);
-          }
-        } catch (error) {
-          DynamoFM_Log.error(
-            `Socket Connection failed: ${this.params.name} ` +
-            `(${this.params.port}) will disconnect now...`, 
-            error
-          );
-          socket.emit(DynamoNTS_SocketEventKey.error, error);
-          socket.disconnect();
-        }
-      });
-        
-      newSocketServer.listen(this.params.port);
-      
-      DynamoFM_Log.success(
-        `\nsocket server setup finished: ${this.params.name}` + 
-        `\nsocket server listening on port: ${this.params.port}`
-      );
-
-      successCallback();
-      
-      if (security === DynamoNTS_SocketSecurity.open) {
-        this.openSocketServer = newSocketServer;
-
-        return this.openSocketServer;
-      } else {
-        this.secureSocketServer = newSocketServer;
-
-        return this.secureSocketServer;
-      }
-    } catch (error) {
-      DynamoFM_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
-      );
-      
-      if (activePresence) {
-        activePresence.sockets.push(...newPresence.sockets);
-      } else {
-        this.presences.push(newPresence);
-      }
-    } catch (error) {
-      DynamoFM_Log.error(
-        `Socket Subscription failed: ${this.params?.name} (${this.params?.port})`, 
-        error
-      );
-
-      throw error;
-    }
-  }
-
-  private async disconnectBaseTask(socket: SocketIO.Socket, issuer: string): Promise<void> {
-    try {
-      await this.removeSubscription(socket, issuer);
-
-      DynamoFM_Log.info(`< x >  socket(${this.params.name}) disconnected (${issuer})`);
-    } catch (error) {
-      throw new DynamoFM_Error({
-        ...this._getDefaultErrorSettings(
-          'disconnectBaseTask',
-          error,
-          issuer
-        ),
-
-        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)
-      );
-      
-      if (activePresenceIndex === -1) {
-        throw new DynamoFM_Error({
-          ...this._getDefaultErrorSettings(
-            'sendEventForId', 
-            new Error(
-              `closing socket(${this.params.name}) does not match any in the activePresences`
-            ), 
-            issuer
-          ),
-
-          errorCode: 'NTS-SSS-203',
-        });
-      }
-
-      const activePresence: DynamoNTS_SocketPresence = this.presences[activePresenceIndex];
-
-      if (activePresence.issuerId !== issuer) {
-        throw new DynamoFM_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 DynamoFM_Error({
-          ...this._getDefaultErrorSettings(
-            'sendEventForId',
-            new Error(
-              `closing socket(${this.params.name}) does not match any in the activePresences`
-            ),
-            issuer
-          ),
-
-          errorCode: 'NTS-SSS-202',
-        });
-      }
-
-      activePresence.sockets.splice(socketIndex);
-
-      if (this.getSubscriptionCloseTasks) {
-        await DynamoFM_Array.asyncForEach(
-          this.getSubscriptionCloseTasks(), 
-          async (task: DynamoNTS_SocketEventTask<null>) => {
-            await task(null, issuer);
-          }
-        );
-      }
-
-      if (activePresence.sockets.length === 0) {
-        this.presences.splice(activePresenceIndex);
-      }
-
-      socket.disconnect();
-      DynamoFM_Log.info(`<x==>  socket(${this.params.name}) unsubscription successfull (${issuer})`);
-    } catch (error) {
-      throw new DynamoFM_Error({
-        ...this._getDefaultErrorSettings(
-          'sendEventForId',
-          error,
-          issuer
-        ),
-
-        errorCode: 'NTS-SSS-200',
-        message: `socket(${this.params.name}) Subscription Removal failed: ${this.params?.name}`,
-      });
-    }
-  }
-
-  /* emitServerEvent(event: string, content: any): void {
-    try {
-      DynamoFM_Log.log(` <=--  emitting server socket(${this.params.name}) event: ${event}`);
-
-      this.openSocketServer.emit(event, content, error => {
-        DynamoFM_Log.error(`Emitting server event '${event}' failed!\nerror:`, error);
-      });
-    } catch (error) {
-      throw new DynamoFM_Error({
-        ...this._getDefaultErrorSettings(
-          'emitEvent',
-          error
-        ),
-
-        errorCode: 'NTS-SSS-500',
-        message: `socket(${this.params.name}) Event Emit (${event}) failed: ${this.params?.name}`,
-      });
-    }
-  } */
-
-  idIsSubscribed(id: string): boolean {
-    try {
-      return !!this.presences.find(
-        (presence: DynamoNTS_SocketPresence) => presence.issuerId === id
-      );
-    } catch (error) {
-      throw new DynamoFM_Error({
-        ...this._getDefaultErrorSettings(
-          'idIsSubscribed',
-          error
-        ),
-
-        errorCode: 'NTS-SSS-600',
-        message: `socket(${this.params.name}) ID Subscription Check (${id}) failed`,
-      });
-    }
-  }
-
-  async emitError(presenceIssuerId: string, error: any, issuer: string): Promise<void> {
-    try {
-      await this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEventKey.error, error, issuer);
-    } catch (error) {
-      throw new DynamoFM_Error({
-        ...this._getDefaultErrorSettings(
-          'emitError',
-          error,
-          presenceIssuerId
-        ),
-
-        errorCode: 'NTS-SSS-700',
-        message: `socket(${this.params.name}) Error Emit (id: ${presenceIssuerId}) failed`,
-      });
-    }
-  }
-
-  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
-      );
-
-      if (!presence) {
-        throw new DynamoFM_Error({ 
-          ...this._getDefaultErrorSettings(
-            'sendEventForId',
-            new Error(`No active socket with this specific ID: ${id}`),
-            content?.source
-          ),
-
-          status: 404, 
-          errorCode: 'NTS-SSS-301',
-        });
-      }
-
-      presence.emitEvent(event, content, issuer);
-
-      if (DynamoNTS_globalSettings.logSocketEventContent) {
-        DynamoFM_Log.success(
-          ` <--=  emitted socket(${this.params.name}) event for presence: ${event}, ` +
-          `\n  presenceId: ${id}, sockets: ${presence.sockets.length}` +
-          `\n  content:`, content
-        );
-      } else {
-        DynamoFM_Log.success(
-          ` <--=  emitted socket(${this.params.name}) event for presence: ${event}, ` +
-          `\n  presenceId: ${id}, sockets: ${presence.sockets.length}`
-        );
-      }
-    } catch (error) {
-      try {
-        if (error.flag.includes('DYNAMO') && error?.accitionalInfo?.inactiveSockets) {
-          const sockets: SocketIO.Socket[] = error.accitionalInfo.inactiveSockets;
-
-          await DynamoFM_Array.asyncForEach(sockets, async (socket: SocketIO.Socket) => {
-            await this.removeSubscription(socket);
-          });
-
-          const presence: DynamoNTS_SocketPresence = this.presences.find(
-            (pres: DynamoNTS_SocketPresence) => pres.issuerId === id
-          );
-
-          if (!presence) {
-            throw new DynamoFM_Error({ 
-              ...this._getDefaultErrorSettings(
-                'sendEventForId',
-                new Error(`No active socket(${this.params.name}) with this specific ID: ${id}`),
-                content?.source
-              ),
-
-              status: 404, 
-              errorCode: 'NTS-SSS-302',
-            });
-          }
-        }
-      } catch (error) {
-        throw new DynamoFM_Error({
-          ...this._getDefaultErrorSettings('sendEventForId', error, content?.source),
-  
-          errorCode: 'NTS-SSS-310',
-          message: 
-            `Error handling of inactive sockets(${this.params.name}) failed!` +
-            `\n(Socket Event Emit for id (${id}, ${event}) failed)`,
-        });
-      }
-
-      throw new DynamoFM_Error({
-        ...this._getDefaultErrorSettings('sendEventForId', error, content?.source),
-
-        errorCode: 'NTS-SSS-310',
-        message: `socket(${this.params.name}) Event Emit for id (${id}, ${event}) failed`,
-      });
-    }
-  }
-
-  broadcastEvent(event: string, content: any, issuer: string): void {
-    try {
-      DynamoFM_Log.log(` <=-== broadcasting socket(${this.params.name}) event: ${event}`);
-
-      this.presences.forEach((presence: DynamoNTS_SocketPresence) => {
-        presence.emitEvent(event, content, issuer);
-      });
-    } catch (error) {
-      DynamoFM_Log.error(`socket(${this.params.name}) Event Broadcast (${event}) failed`, error);
-      
-      throw new DynamoFM_Error({
-        ...this._getDefaultErrorSettings('broadcastEvent', error),
-        
-        errorCode: 'NTS-SSS-400',
-        message: `socket(${this.params.name}) Event Broadcast (${event}) failed`,
-      });
-    }
-  }
-
-  private _getDefaultErrorSettings(
-    fnName: string, 
-    error: DynamoFM_AnyError, 
-    issuer?: string
-  ): DynamoFM_Error_Settings {
-    return {
-      status: (error as DynamoFM_Error)?.___status ?? 500,
-      message: (error as Error)?.message ?? `${fnName} was UNSUCCESFUL (NTS)`,
-      addECToUserMsg: !(error as DynamoFM_Error)?.__userMessage,
-      userMessage: (error as DynamoFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
-      issuer: issuer,
-      issuerService: this.constructor?.name,
-      error: error,
-    };
-  }
-
-  /**
-   * You must setup params for the service in this function
-   */
-  protected abstract getServiceParams(): DynamoNTS_SocketServerService_Params;
-
-  /**
-   * You must setup events and required services in this function
-   */
-  protected abstract getIncomingEvents(): DynamoNTS_SocketEvent<any>[];
-
-  /**
-   * You can setup tasks for the subscription event in this function
-   */
-  protected getSubscriptionTasks?(): DynamoNTS_SocketEventTask<T_SubscriptionContent>[];
-  
-  /**
-   * You can setup tasks for the subscription event in this function
-   */
-  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
-   */
-  protected errorHandling?: DynamoNTS_SocketEventTask<T_ErrorContent>;
-}
+
+import * as SocketIO from 'socket.io';
+
+import { 
+  DynamoFM_AnyError, DynamoFM_Array, DynamoFM_Error, DynamoFM_Error_Settings, DynamoFM_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_SocketServerService_Params 
+} 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:
+ * ```ts
+ * getServiceParams(): DynamoNTS_SocketServerServiceParams;
+ * 
+ * getIncomingEvents(): DynamoNTS_SocketEvent<any>[];
+ * 
+ * getPresenceFromSubscrioptionEventContent(  
+ *  socketSubscription: T_SubscriptionContent,  
+ *  socket: SocketIO.Socket  
+ * ): Promise<T_Presence>;  
+ * ```
+ */
+export abstract class DynamoNTS_SocketServerService<
+      T_Presence extends DynamoNTS_SocketPresence = DynamoNTS_SocketPresence, 
+      T_SubscriptionContent = any, 
+      T_ErrorContent = any
+    > extends DynamoNTS_SingletonService {
+
+  protected params: DynamoNTS_SocketServerService_Params;
+  get name(): string { return this.params.name; }
+  get port(): number { return this.params.port; }
+  get security(): DynamoNTS_SocketSecurity { return this.params.security; }
+  get activeSubscriptionsCount(): number { return this.presences.length; }
+
+  protected openSocketServer: SocketIO.Server;
+  protected secureSocketServer: SocketIO.Server;
+
+  private connectEvent: DynamoNTS_SocketEvent<SocketIO.Socket>;
+  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 presences: T_Presence[] = [];
+
+  protected logSetup: boolean;
+  protected logFn: boolean;
+
+  defaultErrorUserMsg = 
+    `We encountered an unhandled Socket Server Error, ` +
+    `\nplease contact the responsible development team.`;
+
+  constructor(){
+    super();
+
+    this.asyncConstructor().catch((error: any) => {
+      DynamoFM_Log.error(
+        `Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, 
+        error
+      );
+    });
+  }
+
+  private async asyncConstructor(): Promise<void> {
+    try {
+      this.logSetup = DynamoNTS_globalSettings.logSetup;
+      this.params = this.getServiceParams();
+      this.incomingEvents = this.getIncomingEvents() ?? [];
+
+      await this.prepareEvents();
+
+      if (this.logSetup) console.log(
+        `Socket Server Service setup done: ${this.params.name} (${this.params.port}) ` +
+        `serurity: ${this.params.security}\n`
+      );
+    } catch (error) {
+      DynamoFM_Log.error(
+        `Socket Server Service setup failed: ${this.params?.name} (${this.params?.port})`, 
+        error
+      );
+
+      throw new DynamoFM_Error({
+        errorCode: 'NTS-SSS-001',
+        error: error,        
+      });
+    }
+  }
+
+  /**
+   * You must setup events and required services for this function
+   */
+  private async prepareEvents(): Promise<void> {
+    try {
+      /** Setup connect event */
+      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 {
+        this.connectEvent = new DynamoNTS_SocketEvent({
+          eventKey: DynamoNTS_SocketEventKey.connection,
+        });
+      }
+      this.connectEvent.serviceName = this.params.name;
+
+      /** Setup subscriptions events */
+      if (this.getPresenceFromSubscrioptionEventContent) {
+        /** 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];
+          DynamoFM_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 DynamoNTS_SocketEvent<T_SubscriptionContent>({ 
+            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];
+          DynamoFM_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
+        );
+
+        if (0 <= disconnectEventIndex) {
+          this.incomingEvents[disconnectEventIndex].serviceName = this.params.name;
+          this.incomingEvents[disconnectEventIndex].tasks.push(this.disconnectBaseTask);
+        } else {
+          this.incomingEvents.push(
+            new DynamoNTS_SocketEvent({
+              serviceName: this.params.name,
+              eventKey: DynamoNTS_SocketEventKey.disconnect,
+              tasks: [
+                this.disconnectBaseTask,
+              ],
+            })
+          );
+        }
+
+        /** Setup error event */
+        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.subscriptionEvent.socketName = this.params.name;
+      } else {
+        DynamoFM_Log.error(
+          'getPresenceFromSubscrioptionEventContent is not set', 
+          `${this.params.name} (${this.params.port})`
+        );
+      }
+
+      /** Set incoming events serviceName */
+      this.incomingEvents.forEach((event: DynamoNTS_SocketEvent<any>) => {
+        event.serviceName = this.params.name;
+      });
+    } catch (error) {
+      DynamoFM_Log.error(
+        `Socket Server Service - Event Preparation setup failed: ` +
+        `${this.params?.name} (${this.params?.port})`, 
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  // 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');
+
+      newSocketServer.on(DynamoNTS_SocketEventKey.connection, async (socket: SocketIO.Socket) => {
+        try {
+          let issuer: string;
+
+          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) {
+                    DynamoFM_Log.log(
+                      `--=>   incoming socket(${this.params.name}) ` +
+                      `event: ${DynamoNTS_SocketEventKey.subscribe};` +
+                      `\ncontent:`, content
+                    );
+                  } else {
+                    DynamoFM_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 => {
+                      DynamoFM_Log.error(
+                        `Emitting subscriptionSuccessful event failed!` +
+                        `\nerror:`, error
+                      );
+                    }
+                  );
+                  
+                  DynamoFM_Log.success(
+                    `<-==>  socket(${this.params.name}) subscription successfull (${issuer})`
+                  );
+                } catch (error) {
+                  DynamoFM_Log.error(
+                    `Socket Subscription failed: ${this.params.name} ` ,
+                    `(${this.params.port}) will disconnect now...`, 
+                    error
+                  );
+                  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) {
+                    DynamoFM_Log.log(
+                      `--=>   incoming socket(${this.params.name}) ` +
+                      `event: ${DynamoNTS_SocketEventKey.unsubscribe};` +
+                      `\ncontent:`, issuer
+                    );
+                  } else {
+                    DynamoFM_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 => {
+                      DynamoFM_Log.error(
+                        `Emitting unsubscribeSuccessful event failed!` +
+                        `\nerror:`, error
+                      );
+                    }
+                  );
+                  
+                  DynamoFM_Log.success(
+                    `< x >  socket(${this.params.name}) unsubscribe successfull (${issuer})`
+                  );
+                } catch (error) {
+                  DynamoFM_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) {
+                  DynamoFM_Log.error(
+                    `Socket Event failed: ${this.params.name} (${this.params.port})`, 
+                    error
+                  );
+                  socket.emit(DynamoNTS_SocketEventKey.error, error);
+                }
+              }
+            );
+          });
+
+          if (DynamoNTS_globalSettings.logMainSocketEvents) {
+            DynamoFM_Log.success(`<   >  socket(${this.params.name}): new CONNECTION established`);
+          }
+        } catch (error) {
+          DynamoFM_Log.error(
+            `Socket Connection failed: ${this.params.name} ` +
+            `(${this.params.port}) will disconnect now...`, 
+            error
+          );
+          socket.emit(DynamoNTS_SocketEventKey.error, error);
+          socket.disconnect();
+        }
+      });
+        
+      newSocketServer.listen(this.params.port);
+      
+      DynamoFM_Log.success(
+        `\nsocket server setup finished: ${this.params.name}` + 
+        `\nsocket server listening on port: ${this.params.port}`
+      );
+
+      successCallback();
+      
+      if (security === DynamoNTS_SocketSecurity.open) {
+        this.openSocketServer = newSocketServer;
+
+        return this.openSocketServer;
+      } else {
+        this.secureSocketServer = newSocketServer;
+
+        return this.secureSocketServer;
+      }
+    } catch (error) {
+      DynamoFM_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
+      );
+      
+      if (activePresence) {
+        activePresence.sockets.push(...newPresence.sockets);
+      } else {
+        this.presences.push(newPresence);
+      }
+    } catch (error) {
+      DynamoFM_Log.error(
+        `Socket Subscription failed: ${this.params?.name} (${this.params?.port})`, 
+        error
+      );
+
+      throw error;
+    }
+  }
+
+  private async disconnectBaseTask(socket: SocketIO.Socket, issuer: string): Promise<void> {
+    try {
+      await this.removeSubscription(socket, issuer);
+
+      DynamoFM_Log.info(`< x >  socket(${this.params.name}) disconnected (${issuer})`);
+    } catch (error) {
+      throw new DynamoFM_Error({
+        ...this._getDefaultErrorSettings(
+          'disconnectBaseTask',
+          error,
+          issuer
+        ),
+
+        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)
+      );
+      
+      if (activePresenceIndex === -1) {
+        throw new DynamoFM_Error({
+          ...this._getDefaultErrorSettings(
+            'sendEventForId', 
+            new Error(
+              `closing socket(${this.params.name}) does not match any in the activePresences`
+            ), 
+            issuer
+          ),
+
+          errorCode: 'NTS-SSS-203',
+        });
+      }
+
+      const activePresence: DynamoNTS_SocketPresence = this.presences[activePresenceIndex];
+
+      if (activePresence.issuerId !== issuer) {
+        throw new DynamoFM_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 DynamoFM_Error({
+          ...this._getDefaultErrorSettings(
+            'sendEventForId',
+            new Error(
+              `closing socket(${this.params.name}) does not match any in the activePresences`
+            ),
+            issuer
+          ),
+
+          errorCode: 'NTS-SSS-202',
+        });
+      }
+
+      activePresence.sockets.splice(socketIndex);
+
+      if (this.getSubscriptionCloseTasks) {
+        await DynamoFM_Array.asyncForEach(
+          this.getSubscriptionCloseTasks(), 
+          async (task: DynamoNTS_SocketEventTask<null>) => {
+            await task(null, issuer);
+          }
+        );
+      }
+
+      if (activePresence.sockets.length === 0) {
+        this.presences.splice(activePresenceIndex);
+      }
+
+      socket.disconnect();
+      DynamoFM_Log.info(`<x==>  socket(${this.params.name}) unsubscription successfull (${issuer})`);
+    } catch (error) {
+      throw new DynamoFM_Error({
+        ...this._getDefaultErrorSettings(
+          'sendEventForId',
+          error,
+          issuer
+        ),
+
+        errorCode: 'NTS-SSS-200',
+        message: `socket(${this.params.name}) Subscription Removal failed: ${this.params?.name}`,
+      });
+    }
+  }
+
+  /* emitServerEvent(event: string, content: any): void {
+    try {
+      DynamoFM_Log.log(` <=--  emitting server socket(${this.params.name}) event: ${event}`);
+
+      this.openSocketServer.emit(event, content, error => {
+        DynamoFM_Log.error(`Emitting server event '${event}' failed!\nerror:`, error);
+      });
+    } catch (error) {
+      throw new DynamoFM_Error({
+        ...this._getDefaultErrorSettings(
+          'emitEvent',
+          error
+        ),
+
+        errorCode: 'NTS-SSS-500',
+        message: `socket(${this.params.name}) Event Emit (${event}) failed: ${this.params?.name}`,
+      });
+    }
+  } */
+
+  idIsSubscribed(id: string): boolean {
+    try {
+      return !!this.presences.find(
+        (presence: DynamoNTS_SocketPresence) => presence.issuerId === id
+      );
+    } catch (error) {
+      throw new DynamoFM_Error({
+        ...this._getDefaultErrorSettings(
+          'idIsSubscribed',
+          error
+        ),
+
+        errorCode: 'NTS-SSS-600',
+        message: `socket(${this.params.name}) ID Subscription Check (${id}) failed`,
+      });
+    }
+  }
+
+  async emitError(presenceIssuerId: string, error: any, issuer: string): Promise<void> {
+    try {
+      await this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEventKey.error, error, issuer);
+    } catch (error) {
+      throw new DynamoFM_Error({
+        ...this._getDefaultErrorSettings(
+          'emitError',
+          error,
+          presenceIssuerId
+        ),
+
+        errorCode: 'NTS-SSS-700',
+        message: `socket(${this.params.name}) Error Emit (id: ${presenceIssuerId}) failed`,
+      });
+    }
+  }
+
+  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
+      );
+
+      if (!presence) {
+        throw new DynamoFM_Error({ 
+          ...this._getDefaultErrorSettings(
+            'sendEventForId',
+            new Error(`No active socket with this specific ID: ${id}`),
+            content?.source
+          ),
+
+          status: 404, 
+          errorCode: 'NTS-SSS-301',
+        });
+      }
+
+      presence.emitEvent(event, content, issuer);
+
+      if (DynamoNTS_globalSettings.logSocketEventContent) {
+        DynamoFM_Log.success(
+          ` <--=  emitted socket(${this.params.name}) event for presence: ${event}, ` +
+          `\n  presenceId: ${id}, sockets: ${presence.sockets.length}` +
+          `\n  content:`, content
+        );
+      } else {
+        DynamoFM_Log.success(
+          ` <--=  emitted socket(${this.params.name}) event for presence: ${event}, ` +
+          `\n  presenceId: ${id}, sockets: ${presence.sockets.length}`
+        );
+      }
+    } catch (error) {
+      try {
+        if (error.flag.includes('DYNAMO') && error?.accitionalInfo?.inactiveSockets) {
+          const sockets: SocketIO.Socket[] = error.accitionalInfo.inactiveSockets;
+
+          await DynamoFM_Array.asyncForEach(sockets, async (socket: SocketIO.Socket) => {
+            await this.removeSubscription(socket);
+          });
+
+          const presence: DynamoNTS_SocketPresence = this.presences.find(
+            (pres: DynamoNTS_SocketPresence) => pres.issuerId === id
+          );
+
+          if (!presence) {
+            throw new DynamoFM_Error({ 
+              ...this._getDefaultErrorSettings(
+                'sendEventForId',
+                new Error(`No active socket(${this.params.name}) with this specific ID: ${id}`),
+                content?.source
+              ),
+
+              status: 404, 
+              errorCode: 'NTS-SSS-302',
+            });
+          }
+        }
+      } catch (error) {
+        throw new DynamoFM_Error({
+          ...this._getDefaultErrorSettings('sendEventForId', error, content?.source),
+  
+          errorCode: 'NTS-SSS-310',
+          message: 
+            `Error handling of inactive sockets(${this.params.name}) failed!` +
+            `\n(Socket Event Emit for id (${id}, ${event}) failed)`,
+        });
+      }
+
+      throw new DynamoFM_Error({
+        ...this._getDefaultErrorSettings('sendEventForId', error, content?.source),
+
+        errorCode: 'NTS-SSS-310',
+        message: `socket(${this.params.name}) Event Emit for id (${id}, ${event}) failed`,
+      });
+    }
+  }
+
+  broadcastEvent(event: string, content: any, issuer: string): void {
+    try {
+      DynamoFM_Log.log(` <=-== broadcasting socket(${this.params.name}) event: ${event}`);
+
+      this.presences.forEach((presence: DynamoNTS_SocketPresence) => {
+        presence.emitEvent(event, content, issuer);
+      });
+    } catch (error) {
+      DynamoFM_Log.error(`socket(${this.params.name}) Event Broadcast (${event}) failed`, error);
+      
+      throw new DynamoFM_Error({
+        ...this._getDefaultErrorSettings('broadcastEvent', error),
+        
+        errorCode: 'NTS-SSS-400',
+        message: `socket(${this.params.name}) Event Broadcast (${event}) failed`,
+      });
+    }
+  }
+
+  private _getDefaultErrorSettings(
+    fnName: string, 
+    error: DynamoFM_AnyError, 
+    issuer?: string
+  ): DynamoFM_Error_Settings {
+    return {
+      status: (error as DynamoFM_Error)?.___status ?? 500,
+      message: (error as Error)?.message ?? `${fnName} was UNSUCCESFUL (NTS)`,
+      addECToUserMsg: !(error as DynamoFM_Error)?.__userMessage,
+      userMessage: (error as DynamoFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
+      issuer: issuer,
+      issuerService: this.constructor?.name,
+      error: error,
+    };
+  }
+
+  /**
+   * You must setup params for the service in this function
+   */
+  protected abstract getServiceParams(): DynamoNTS_SocketServerService_Params;
+
+  /**
+   * You must setup events and required services in this function
+   */
+  protected abstract getIncomingEvents(): DynamoNTS_SocketEvent<any>[];
+
+  /**
+   * You can setup tasks for the subscription event in this function
+   */
+  protected getSubscriptionTasks?(): DynamoNTS_SocketEventTask<T_SubscriptionContent>[];
+  
+  /**
+   * You can setup tasks for the subscription event in this function
+   */
+  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
+   */
+  protected errorHandling?: DynamoNTS_SocketEventTask<T_ErrorContent>;
+}