@futdevpro/nts-dynamo 1.5.34 → 1.5.35

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

@@ -8,6 +8,8 @@ import { DynamoNTS_DBService } from './dynamo-nts-db.service';
 import { DynamoNTS_EmailServiceCollection } from './dynamo-nts-email-service-collection.service';
 import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
 import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
+import { DynamoNTS_SocketServiceCollection } from './dynamo-nts-socket-service-collection.service';
+import { DynamoNTS_SocketService } from './dynamo-nts-socket.service';
 
 /**
  * This is the main Global/Core Service Collection used by DynamoBE, 
@@ -23,6 +25,8 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
   authService: DynamoNTS_AuthService;
   dbServiceCollection: DynamoNTS_DBServiceCollection;
   emailServiceCollection: DynamoNTS_EmailServiceCollection;
+
+  socketServiceCollection: DynamoNTS_SocketServiceCollection = DynamoNTS_SocketServiceCollection.getInstance();
   
   /**
    * You need to setup global Services through this function
@@ -72,7 +76,7 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
     if (!this.instance?.authService?.authenticateToken) {
       throw new Error(
         `\nUnique Authentication Service missing!` + 
-        `\nPlease create a Unique Authentication Service extending DynamoBEAuthService, ` + 
+        `\nPlease create a Unique Authentication Service extending DynamoNTS_AuthService, ` + 
         `and Setup with "DBE_Global_SC.setServices(...)"`);
     }
     return this.instance.authService;
@@ -86,7 +90,7 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
     if (!this.instance?.dbServiceCollection) {
       throw new Error(
         `\nUnique DataBase Service Collection missing!` + 
-        `\nPlease create a Unique DataBase Service Collectio extending DynamoBEDBServiceCollection, ` + 
+        `\nPlease create a Unique DataBase Service Collection extending DynamoNTS_DBServiceCollection, ` + 
         `and Setup with "DBE_Global_SC.setServices(...)"`);
     }
     return this.instance.dbServiceCollection;
@@ -114,7 +118,7 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
       let keys: string = `${Object.keys(collection)}`;
       keys = keys.replace(/,/g, '\n                ');
       throw new Error(
-        `\nDBE_Global_S.getDBService failed ERROR: 
+        `\nDBE_Global_S.getDBService failed, ERROR: 
         no dbService on collection with this key: ${key}!
         The available dbServices on collection:
                 ${keys}\n`);
@@ -134,4 +138,54 @@ export class DynamoNTS_GlobalService extends DynamoNTS_SingletonService {
     }
     return this.instance.emailServiceCollection;
   }
+
+  /**
+   * 
+   * @returns 
+   */
+  static getSocketServiceCollection(): DynamoNTS_SocketServiceCollection {
+    if (!this.instance?.socketServiceCollection) {
+      throw new Error(
+        `\nUnique Socket Service Collection missing!` + 
+        `\nSocket Service Collection will only be created if there are Socket Services properly setted up ` +
+        `in the setupModules in the App using DynamoNTS_AppExtended, ` + 
+        `and Setup with "DBE_Global_SC.setServices(...)"`);
+    }
+    return this.instance.socketServiceCollection;
+  }
+
+  /**
+   * 
+   * @param name 
+   * @returns 
+   */
+  static getSocketServiceByName(name: string): DynamoNTS_SocketService {
+    const collection = this.getSocketServiceCollection();
+    if (collection[name]) {
+      return collection[name];
+    } else {
+      let names: string = `${Object.keys(collection)}`;
+      names = names.replace(/,/g, '\n                ');
+      throw new Error(
+        `\nDBE_Global_S.getSocketServiceByName failed, ERROR: 
+        no socketService on collection with this name: ${name}!
+        The available socketServices on collection:
+                ${names}\n`);
+    }
+  }
+
+  static attachNewSocketService(service: DynamoNTS_SocketService): void {
+    const collection = this.getSocketServiceCollection();
+    if (!collection[service.name]) {
+      collection[service.name] = service;
+    } else {
+      let names: string = `${Object.keys(collection)}`;
+      names = names.replace(/,/g, '\n                ');
+      throw new Error(
+        `\nDBE_Global_S.attachNewSocketService failed, ERROR: 
+        socketService name is already taken on collection with this name: ${service.name}!
+        The available socketServices on collection:
+                ${names}\n`);
+    }
+  }
 }

package/src/_services/dynamo-nts-routing-module.service.ts

@@ -8,12 +8,7 @@ import { HttpCallType } from '../_enums/http/http-call-type.enum';
 import { DynamoNTS_EndpointParams } from '../_models/dynamo-nts-endpoint-params';
 import { DynamoNTS_Controller } from './dynamo-nts-controller.service';
 import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
-
-export interface DynamoNTS_RoutingModuleSettings {
-  route: string;
-  controllers: DynamoNTS_Controller[];
-  securityOverride?: DynamoNTS_RouteSecurity;
-}
+import { DynamoNTS_RoutingModuleSettings } from '../_models/dynamo-nts-routing-module-settings';
 
 /**
  * 
@@ -47,7 +42,7 @@ export class DynamoNTS_RoutingModule {
   }
 
   /**
-   * You must setup endpoints and required services in this function
+   * You must setup endpoints and required services for this function
    */
   private setupRoutes(): void {
     this.controllers.forEach((controller: DynamoNTS_Controller) => {

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

@@ -0,0 +1,16 @@
+
+import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
+import { DynamoNTS_SocketService } from './dynamo-nts-socket.service';
+
+/**
+ * 
+ */
+export class DynamoNTS_SocketServiceCollection extends DynamoNTS_SingletonService {
+  
+  static getInstance(): DynamoNTS_SocketServiceCollection {
+    return DynamoNTS_SocketServiceCollection.getSingletonInstance();
+  }
+
+  [service: string]: DynamoNTS_SocketService;
+  
+}

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

@@ -0,0 +1,179 @@
+
+import * as SocketIO from 'socket.io';
+
+import { dynamoNTS_GlobalSettings } from '../_constants/dynamo-nts-global.settings';
+import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
+import { DynamoNTS_SocketServiceSettings } from '../_models';
+import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
+import { DynamoNTS_SocketEventParams } 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 { DynamoNTS_Error } from '@futdevpro/fsm-dynamo';
+import { DynamoNTS_SocketSecurity } from '../_enums/dynamo-nts-socket-security.enum';
+
+export interface DynamoNTS_SocketDictionary {
+  id?: string;
+  sockets: SocketIO.Socket[];
+}
+
+/**
+ * 
+ */
+export class DynamoNTS_SocketService extends DynamoNTS_SingletonService {
+  name: string;
+  security: DynamoNTS_SocketSecurity;
+  port: number;
+
+  socketServer: SocketIO.Server;
+
+  connectEvent: DynamoNTS_SocketEventParams<SocketIO.Socket>;
+  events: DynamoNTS_SocketEventParams<any>[];
+
+  subscriptionEvent: DynamoNTS_SocketEventParams<any>;
+  getIdFromSubscrioption?: <T>(content: T) => string;
+  activeSockets: DynamoNTS_SocketDictionary[] = [];
+
+  protected log: boolean = dynamoNTS_GlobalSettings.logSetup;
+
+  constructor(
+    set: DynamoNTS_SocketServiceSettings
+  ){
+    super();
+    try {
+      this.name = set.name;
+      this.port = set.port;
+      this.events = set.events;
+      this.security = set.security ? set.security : dynamoNTS_GlobalSettings.defaultSocketSecurity;
+      
+      if (set.getIdFromSubscrioption) {
+        this.getIdFromSubscrioption = set.getIdFromSubscrioption;
+        if (set.groupActiveSocketsBy) {
+          DynamoNTS_Shared.logError(
+            `setting groupActiveSocketsBy on DynamoNTS_SocketService (${this.name}) won't take effect, ` +
+            `since getIdFromSubscrioption is also setted, so it will be used instead`)
+        }
+      } else if (set.groupActiveSocketsBy) {
+        this.getIdFromSubscrioption = content => content[set.groupActiveSocketsBy];
+      }      
+
+      this.attachToGlobalCollection();
+      this.prepareEvents();
+
+      if (this.log) console.log(`Socket Controller setup done: ${this.name} (${this.port}) serurity: ${this.security}\n`);
+    } catch (error) {
+      DynamoNTS_Shared.logError(`Socket Controller setup failed: ${this.name} (${this.port})`, error);
+    }
+  }
+
+  private attachToGlobalCollection(): void {
+    DynamoNTS_GlobalService.attachNewSocketService(this);
+  }
+
+  /**
+   * You must setup events and required services for this function
+   */
+  private prepareEvents(): void {
+    const connectEventIndex = this.events.findIndex((event: DynamoNTS_SocketEventParams<any>) => event.event === DynamoNTS_SocketEvent.connection);
+    if (0 <= connectEventIndex) {
+      this.connectEvent = this.events.splice(connectEventIndex)[0];
+    } else {
+      this.connectEvent = new DynamoNTS_SocketEventParams({
+        event: DynamoNTS_SocketEvent.connection,
+        tasks: []
+      });
+    }
+
+    if (this.getIdFromSubscrioption) {
+      const subscriptionEventIndex = this.events.findIndex((event: DynamoNTS_SocketEventParams<any>) => event.event === DynamoNTS_SocketEvent.subscribe);
+      if (0 <= subscriptionEventIndex) {
+        this.subscriptionEvent = this.events.splice(subscriptionEventIndex)[0];
+      } else {
+        this.subscriptionEvent = new DynamoNTS_SocketEventParams<SocketIO.Socket>({
+          event: DynamoNTS_SocketEvent.subscribe,
+          tasks: []
+        });
+      }
+
+      const disconnectEventIndex = this.events.findIndex((event: DynamoNTS_SocketEventParams<any>) => event.event === DynamoNTS_SocketEvent.disconnect);
+      if (0 <= disconnectEventIndex) {
+        this.events[disconnectEventIndex].tasks.push(this.removeSubscriptionOnDisconnect);
+      } else {
+        this.events.push(new DynamoNTS_SocketEventParams<SocketIO.Socket>({
+          event: DynamoNTS_SocketEvent.disconnect,
+          tasks: [
+            this.removeSubscriptionOnDisconnect
+          ]
+        }));
+      }      
+    }
+  }
+
+  setupSocketServer(newSocketServer: SocketIO.Server): void {
+    this.socketServer = newSocketServer;
+    this.socketServer.on(DynamoNTS_SocketEvent.connection, async (socket: SocketIO.Socket) => {
+      let issuer: string;
+      
+      for(let i = 0; i < this.connectEvent.preProcessess.length; i++) {
+        await this.connectEvent.preProcessess[i](socket);
+      }
+
+      for(let i = 0; i < this.connectEvent.tasks.length; i++) {
+        await this.connectEvent.tasks[i](socket);        
+      }
+
+      if (this.getIdFromSubscrioption) {
+        socket.on(DynamoNTS_SocketEvent.subscribe, (content: any) => {
+          issuer = this.getIdFromSubscrioption(content);
+          this.socketSubscription(socket, issuer);
+          this.subscriptionEvent.getFullExecution(issuer)(content);
+        })
+      }
+
+      this.events.forEach((event: DynamoNTS_SocketEventParams<any>) => {
+        socket.on(event.event, event.getFullExecution(issuer));
+      });
+    });
+
+    this.socketServer.listen(this.port);
+
+    if (this.log) console.log(
+      `\nsocket service setup finished: ${this.name}` + 
+      `\nsocket server listening on port: ${this.port}`
+    );
+  }
+
+  private async socketSubscription(newSocket: SocketIO.Socket, id: string): Promise<void> {
+    const activeSocket: DynamoNTS_SocketDictionary = this.activeSockets.find((dic: DynamoNTS_SocketDictionary) => dic.id === id);
+    if (activeSocket) {
+      activeSocket.sockets.push(newSocket);
+    } else {
+      this.activeSockets.push({ id, sockets: [ newSocket ] });
+    }
+  }
+
+  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);
+      }
+    }
+  }
+
+  emitEvent(event: string, content: any): void {
+    this.socketServer.emit(event, content);
+  }
+
+  emitEventForId(id: string, event: string, content: any): void {
+    const dic: DynamoNTS_SocketDictionary = this.activeSockets.find((dic: DynamoNTS_SocketDictionary) => dic.id === id);
+    if (dic) {
+      dic.sockets.forEach((socket: SocketIO.Socket) => {
+        socket.emit(event, content);
+      });
+    } else {
+      throw new DynamoNTS_Error({ message: `No active socket whit this specific ID: ${id}` });
+    }
+  }
+}

package/src/_services/index.ts

@@ -14,6 +14,8 @@ export * from './dynamo-nts-email-service-collection.service';
 export * from './dynamo-nts-email.service';
 export * from './dynamo-nts-global.service';
 export * from './dynamo-nts-routing-module.service';
+export * from './dynamo-nts-socket.service';
+export * from './dynamo-nts-socket-service-collection.service';
 export * from './dynamo-nts-shared.service';
 export * from './dynamo-nts-singleton.service';
 

package/src/_models/dynamo-module-settings.ts

@@ -1,10 +0,0 @@
-
-/**
- * 
- */
-/* export interface DynamoModuleSettings {
-  mainRoute: string;
-  endPoints: {
-    [endpointName: string]: string
-  }
-} */