@futdevpro/nts-dynamo 1.5.76 → 1.5.81

package/src/_services/dynamo-nts-socket.service.ts

@@ -1,20 +1,21 @@
 
 import * as SocketIO from 'socket.io';
 
-import { dynamoNTS_GlobalSettings } from '../_constants/dynamo-nts-global-settings';
+import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
+
+import { DynamoNTS_GlobalService } from './dynamo-nts-global.service';
 import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
-import { DynamoNTS_SocketEventParams } from '../_models/dynamo-nts-socket-event-params';
+import { dynamoNTS_GlobalSettings } from '../_constants/dynamo-nts-global-settings';
+import { DynamoNTS_SocketEventParams, DynamoNTS_SocketEventPreprocessTask, DynamoNTS_SocketEventTask } from '../_models/dynamo-nts-socket-event-params';
 import { DynamoNTS_SocketEvent } from '../_enums/http/socket-event.enum';
-import { DynamoNTS_GlobalService } from './dynamo-nts-global.service';
-import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 import { DynamoNTS_SocketServiceParams } from '../_models/dynamo-nts-socket-service-params';
-import { DynamoNTS_SocketDictionary } from '../_models/dynamo-nts-socket-dictionary';
+import { DynamoNTS_SocketPresence } from '../_models/dynamo-nts-socket-presence';
 import { DynamoNTS_SocketSecurity } from '../_enums/dynamo-nts-socket-security.enum';
 
 /**
  * 
  */
-export abstract class DynamoNTS_SocketService<T extends DynamoNTS_SocketDictionary> extends DynamoNTS_SingletonService {
+export abstract class DynamoNTS_SocketService<T_Presence extends DynamoNTS_SocketPresence, T_Content = any> extends DynamoNTS_SingletonService {
   protected params: DynamoNTS_SocketServiceParams;
   get name(): string { return this.params.name; }
   get port(): number { return this.params.port; }
@@ -26,8 +27,11 @@ export abstract class DynamoNTS_SocketService<T extends DynamoNTS_SocketDictiona
   protected incomingEvents: DynamoNTS_SocketEventParams<any>[];
 
   private subscriptionEvent: DynamoNTS_SocketEventParams<any>;
-  private getDicFromSubscrioption?: (content: any) => Promise<T>;
-  protected activeSockets: T[] = [];
+  /**
+   * You need to setup a function that converts subscription event content to presence
+   */
+  protected getPresenceFromSubscrioptionEventContent?: (socketSubscription: T_Content) => Promise<T_Presence>;
+  protected presences: T_Presence[] = [];
 
   protected log: boolean = dynamoNTS_GlobalSettings.logSetup;
 
@@ -39,8 +43,8 @@ export abstract class DynamoNTS_SocketService<T extends DynamoNTS_SocketDictiona
     super();
 
     try {
-      this.setupServiceParams();
-      this.setupEvents();
+      this.params = this.getServiceParams();
+      this.incomingEvents = this.getIncomingEvents() ?? [];
       
       this.attachToGlobalCollection();
       this.prepareEvents();
@@ -70,15 +74,22 @@ export abstract class DynamoNTS_SocketService<T extends DynamoNTS_SocketDictiona
     }
     this.connectEvent.socketName = this.params.name;
 
-    if (this.getDicFromSubscrioption) {
+    if (this.getPresenceFromSubscrioptionEventContent) {
       const subscriptionEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEventParams<any>) => event.event === DynamoNTS_SocketEvent.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 subscripotions.`
+        );
       } else {
-        this.subscriptionEvent = new DynamoNTS_SocketEventParams<SocketIO.Socket>({
-          event: DynamoNTS_SocketEvent.subscribe,
-          tasks: []
-        });
+        this.subscriptionEvent = new DynamoNTS_SocketEventParams<SocketIO.Socket>({ event: DynamoNTS_SocketEvent.subscribe });
+      }
+      if (this.getSubscriptionPreProcessess) {
+        this.subscriptionEvent.preProcessess.push(...this.getSubscriptionPreProcessess());
+      }
+      if (this.getSubscriptionTasks) {
+        this.subscriptionEvent.tasks.push(...this.getSubscriptionTasks());
       }
 
       const disconnectEventIndex = this.incomingEvents.findIndex((event: DynamoNTS_SocketEventParams<any>) => event.event === DynamoNTS_SocketEvent.disconnect);
@@ -114,19 +125,32 @@ export abstract class DynamoNTS_SocketService<T extends DynamoNTS_SocketDictiona
         await this.connectEvent.tasks[i](socket);        
       }
 
-      if (this.getDicFromSubscrioption) {
+      if (this.getPresenceFromSubscrioptionEventContent) {
         socket.on(DynamoNTS_SocketEvent.subscribe, async (content: any) => {
-          const dic: T = await this.getDicFromSubscrioption(content);
-          issuer = dic.issuerId;
-
-          this.socketSubscription(dic);
-          this.subscriptionEvent.getFullExecution(issuer)(content);
+          try {
+            const presence: T_Presence = await this.getPresenceFromSubscrioptionEventContent(content);
+            issuer = presence.issuerId;
+  
+            this.socketSubscription(presence);
+            await this.subscriptionEvent.executeEventTasks(issuer, content);
+          } catch (error) {
+            Dynamo_Log.error(`Socket Subscription failed: ${this.params.name} (${this.params.port})`, error);
+            socket.emit(DynamoNTS_SocketEvent.error, error);
+          }
         })
       }
 
       this.incomingEvents.forEach((event: DynamoNTS_SocketEventParams<any>) => {
-        socket.on(event.event, event.getFullExecution(issuer));
+        socket.on(event.event, async (content: any) => { 
+          try {
+            await event.executeEventTasks(issuer, content);
+          } catch (error) {
+            Dynamo_Log.error(`Socket Event failed: ${this.params.name} (${this.params.port})`, error);
+            socket.emit(DynamoNTS_SocketEvent.error, error);
+          }
+        });
       });
+
     });
 
     this.socketServer.listen(this.params.port);
@@ -137,22 +161,23 @@ export abstract class DynamoNTS_SocketService<T extends DynamoNTS_SocketDictiona
     );
   }
 
-  private async socketSubscription(dictionary: T): Promise<void> {
-    const activeSocket: T = this.activeSockets.find((dic: T) => dic.issuerId === dictionary.issuerId);
-    if (activeSocket) {
-      activeSocket.sockets.push(dictionary.sockets[0]);
+  protected async socketSubscription(newPresence: T_Presence): Promise<void> {
+    const activePresence: T_Presence = this.presences.find((pres: T_Presence) => pres.issuerId === newPresence.issuerId);
+    if (activePresence) {
+      activePresence.sockets.push(newPresence.sockets[0]);
     } else {
-      this.activeSockets.push(dictionary);
+      this.presences.push(newPresence);
     }
   }
 
   private async removeSubscriptionOnDisconnect(socket: SocketIO.Socket): Promise<void> {
-    const activeSocketIndex: number = this.activeSockets.findIndex((dic: DynamoNTS_SocketDictionary) => dic.sockets.includes(socket));
-    if (0 <= activeSocketIndex) {
-      const socketIndex = this.activeSockets[activeSocketIndex].sockets.findIndex((s: SocketIO.Socket) => s === socket);
-      this.activeSockets[activeSocketIndex].sockets.splice(socketIndex);
-      if (this.activeSockets[activeSocketIndex].sockets.length === 0) {
-        this.activeSockets.splice(activeSocketIndex);
+    const activePresenceIndex: number = this.presences.findIndex((pres: DynamoNTS_SocketPresence) => pres.sockets.includes(socket));
+    if (0 <= activePresenceIndex) {
+      const presenceIndex = this.presences[activePresenceIndex].sockets.findIndex((s: SocketIO.Socket) => s === socket);
+      this.presences[activePresenceIndex].sockets.splice(presenceIndex);
+
+      if (this.presences[activePresenceIndex].sockets.length === 0) {
+        this.presences.splice(activePresenceIndex);
       }
     }
   }
@@ -162,13 +187,17 @@ export abstract class DynamoNTS_SocketService<T extends DynamoNTS_SocketDictiona
   }
 
   idIsSubscribed(id: string): boolean {
-    return !!this.activeSockets.find((dic: DynamoNTS_SocketDictionary) => dic.issuerId === id);
+    return !!this.presences.find((presence: DynamoNTS_SocketPresence) => presence.issuerId === id);
+  }
+
+  emitError(presenceIssuerId: string, error: any): void {
+    this.sendEventForId(presenceIssuerId, DynamoNTS_SocketEvent.error, error);
   }
 
   async sendEventForId(id: string, event: string, content: any, error?: (err: any) => void): Promise<void> {
-    const dic: DynamoNTS_SocketDictionary = this.activeSockets.find((dic: DynamoNTS_SocketDictionary) => dic.issuerId === id);
-    if (dic) {
-      dic.emitEvent(event, content);
+    const presence: DynamoNTS_SocketPresence = this.presences.find((pres: DynamoNTS_SocketPresence) => pres.issuerId === id);
+    if (presence) {
+      presence.emitEvent(event, content);
     } else {
       if (error) {
 
@@ -184,8 +213,8 @@ export abstract class DynamoNTS_SocketService<T extends DynamoNTS_SocketDictiona
   }
 
   broadcastEvent(event: string, content: any): void {
-    this.activeSockets.forEach((dic: DynamoNTS_SocketDictionary) => {
-      dic.emitEvent(event, content);
+    this.presences.forEach((presence: DynamoNTS_SocketPresence) => {
+      presence.emitEvent(event, content);
     })
   }
 
@@ -193,10 +222,20 @@ export abstract class DynamoNTS_SocketService<T extends DynamoNTS_SocketDictiona
    * You must setup params for the service in this function
    * 
    */
-  abstract setupServiceParams(): void
+  abstract getServiceParams(): DynamoNTS_SocketServiceParams;
 
   /**
    * You must setup events and required services in this function
    */
-  abstract setupEvents(): void
+  abstract getIncomingEvents(): DynamoNTS_SocketEventParams<any>[];
+
+  /**
+   * You can setup tasks for the subscription event in this function
+   */
+  protected getSubscriptionTasks?(): DynamoNTS_SocketEventTask[];
+
+  /**
+   * You can setup preprocessess for the subscription event in this function
+   */
+  protected getSubscriptionPreProcessess?(): DynamoNTS_SocketEventPreprocessTask<T_Content>[];
 }

package/src/_services/index.ts

@@ -3,8 +3,8 @@
 
 // SERVICES
 export * from './dynamo-nts-api.service';
-export * from './dynamo-nts-app';
-export * from './dynamo-nts-app-extended';
+//export * from './dynamo-nts-app';
+//export * from './dynamo-nts-app-extended';
 export * from './dynamo-nts-auth.service';
 export * from './dynamo-nts-controller.service';
 export * from './dynamo-nts-data.service';