@futdevpro/nts-dynamo 1.5.54 → 1.5.58

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

@@ -1,14 +1,13 @@
 
 import * as Axios from 'axios';
-import { Dynamo_Error } from '@futdevpro/fsm-dynamo';
+import { Dynamo_Error, Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
 import { HttpCallType } from '../_enums/http/http-call-type.enum';
 import { HttpResponseType } from '../_enums/http/http-response-type.enum';
 import { DynamoNTS_ApiCallParams } from '../_models/dynamo-nts-api-call-params';
-import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
 
 /**
- * 
+ * This predefined Api service contains the basic API call function which can be used in various ways
  */
 export class DynamoNTS_ApiService {
 
@@ -21,12 +20,24 @@ export class DynamoNTS_ApiService {
      * @returns 
      */
   public static async startApiCall<T>(
+    /**
+     * you must setup the basic api call params with this.
+     * follow the instructions in the constructor: new DynamoNTS_ApiCallParams({ ... })
+     */
     callParams: DynamoNTS_ApiCallParams,
+    /**
+     * you can pass data and other inputs in this section
+     */
     inputParams?: {
       pathParams?: {
+        /**
+         * path params setted in endpoint
+         */
         [param: string]: string
       },
-      /* queryParams?: object, */
+      /**
+       * api call's body
+       */
       body?: any
     }
   ): Promise<any> {
@@ -40,7 +51,7 @@ export class DynamoNTS_ApiService {
                 if (callParams.httpOptions.headers[headerKey]) {
                     privateAxiosInstance.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
                 } else {
-                    DynamoNTS_Shared.logError('DYNAMOBE ERROR: \n missing header:', headerKey, '\n\n', new Error());
+                    Dynamo_Log.logError('DYNAMOBE ERROR: \n missing header:', headerKey, '\n\n', new Error());
                 }
             }
         }
@@ -57,11 +68,11 @@ export class DynamoNTS_ApiService {
                         url = url.replace(`:${pathParamKey}`, inputParams.pathParams[pathParamKey]);
                         break;
                     default:
-                        DynamoNTS_Shared.logError(`DYNAMOBE ERROR: \n wrong path param type: (${pathParamKey}): ${paramType} \n${inputParams.pathParams[pathParamKey]}\nMUST BE string or number\n\n`, new Error());
+                        Dynamo_Log.logError(`DYNAMOBE ERROR: \n wrong path param type: (${pathParamKey}): ${paramType} \n${inputParams.pathParams[pathParamKey]}\nMUST BE string or number\n\n`, new Error());
                         break;
                     }
                 } else {
-                    DynamoNTS_Shared.logError('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey, '\n\n', new Error());
+                    Dynamo_Log.logError('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey, '\n\n', new Error());
                 }
             }
         }
@@ -130,7 +141,7 @@ export class DynamoNTS_ApiService {
                 });
             break;
             default:
-                DynamoNTS_Shared.logError('DYNAMOBE ERROR: \n wrong api call type', '\n\n', new Error());
+                Dynamo_Log.logError('DYNAMOBE ERROR: \n wrong api call type', '\n\n', new Error());
             break;
         }
 
@@ -140,7 +151,7 @@ export class DynamoNTS_ApiService {
             return a as T;
         }
     } catch (error) {
-        DynamoNTS_Shared.logError(`\nAPI ERROR: ${callParams?.name} failed...` +
+        Dynamo_Log.logError(`\nAPI ERROR: ${callParams?.name} failed...` +
         `\n${callParams?.baseUrl}${callParams?.endPoint}`);
 
         if (callParams?.httpOptions?.responseType === HttpResponseType.text) {
@@ -148,7 +159,7 @@ export class DynamoNTS_ApiService {
         }
         
         if (error?.response?.data?.flag === 'DYNAMO ERROR OBJECT') {
-            DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            Dynamo_Log.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
 
             throw new Dynamo_Error({
                 errorCode: 'NTS-API-002',
@@ -158,7 +169,7 @@ export class DynamoNTS_ApiService {
                 error: error.response.data
             });
         } else if (error.code === 'ENOTFOUND') {
-            DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
+            Dynamo_Log.logError(`\n${callParams.name} was UNSUCCESSFUL\n\n`, new Error());
 
             throw new Dynamo_Error({ 
                 status: 404, 
@@ -178,7 +189,7 @@ export class DynamoNTS_ApiService {
                 error 
             });
         } else {
-            DynamoNTS_Shared.logError(`\n${callParams.name} was UNSUCCESSFUL`, error, '\n\n', new Error());
+            Dynamo_Log.logError(`\n${callParams.name} was UNSUCCESSFUL`, error, '\n\n', new Error());
 
             throw error;
         }

package/src/_services/dynamo-nts-app-extended.ts

@@ -2,11 +2,11 @@
 import * as SocketIO from 'socket.io';
 import * as Http from 'http';
 
-import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
 import { DynamoNTS_RouteSecurity } from '../_enums/dynamo-nts-route-security.enum';
 import { DynamoNTS_App } from './dynamo-nts-app';
 import { DynamoNTS_SocketService } from './dynamo-nts-socket.service';
 import { DynamoNTS_SocketSecurity } from '../_enums/dynamo-nts-socket-security.enum';
+import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
 /**
  * This will be the MAIN service of our server project,
@@ -27,7 +27,7 @@ import { DynamoNTS_SocketSecurity } from '../_enums/dynamo-nts-socket-security.e
  * // Setting up App params, and preparing project global settings
  *   setupAppParams(): void {
  *     this.params = new DynamoNTS_AppParams({
- *       name: 'Warbots Distribution Server',
+ *       name: 'Warbots Server',
  *       title: warbotsTitleLog,
  *       version: version,
  *       dbName: 'warbots',
@@ -112,6 +112,15 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
 
   private socketSecurity: DynamoNTS_RouteSecurity;
   
+  /**
+   * @example
+   * // Setting up Sockets
+   * this.socketServices = [
+   *   NotificationService.getInstance(),
+   *   ChatService.getInstance(),
+   *   ...
+   * ];
+   */
   protected socketServices: DynamoNTS_SocketService<any>[];
 
   constructor(){
@@ -123,15 +132,15 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
 
         this.setupSocketServices();
 
-        if (this.log) console.log(`\nAll sockets setted up.... sockets using security: ${this.socketSecurity}`);
+        if (this.debugLog) console.log(`\nAll sockets setted up.... sockets using security: ${this.socketSecurity}`);
       } else {
-        DynamoNTS_Shared.logWarning(
+        Dynamo_Log.logWarning(
           '\nNo socketServices setted up while using Extended Application.',
           '\nYou should use DynamoNTS_App if you don`t need socket services.\n' 
         );
       }
     } catch (error) {
-      DynamoNTS_Shared.logError('\nExtended Application start failed.\n', error, '\n');
+      Dynamo_Log.logError('\nExtended Application start failed.\n', error, '\n');
     }
   }
 
@@ -179,7 +188,7 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
               errorMsg += `\n  ${service.name} (port: ${service.port})`;
             }
           });
-          DynamoNTS_Shared.logError(errorMsg);
+          Dynamo_Log.logError(errorMsg);
   
           let error = new Error('Secure routes cannot be established!');
           let errorStack: string[] = error.stack.split('\n');
@@ -206,10 +215,10 @@ export abstract class DynamoNTS_AppExtended extends DynamoNTS_App {
       }
 
       if (service.security === DynamoNTS_SocketSecurity.open) {
-        if (this.log) console.log(`\nsocket setup (open): ${service.name}:${service.port}`);
+        if (this.debugLog) console.log(`\nsocket setup (open): ${service.name}:${service.port}`);
         service.setupSocketServer(new SocketIO.Server(httpSocketServer));
       } else if (service.security === DynamoNTS_SocketSecurity.secure) {
-        if (this.log) console.log(`\nsocket setup (secure): ${service.name}:${service.port}`);
+        if (this.debugLog) console.log(`\nsocket setup (secure): ${service.name}:${service.port}`);
         service.setupSocketServer(new SocketIO.Server(this.httpsServer));
       } else {
         let error = new Error(`INVALID Socket Service security: ${service.security} on ${service.name}`);

package/src/_services/dynamo-nts-app.ts

@@ -6,12 +6,12 @@ import * as Https from 'https';
 import * as FileSystem from 'fs';
 import * as BodyParser from 'body-parser';
 
-import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
 import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
 import { DynamoNTS_RouteSecurity } from '../_enums/dynamo-nts-route-security.enum';
 import { DynamoNTS_RoutingModule } from './dynamo-nts-routing-module.service';
 import { DynamoNTS_EndpointParams } from '../_models/dynamo-nts-endpoint-params';
 import { dynamoNTS_GlobalSettings } from '../_constants';
+import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
 /**
  * This will be the MAIN service of our server project,
@@ -27,10 +27,10 @@ import { dynamoNTS_GlobalSettings } from '../_constants';
  *   
  *   ...
  *   
- * // Setting up App params, and preparing project global settings
+ *   // Setting up App params, and preparing project global settings
  *   setupAppParams(): void {
  *     this.params = new DynamoNTS_AppParams({
- *       name: 'Warbots Distribution Server',
+ *       name: 'Warbots Server',
  *       title: warbotsTitleLog,
  *       version: version,
  *       dbName: 'warbots',
@@ -125,15 +125,36 @@ import { dynamoNTS_GlobalSettings } from '../_constants';
  */
 export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
 
+  /**
+   * Setup this in the setupAppParams(), which will be called first in the constuctor
+   * 
+   * @example
+   * 
+   * this.params = new DynamoNTS_AppParams({
+   *   name: 'Warbots Server',
+   *   title: warbotsTitleLog,
+   *   version: version,
+   *   dbName: 'warbots',
+   * });
+   */
   protected params: DynamoNTS_AppParams;
   
   protected mongoose = Mongoose;
 
   protected security: DynamoNTS_RouteSecurity;
 
+  /**
+   * setup this in the setupRoutingModules()
+   */
   protected httpPort?: number;
+  /**
+   * setup this in the setupRoutingModules()
+   */
   protected httpsPort?: number;
 
+  /**
+   * setup this in the setupRoutingModules()
+   */
   protected cert?: {
     keyPath: FileSystem.PathLike,
     certPath: FileSystem.PathLike,
@@ -143,9 +164,15 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   private secureExpress: Express.Application;
   protected httpsServer: Https.Server;
 
+  /**
+   * setup this in the setupRoutingModules()
+   */
   protected routingModules: DynamoNTS_RoutingModule[];
 
-  protected log: boolean;
+  /**
+   * setting this value to true, enables this service debug logs
+   */
+  protected debugLog: boolean;
 
   constructor(){
     super();
@@ -158,7 +185,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       this.startDB();
 
       this.setGlobalServiceCollection();
-      this.log = dynamoNTS_GlobalSettings.logSetup;
+      this.debugLog = dynamoNTS_GlobalSettings.logSetup;
 
       this.setupRoutingModules();
       this.setSecurity();
@@ -174,10 +201,10 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
           this.mountSecureRoutes();
         }
 
-        if (this.log) console.log(`\nRoutes mounted.... server using security: ${this.security}`);
+        if (this.debugLog) console.log(`\nRoutes mounted.... server using security: ${this.security}`);
       }
     } catch (error) {
-      DynamoNTS_Shared.logError('\nApplication start failed.\n', error);
+      Dynamo_Log.logError('\nApplication start failed.\n', error);
     }
   }
 
@@ -187,10 +214,10 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   private startDB(): void {
     this.mongoose.connection
       .on('error', (error) => {
-        DynamoNTS_Shared.logError('\nUnable to connect to MongoDB server, ERROR: ', error);
+        Dynamo_Log.logError('\nUnable to connect to MongoDB server, ERROR: ', error);
       })
       .once('open', () => {
-        DynamoNTS_Shared.logSuccess('\nConnected to MongoDB\n');
+        Dynamo_Log.logSuccess('\nConnected to MongoDB\n');
       });
 
     this.mongoose.connect(
@@ -224,7 +251,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
             });
           }
         });
-        DynamoNTS_Shared.logError(errorMsg);
+        Dynamo_Log.logError(errorMsg);
 
         let error = new Error('Open routes cannot be established!');
         let errorStack: string[] = error.stack.split('\n');
@@ -261,7 +288,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
             });
           }
         });
-        DynamoNTS_Shared.logError(errorMsg);
+        Dynamo_Log.logError(errorMsg);
 
         let error = new Error('Secure routes cannot be established!');
         let errorStack: string[] = error.stack.split('\n');
@@ -307,30 +334,30 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
       if (this.security !== DynamoNTS_RouteSecurity.open) {
         this.httpsServer
           .listen(this.httpsPort, 'localhost', 0, () => {
-            DynamoNTS_Shared.logSuccess(`\nHTTPS (secure) server is listening on port ${this.httpsPort}\n`);
+            Dynamo_Log.logSuccess(`\nHTTPS (secure) server is listening on port ${this.httpsPort}\n`);
           })
           .on('error', (error) => {
-            DynamoNTS_Shared.logError(`\nHTTPS (secure) server ERROR`, error);
+            Dynamo_Log.logError(`\nHTTPS (secure) server ERROR`, error);
           })
           .on('uncaughtException', (ex) => {
-            DynamoNTS_Shared.logWarning(`\nHTTPS (secure) server uncaughtException`, ex);
+            Dynamo_Log.logWarning(`\nHTTPS (secure) server uncaughtException`, ex);
           });
       }
 
       if (this.security !== DynamoNTS_RouteSecurity.secure) {
         this.openExpress
           .listen(this.httpPort, () => {
-            DynamoNTS_Shared.logSuccess(`\nHTTP  (-open-) server is listening on port ${this.httpPort}\n`);
+            Dynamo_Log.logSuccess(`\nHTTP  (-open-) server is listening on port ${this.httpPort}\n`);
           })
           .on('error', (error) => {
-            DynamoNTS_Shared.logError(`\nHTTP  (-open-) server ERROR`, error);
+            Dynamo_Log.logError(`\nHTTP  (-open-) server ERROR`, error);
           })
           .on('uncaughtException', (ex) => {
-            DynamoNTS_Shared.logWarning(`\nHTTP  (-open-) server uncaughtException`, ex);
+            Dynamo_Log.logWarning(`\nHTTP  (-open-) server uncaughtException`, ex);
           });
       }
     } catch (error) {
-      DynamoNTS_Shared.logError(`startExpresses failed...`, error);
+      Dynamo_Log.logError(`startExpresses failed...`, error);
     }
   }
 
@@ -340,7 +367,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   private mountSecureRoutes (): void {
     this.routingModules.forEach((module: DynamoNTS_RoutingModule) => {
       if (module.security !== DynamoNTS_RouteSecurity.open) {
-        if (this.log) console.log(`route mount (secure): ${module.route}`);
+        if (this.debugLog) console.log(`route mount (secure): ${module.route}`);
         const existingRoutes: DynamoNTS_RoutingModule[] = this.routingModules.filter(
             (mod: DynamoNTS_RoutingModule) => mod.route === module.route);
         if (1 < existingRoutes.length) {
@@ -362,7 +389,7 @@ export abstract class DynamoNTS_App extends DynamoNTS_SingletonService {
   private mountOpenRoutes (): void {
     this.routingModules.forEach((module: DynamoNTS_RoutingModule) => {
       if (module.security !== DynamoNTS_RouteSecurity.secure) {
-        if (this.log) console.log(`route mount (open): ${module.route}`);
+        if (this.debugLog) console.log(`route mount (open): ${module.route}`);
         const existingRoutes: DynamoNTS_RoutingModule[] = this.routingModules.filter(
             (mod: DynamoNTS_RoutingModule) => mod.route === module.route);
         if (1 < existingRoutes.length) {

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

@@ -65,7 +65,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    *     let token = AuthService.getTokenFromRequest(req);
    *     token = await AuthService.verifyToken(token);
    * 
-   *     DynamoNTS_Shared.logSuccess('token authenticated');
+   *     Dynamo_Log.logSuccess('token authenticated');
    *     res.setHeader('authorization', `Bearer ${token}`);
    *     next();
    *   } catch (error) {
@@ -76,7 +76,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    *       userMessage: `Authorization failed.`, 
    *       error 
    *     });
-   *     DynamoNTS_Shared.logError(error?.message, error);
+   *     Dynamo_Log.logError(error?.message, error);
    * 
    *     res.status(error.status);
    *     res.send(error);
@@ -99,7 +99,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    *   try {
    *     let token = AuthService.getTokenFromRequest(req);
    *     token = await AuthService.verifyTokenSelf(token, req?.params?.userId);
-   *     DynamoNTS_Shared.logSuccess('selftoken authenticated');
+   *     Dynamo_Log.logSuccess('selftoken authenticated');
    * 
    *     res.setHeader('authorization', `Bearer ${token}`);
    *     next();
@@ -111,7 +111,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    *       userMessage: `Authorization failed.`, 
    *       error 
    *     });
-   *     DynamoNTS_Shared.logError(error?.message, error);
+   *     Dynamo_Log.logError(error?.message, error);
    * 
    *     res.status(error.status);
    *     res.send(error);

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

@@ -1,7 +1,7 @@
 
 
+import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
 import { DynamoNTS_EndpointParams } from '../_models/dynamo-nts-endpoint-params';
-import { DynamoNTS_Shared } from './dynamo-nts-shared.service';
 import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
 
 /**
@@ -46,6 +46,33 @@ import { DynamoNTS_SingletonService } from './dynamo-nts-singleton.service';
  */
 export abstract class DynamoNTS_Controller extends DynamoNTS_SingletonService {
 
+  /**
+   * setup this in the setupEndpoints(), which will be called on the construcion
+   * 
+   * @example
+   * 
+   * this.endpoints = [
+   *   new DynamoNTS_EndpointParams({
+   *     name: 'getUserMatchStatistics',
+   *     type: HttpCallType.get,
+   *     endpoint: '/get/user-match-statistics/:userId',
+   *     preProcessess: [ this.authService.authenticateTokenSelf ],
+   *     tasks: [ 
+   *       async (req: Request, res: Response) => {
+   *         const userMatchStatistics = new UserMatchStatisticsService({ 
+   *           data: { userId: req.params.userId }
+   *         });
+   * 
+   *         await userMatchStatistics.getDataByDependencyId();
+   *         
+   *         res.send(
+   *           userMatchStatistics.data
+   *         );
+   *       }
+   *     ]
+   *   }),
+   * ];
+   */
   endpoints: DynamoNTS_EndpointParams[];
 
   protected constructor(){
@@ -54,12 +81,40 @@ export abstract class DynamoNTS_Controller extends DynamoNTS_SingletonService {
     try {
       this.setupEndpoints();
     } catch (error) {
-      DynamoNTS_Shared.logError(`DynamoBEController ERROR setup failed:`, error);
+      Dynamo_Log.logError(`DynamoBEController ERROR setup failed:`, error);
     }
   }
 
   /**
    * You must setup endpoints and required services in this function
+   * 
+   * @example
+   * 
+   * setupEndpoints(): void {
+   *   this.authService = AuthService.getInstance();
+   *
+   *   this.endpoints = [
+   *     new DynamoNTS_EndpointParams({
+   *       name: 'getUserMatchStatistics',
+   *       type: HttpCallType.get,
+   *       endpoint: '/get/user-match-statistics/:userId',
+   *       preProcessess: [ this.authService.authenticateTokenSelf ],
+   *       tasks: [ 
+   *         async (req: Request, res: Response) => {
+   *           const userMatchStatistics = new UserMatchStatisticsService({ 
+   *             data: { userId: req.params.userId }
+   *           });
+   *
+   *           await userMatchStatistics.getDataByDependencyId();
+   *             
+   *           res.send(
+   *             userMatchStatistics.data
+   *           );
+   *         }
+   *       ]
+   *     }),
+   *   ];
+   * }
    */
   abstract setupEndpoints(): void
 }