@futdevpro/nts-dynamo 1.9.17 → 1.9.19

package/src/_services/core/api.service.ts

@@ -1,17 +1,17 @@
 
 import * as Axios from 'axios';
 import { 
-  DynamoFM_AnyError, DynamoFM_Error, DynamoFM_Error_Settings, DynamoFM_Log 
+  DyFM_AnyError, DyFM_Error, DyFM_Error_Settings, DyFM_Log 
 } from '@futdevpro/fsm-dynamo';
 
-import { DynamoNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
-import { DynamoNTS_HttpResponseType } from '../../_enums/http/http-response-type.enum';
+import { DyNTS_HttpCallType } from '../../_enums/http/http-call-type.enum';
+import { DyNTS_HttpResponseType } from '../../_enums/http/http-response-type.enum';
 import {
-  DynamoNTS_ApiCall_Params
+  DyNTS_ApiCall_Params
 } from '../../_models/control-models/api-call-params.control-model';
-import { DynamoNTS_globalSettings } from '../../_constants';
+import { DyNTS_globalSettings } from '../../_constants';
 
-export interface DynamoNTS_ApiCallInput_Params<T_Body = any> {
+export interface DyNTS_ApiCallInput_Params<T_Body = any> {
   pathParams?: {
     /**
      * path params setted in endpoint
@@ -27,7 +27,7 @@ export interface DynamoNTS_ApiCallInput_Params<T_Body = any> {
 /**
  * This predefined Api service contains the basic API call function which can be used in various ways
  */
-export class DynamoNTS_ApiService {
+export class DyNTS_ApiService {
 
   static defaultErrorUserMsg =
     `We encountered a BackEnd API Error, ` +
@@ -45,13 +45,13 @@ export class DynamoNTS_ApiService {
   public static async startApiCall<T_Response, T_Body = any>(
     /**
      * you must setup the basic api call params with this.
-     * follow the instructions in the constructor: new DynamoNTS_ApiCallParams({ ... })
+     * follow the instructions in the constructor: new DyNTS_ApiCallParams({ ... })
      */
-    callParams: DynamoNTS_ApiCall_Params,
+    callParams: DyNTS_ApiCall_Params,
     /**
      * you can pass data and other inputs in this section
      */
-    inputParams?: DynamoNTS_ApiCallInput_Params<T_Body>
+    inputParams?: DyNTS_ApiCallInput_Params<T_Body>
   ): Promise<T_Response /* | Axios.AxiosResponse */> {
     try {
       let a: T_Response;
@@ -70,30 +70,30 @@ export class DynamoNTS_ApiService {
         this.setupQueryParams<T_Body>(inputParams, callParams);
       } */
 
-      if (DynamoNTS_globalSettings.logApiEvents) {
+      if (DyNTS_globalSettings.logApiEvents) {
         this.logEvent(url, inputParams, callParams);
       }
 
       switch (callParams.type) {
-        case DynamoNTS_HttpCallType.get:
+        case DyNTS_HttpCallType.get:
           if (inputParams?.body) {
-            DynamoFM_Log.warn('WARNING you cant send body in get calls');
+            DyFM_Log.warn('WARNING you cant send body in get calls');
           }
 
           a = await this.get<T_Response>(axios, url, callParams);
           break;
 
-        case DynamoNTS_HttpCallType.delete:
+        case DyNTS_HttpCallType.delete:
           if (inputParams?.body) {
-            DynamoFM_Log.warn('WARNING you cant send body in delete calls');
+            DyFM_Log.warn('WARNING you cant send body in delete calls');
           }
 
           a = await this.delete<T_Response>(axios, url, callParams);
           break;
 
-        case DynamoNTS_HttpCallType.post:
-        case DynamoNTS_HttpCallType.put:
-        case DynamoNTS_HttpCallType.patch:
+        case DyNTS_HttpCallType.post:
+        case DyNTS_HttpCallType.put:
+        case DyNTS_HttpCallType.patch:
           if (!inputParams?.body) {
             if (!inputParams) {
               inputParams = {};
@@ -106,7 +106,7 @@ export class DynamoNTS_ApiService {
           break;
 
         default:
-          throw new DynamoFM_Error({
+          throw new DyFM_Error({
             ...this._getDefaultErrorSettings(
               'startApiCall',
               new Error('wrong api call type')
@@ -117,7 +117,7 @@ export class DynamoNTS_ApiService {
               inputParams,
             },
           });
-          //DynamoFM_Log.error('DYNAMO-NTS ERROR: \n wrong api call type'/* , '\n\n', new Error() */);
+          //DyFM_Log.error('DYNAMO-NTS ERROR: \n wrong api call type'/* , '\n\n', new Error() */);
           break;
       }
 
@@ -133,7 +133,7 @@ export class DynamoNTS_ApiService {
   }
 
   /* private static setupQueryParams<T_Body = any>(
-    inputParams: DynamoNTS_ApiCallInputParams<T_Body>, callParams: DynamoNTS_ApiCallParams) {
+    inputParams: DyNTS_ApiCallInputParams<T_Body>, callParams: DyNTS_ApiCallParams) {
     const httpParams = new HttpParams();
 
     for (const queryParamKey in inputParams.queryParams) {
@@ -157,7 +157,7 @@ export class DynamoNTS_ApiService {
   } */
 
   private static handleError<T_Body>(
-    callParams: DynamoNTS_ApiCall_Params,
+    callParams: DyNTS_ApiCall_Params,
     error: any,
     inputParams: {
       pathParams?: { [param: string]: string; };
@@ -167,23 +167,23 @@ export class DynamoNTS_ApiService {
       body?: T_Body;
     }
   ): void {
-    DynamoFM_Log.error(
+    DyFM_Log.error(
       `\n--->   API ERROR: '${callParams?.name}' failed...` +
       `\n${callParams?.baseUrl}${callParams?.endPoint}`
     );
 
-    if (DynamoNTS_globalSettings.logDetailedErrors) {
-      DynamoFM_Log.error(`\ncallParams:`, callParams);
+    if (DyNTS_globalSettings.logDetailedErrors) {
+      DyFM_Log.error(`\ncallParams:`, callParams);
     }
 
-    if (error && callParams?.httpOptions?.responseType === DynamoNTS_HttpResponseType.text) {
+    if (error && callParams?.httpOptions?.responseType === DyNTS_HttpResponseType.text) {
       error.error = JSON.parse(error?.error);
     }
 
-    if ((error?.response?.data as DynamoFM_Error)?.flag?.includes('DYNAMO')) {
-      DynamoFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
+    if ((error?.response?.data as DyFM_Error)?.flag?.includes('DYNAMO')) {
+      DyFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
 
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           callParams.name + ' startApiCall',
           error.response.data
@@ -198,9 +198,9 @@ export class DynamoNTS_ApiService {
       });
 
     } else if (error.code === 'ENOTFOUND') {
-      DynamoFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
+      DyFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
 
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           callParams.name + ' startApiCall',
           error
@@ -216,9 +216,9 @@ export class DynamoNTS_ApiService {
       });
 
     } else if (error.code === 'ECONNREFUSED') {
-      DynamoFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
+      DyFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
 
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           callParams.name + ' startApiCall',
           error
@@ -235,7 +235,7 @@ export class DynamoNTS_ApiService {
 
     } else if (error.config && error.message) {
 
-      throw new DynamoFM_Error({
+      throw new DyFM_Error({
         ...this._getDefaultErrorSettings(
           callParams.name + ' startApiCall',
           error
@@ -249,7 +249,7 @@ export class DynamoNTS_ApiService {
         },
       });
     } else {
-      DynamoFM_Log.error(
+      DyFM_Log.error(
         `\n${callParams.name} was UNSUCCESSFUL`, 
         error /*, '\n\n' , new Error() */
       );
@@ -260,21 +260,21 @@ export class DynamoNTS_ApiService {
 
   private static async postPutPatch<T_Response, T_Body>(
     axios: Axios.AxiosInstance,
-    callParams: DynamoNTS_ApiCall_Params,
+    callParams: DyNTS_ApiCall_Params,
     url: string,
-    inputParams: DynamoNTS_ApiCallInput_Params<T_Body>
+    inputParams: DyNTS_ApiCallInput_Params<T_Body>
   ): Promise<T_Response> {
     return await axios[callParams.type]<T_Response>(
       url,
       inputParams.body,
       callParams.httpOptions
     ).then((res: Axios.AxiosResponse): T_Response => {
-      if (DynamoNTS_globalSettings.logApiEvents) {
-        if (DynamoNTS_globalSettings.logApiResponseContents) {
-          DynamoFM_Log.success(`--->   '${callParams.name}' api call was successful`, res.data);
+      if (DyNTS_globalSettings.logApiEvents) {
+        if (DyNTS_globalSettings.logApiResponseContents) {
+          DyFM_Log.success(`--->   '${callParams.name}' api call was successful`, res.data);
 
         } else {
-          DynamoFM_Log.success(`--->   '${callParams.name}' api call was successful`);
+          DyFM_Log.success(`--->   '${callParams.name}' api call was successful`);
         }
       }
 
@@ -289,15 +289,15 @@ export class DynamoNTS_ApiService {
   private static async delete<T_Response>(
     axios: Axios.AxiosInstance,
     url: string,
-    callParams: DynamoNTS_ApiCall_Params
+    callParams: DyNTS_ApiCall_Params
   ): Promise<T_Response> {
     return await axios.delete<T_Response>(url, callParams.httpOptions).then(
       (res: Axios.AxiosResponse): T_Response => {
-        if (DynamoNTS_globalSettings.logApiEvents) {
-          if (DynamoNTS_globalSettings.logApiResponseContents) {
-            DynamoFM_Log.success(`'${callParams.name}' was successful`, res.data);
+        if (DyNTS_globalSettings.logApiEvents) {
+          if (DyNTS_globalSettings.logApiResponseContents) {
+            DyFM_Log.success(`'${callParams.name}' was successful`, res.data);
           } else {
-            DynamoFM_Log.success(`'${callParams.name}' was successful`);
+            DyFM_Log.success(`'${callParams.name}' was successful`);
           }
         }
 
@@ -311,15 +311,15 @@ export class DynamoNTS_ApiService {
   private static async get<T_Response>(
     axios: Axios.AxiosInstance,
     url: string,
-    callParams: DynamoNTS_ApiCall_Params
+    callParams: DyNTS_ApiCall_Params
   ): Promise<T_Response> {
     return await axios.get<T_Response>(url, callParams.httpOptions).then(
       (res: Axios.AxiosResponse): T_Response => {
-        if (DynamoNTS_globalSettings.logApiEvents) {
-          if (DynamoNTS_globalSettings.logApiResponseContents) {
-            DynamoFM_Log.success(`'${callParams.name}' was successful`, res.data);
+        if (DyNTS_globalSettings.logApiEvents) {
+          if (DyNTS_globalSettings.logApiResponseContents) {
+            DyFM_Log.success(`'${callParams.name}' was successful`, res.data);
           } else {
-            DynamoFM_Log.success(`'${callParams.name}' was successful`);
+            DyFM_Log.success(`'${callParams.name}' was successful`);
           }
         }
 
@@ -334,23 +334,23 @@ export class DynamoNTS_ApiService {
 
   private static logEvent<T_Body>(
     url: string,
-    inputParams: DynamoNTS_ApiCallInput_Params<T_Body>,
-    callParams: DynamoNTS_ApiCall_Params
+    inputParams: DyNTS_ApiCallInput_Params<T_Body>,
+    callParams: DyNTS_ApiCall_Params
   ): void {
-    if (DynamoNTS_globalSettings.logApiRequestContents) {
-      DynamoFM_Log.log(
+    if (DyNTS_globalSettings.logApiRequestContents) {
+      DyFM_Log.log(
         `<---   outgoing API call: '${callParams?.name}' ` +
         `\n(${url})` +
         `\nbody:`, inputParams?.body
       );
 
     } else {
-      DynamoFM_Log.log(`<---   outgoing API call: '${callParams?.name}'`);
+      DyFM_Log.log(`<---   outgoing API call: '${callParams?.name}'`);
     }
 
-    if (DynamoNTS_globalSettings.logApiRequestSettings) {
-      DynamoFM_Log.log(`callParams:`, callParams);
-      DynamoFM_Log.log('inputParams:', {
+    if (DyNTS_globalSettings.logApiRequestSettings) {
+      DyFM_Log.log(`callParams:`, callParams);
+      DyFM_Log.log('inputParams:', {
         pathParams: inputParams.pathParams ?? {},
         body: inputParams.body ?? null,
       });
@@ -358,7 +358,7 @@ export class DynamoNTS_ApiService {
   }
 
   private static setupHeaders(
-    callParams: DynamoNTS_ApiCall_Params,
+    callParams: DyNTS_ApiCall_Params,
     axios: Axios.AxiosInstance
   ): void {
     for (const headerKey in callParams.httpOptions.headers) {
@@ -366,7 +366,7 @@ export class DynamoNTS_ApiService {
         axios.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
 
       } else {
-        throw new DynamoFM_Error({
+        throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
             'setupHeaders',
             new Error(`missing header: ${headerKey}`)
@@ -398,7 +398,7 @@ export class DynamoNTS_ApiService {
             break;
 
           default:
-            /* DynamoFM_Log.error(
+            /* DyFM_Log.error(
               `DYNAMO-NTS ERROR:`+
               `\nwrong path param type: (${pathParamKey}): ${paramType} ` +
               `\n${pathParams[pathParamKey]}` +
@@ -406,7 +406,7 @@ export class DynamoNTS_ApiService {
               `\n\n`,
               new Error()
             ); */
-            throw new DynamoFM_Error({
+            throw new DyFM_Error({
               ...this._getDefaultErrorSettings(
                 'setupPathParams',
                 new Error(
@@ -423,7 +423,7 @@ export class DynamoNTS_ApiService {
             break;
         }
       } else {
-        throw new DynamoFM_Error({
+        throw new DyFM_Error({
           ...this._getDefaultErrorSettings(
             'setupPathParams',
             new Error(`missing pathParam: ${pathParamKey}`)
@@ -438,14 +438,14 @@ export class DynamoNTS_ApiService {
 
   private static _getDefaultErrorSettings(
     fnName: string, 
-    error: DynamoFM_AnyError
-  ): DynamoFM_Error_Settings {
+    error: DyFM_AnyError
+  ): DyFM_Error_Settings {
     return {
-      status: (error as DynamoFM_Error)?.___status ?? 500,
+      status: (error as DyFM_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,
-      issuerService: `${this?.constructor?.name}-${this?.name}-DynamoNTS_ApiService`,
+      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
+      userMessage: (error as DyFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
+      issuerService: `${this?.constructor?.name}-${this?.name}-DyNTS_ApiService`,
       error: error,
     };
   }

package/src/_services/core/auth.service.ts

@@ -1,9 +1,9 @@
 
 import { Request, Response } from 'express';
 
-import { DynamoFM_Error } from '@futdevpro/fsm-dynamo';
+import { DyFM_Error } from '@futdevpro/fsm-dynamo';
 
-import { DynamoNTS_SingletonService } from '../base/singleton.service';
+import { DyNTS_SingletonService } from '../base/singleton.service';
 
 /**
  * Extend this class as an Auth Service implementation
@@ -18,7 +18,7 @@ import { DynamoNTS_SingletonService } from '../base/singleton.service';
  *   }
  *   ...
  */
-export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
+export abstract class DyNTS_AuthService extends DyNTS_SingletonService {
 
   readonly serviceName: string = 'AuthService';
 
@@ -37,7 +37,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
     const authHeader = req?.headers?.['authorization'];
 
     if (!authHeader) {
-      throw new DynamoFM_Error({ 
+      throw new DyFM_Error({ 
         status: 401,
         errorCode: 'NTS-AS0-GT0',
         addECToUserMsg: true,
@@ -51,7 +51,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
     const token = authHeader.split(' ')[1];
     
     if (!token) {
-      throw new DynamoFM_Error({ 
+      throw new DyFM_Error({ 
         status: 401,
         errorCode: 'NTS-AS0-GT1',
         addECToUserMsg: true,
@@ -76,18 +76,18 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    *     let token = AuthService.getTokenFromRequest(req);
    *     token = await AuthService.verifyToken(token);
    * 
-   *     DynamoFM_Log.success('token authenticated');
+   *     DyFM_Log.success('token authenticated');
    *     res.setHeader('authorization', `Bearer ${token}`);
    *     next();
    *   } catch (error) {
-   *     error = new DynamoFM_Error({ 
+   *     error = new DyFM_Error({ 
    *       status: 401, 
    *       message: `authenticateToken (WB-ERROR)`,
    *       addECToUserMsg: true,
    *       userMessage: `Authorization failed.`, 
    *       error 
    *     });
-   *     DynamoFM_Log.error(error?.message, error);
+   *     DyFM_Log.error(error?.message, error);
    * 
    *     res.status(error.status);
    *     res.send(error);
@@ -110,19 +110,19 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    *   try {
    *     let token = AuthService.getTokenFromRequest(req);
    *     token = await AuthService.verifyTokenSelf(token, req?.params?.userId);
-   *     DynamoFM_Log.success('selftoken authenticated');
+   *     DyFM_Log.success('selftoken authenticated');
    * 
    *     res.setHeader('authorization', `Bearer ${token}`);
    *     next();
    *   } catch (error) {
-   *     error = new DynamoFM_Error({ 
+   *     error = new DyFM_Error({ 
    *       status: 401, 
    *       message: `authenticate_tokenSelf (WB-ERROR)`,
    *       addECToUserMsg: true,
    *       userMessage: `Authorization failed.`, 
    *       error 
    *     });
-   *     DynamoFM_Log.error(error?.message, error);
+   *     DyFM_Log.error(error?.message, error);
    * 
    *     res.status(error.status);
    *     res.send(error);