@futdevpro/nts-dynamo 1.7.16 → 1.7.20

package/src/_services/base/singleton.service.ts

@@ -1,4 +1,3 @@
-import { Dynamo_Log } from '@futdevpro/fsm-dynamo';
 
 /**
  * 
@@ -12,6 +11,7 @@ export class DynamoNTS_SingletonService {
     if (!this.instance) {
       this.instance = new this();
     }
+
     return this.instance;
   }
   /// ---     ---     ---     SINGLETON     ---     ---     --- ///

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

@@ -4,26 +4,41 @@ import { Dynamo_Error, Dynamo_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 { DynamoNTS_ApiCallParams } from '../../_models/control-models/api-call-params.control-model';
+import {
+  DynamoNTS_ApiCallParams
+} from '../../_models/control-models/api-call-params.control-model';
 import { dynamoNTS_globalSettings } from '../../_constants';
 
+export interface DynamoNTS_ApiCallInputParams<T_Body = any> {
+  pathParams?: {
+    /**
+     * path params setted in endpoint
+     */
+    [param: string]: string;
+  };
+  /**
+   * api call's body
+   */
+  body?: T_Body;
+}
+
 /**
  * This predefined Api service contains the basic API call function which can be used in various ways
  */
 export class DynamoNTS_ApiService {
 
-    static defaultErrorUserMsg = 
-        `We encountered a BackEnd API Error, ` +
-        `\nplease contact the responsible development team.\n` +
-        `\n(Internal BE to BE error)`;
+  static defaultErrorUserMsg =
+    `We encountered a BackEnd API Error, ` +
+    `\nplease contact the responsible development team.\n` +
+    `\n(Internal BE to BE error)`;
 
-    /**
-     * 
-     * @param callParams 
-     * @param inputParams 
-     * @returns 
-     */
-  public static async startApiCall<T>(
+  /**
+   * 
+   * @param callParams 
+   * @param inputParams 
+   * @returns 
+   */
+  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({ ... })
@@ -32,235 +47,350 @@ export class DynamoNTS_ApiService {
     /**
      * you can pass data and other inputs in this section
      */
-    inputParams?: {
-      pathParams?: {
-        /**
-         * path params setted in endpoint
-         */
-        [param: string]: string
-      },
+    inputParams?: DynamoNTS_ApiCallInputParams<T_Body>
+  ): Promise<T_Response> {
+    try {
+      let a: T_Response;
+      let url: string = callParams.baseUrl + callParams.endPoint;
+      const axios = Axios.default.create();
+
+      if (callParams?.httpOptions?.headers) {
+        this.setupHeaders(callParams, axios);
+      }
+
+      if (inputParams?.pathParams) {
+        url = this.setupPathParams(inputParams.pathParams, url);
+      }
+
+      /* if (inputParams?.queryParams) {
+        this.setupQueryParams<T_Body>(inputParams, callParams);
+      } */
+
+      if (dynamoNTS_globalSettings.logApiEvents) {
+        this.logEvent(url, inputParams, callParams);
+      }
+
+      switch (callParams.type) {
+        case DynamoNTS_HttpCallType.get:
+          if (inputParams?.body) {
+            Dynamo_Log.warn('WARNING you cant send body in get calls');
+          }
+
+          a = await this.get<T_Response>(axios, url, callParams);
+          break;
+
+        case DynamoNTS_HttpCallType.delete:
+          if (inputParams?.body) {
+            Dynamo_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:
+          if (!inputParams?.body) {
+            if (!inputParams) {
+              inputParams = {};
+            }
+
+            inputParams.body = {} as T_Body;
+          }
+
+          a = await this.postPutPatch<T_Response, T_Body>(axios, callParams, url, inputParams);
+          break;
+
+        default:
+          Dynamo_Log.error('DYNAMOBE ERROR: \n wrong api call type'/* , '\n\n', new Error() */);
+          break;
+      }
+
+      if (callParams.getFullResponse) {
+        return a as Axios.AxiosResponse as T_Response;
+
+      } else {
+        return a as T_Response;
+      }
+    } catch (error) {
+      this.handleError<T_Body>(callParams, error, inputParams);
+    }
+  }
+
+  /* private static setupQueryParams<T_Body = any>(
+    inputParams: DynamoNTS_ApiCallInputParams<T_Body>, callParams: DynamoNTS_ApiCallParams) {
+    const httpParams = new HttpParams();
+
+    for (const queryParamKey in inputParams.queryParams) {
+      if (inputParams.queryParams[queryParamKey]) {
+        switch (typeof inputParams.queryParams[queryParamKey]) {
+          case 'number':
+            httpParams.set(queryParamKey, inputParams.queryParams[queryParamKey].toString());
+            break;
+
+          case 'string':
+            httpParams.set(queryParamKey, inputParams.queryParams[queryParamKey]);
+            break;
+
+          default:
+            console.error('DYNAMOBE ERROR: \n wrong query param type', '\n\n', new Error());
+            break;
+        }
+      }
+    }
+    callParams.httpOptions.params = httpParams;
+  } */
+
+  private static handleError<T_Body>(
+    callParams: DynamoNTS_ApiCallParams,
+    error: any,
+    inputParams: {
+      pathParams?: { [param: string]: string; };
       /**
        * api call's body
        */
-      body?: any
+      body?: T_Body;
     }
-  ): Promise<any> {
-    try {
-        let a: any;
-        let url: string = callParams.baseUrl + callParams.endPoint;
-        const privateAxiosInstance = Axios.default.create();
-
-        if (callParams?.httpOptions?.headers) {
-            for (const headerKey in callParams.httpOptions.headers) {
-                if (callParams.httpOptions.headers[headerKey]) {
-                    privateAxiosInstance.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
-                } else {
-                    Dynamo_Log.error('DYNAMOBE ERROR: \n missing header:', headerKey/* , '\n\n', new Error() */);
-                }
-            }
+  ): void {
+    Dynamo_Log.error(
+      `\n>      API ERROR: ${callParams?.name} failed...` +
+      `\n${callParams?.baseUrl}${callParams?.endPoint}` +
+      `\ncallParams:`, callParams
+    );
+
+    if (error && callParams?.httpOptions?.responseType === DynamoNTS_HttpResponseType.text) {
+      error.error = JSON.parse(error?.error);
+    }
+
+    if ((error?.response?.data as Dynamo_Error)?.flag?.includes('DYNAMO')) {
+      Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL` /* , new Error() */);
+
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          callParams.name + ' startApiCall',
+          error.response.data
+        ),
+
+        errorCode: 'NTS-API-SAC1',
+        message: 'API call failed on the other end! error response found...',
+        additionalContent: {
+          callParams,
+          inputParams,
+        },
+      });
+
+    } else if (error.code === 'ENOTFOUND') {
+      Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL` /* , new Error() */);
+
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          callParams.name + ' startApiCall',
+          error
+        ),
+
+        status: 404,
+        errorCode: 'NTS-API-SAC2',
+        message: 'DNS error; address cannot be resolved!',
+        additionalContent: {
+          callParams,
+          inputParams,
+        },
+      });
+
+    } else if (error.code === 'ECONNREFUSED') {
+      Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL` /* , new Error() */);
+
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          callParams.name + ' startApiCall',
+          error
+        ),
+
+        status: 404,
+        errorCode: 'NTS-API-SAC3',
+        message: `Can't connect to the endpoin!`,
+        additionalContent: {
+          callParams,
+          inputParams,
         }
+      });
 
-        if (inputParams?.pathParams) {
-            for (const pathParamKey in inputParams.pathParams) {
-                if (inputParams.pathParams[pathParamKey]) {
-                    const paramType = typeof inputParams.pathParams[pathParamKey]
-                    switch (paramType) {
-                    case 'number':
-                        url = url.replace(`:${pathParamKey}`, inputParams.pathParams[pathParamKey].toString());
-                        break;
-                    case 'string':
-                        url = url.replace(`:${pathParamKey}`, inputParams.pathParams[pathParamKey]);
-                        break;
-                    default:
-                        Dynamo_Log.error(`DYNAMOBE ERROR: \n wrong path param type: (${pathParamKey}): ${paramType} \n${inputParams.pathParams[pathParamKey]}\nMUST BE string or number\n\n`, new Error());
-                        break;
-                    }
-                } else {
-                    Dynamo_Log.error('DYNAMOBE ERROR: \n missing pathParam:', pathParamKey/* , '\n\n', new Error() */);
-                }
-            }
+    } else if (error.config && error.message) {
+
+      throw new Dynamo_Error({
+        ...this._getDefaultErrorSettings(
+          callParams.name + ' startApiCall',
+          error
+        ),
+
+        status: +error.message.substring(error.message.length - 4, 3),
+        errorCode: 'NTS-API-SAC4',
+        additionalContent: {
+          callParams,
+          inputParams,
+        },
+      });
+    } else {
+      Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`, error /*, '\n\n' , new Error() */);
+
+      throw error;
+    }
+  }
+
+  private static async postPutPatch<T_Response, T_Body>(
+    axios: Axios.AxiosInstance,
+    callParams: DynamoNTS_ApiCallParams,
+    url: string,
+    inputParams: DynamoNTS_ApiCallInputParams<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) {
+          Dynamo_Log.success(`>      ${callParams.name} api call was successful`, res.data);
+
+        } else {
+          Dynamo_Log.success(`>      ${callParams.name} api call was successful`);
         }
+      }
 
-        /* if (inputParams?.queryParams) {
-            const httpParams = new HttpParams();
-            for (const queryParamKey in inputParams.queryParams) {
-            if (inputParams.queryParams[queryParamKey]) {
-                switch (typeof inputParams.queryParams[queryParamKey]) {
-                case 'number':
-                    httpParams.set(queryParamKey, inputParams.queryParams[queryParamKey].toString());
-                    break;
-                case 'string':
-                    httpParams.set(queryParamKey, inputParams.queryParams[queryParamKey]);
-                    break;
-                default:
-                    console.error('DYNAMOBE ERROR: \n wrong query param type', '\n\n', new Error());
-                    break;
-                }
-            }
-            }
-            callParams.httpOptions.params = httpParams;
-        } */
+      if (callParams.getFullResponse) {
+        return res as T_Response;
+      } else {
+        return res.data;
+      }
+    });
+  }
 
+  private static async delete<T_Response>(
+    axios: Axios.AxiosInstance,
+    url: string,
+    callParams: DynamoNTS_ApiCallParams
+  ): 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.logApiRequestContents) {
-                Dynamo_Log.log(`<      outgoing API call: ${url} \nbody:`, inputParams?.body);
-            } else {
-                Dynamo_Log.log(`<      outgoing API call: ${url}`);
-            }
-            if (dynamoNTS_globalSettings.logApiRequestSettings) {
-                Dynamo_Log.log(`callParams:`, callParams);
-                Dynamo_Log.log('inputParams:', { 
-                    pathParams: inputParams.pathParams ?? {}, 
-                    body: inputParams.body ?? null 
-                });
-            }
+          if (dynamoNTS_globalSettings.logApiResponseContents) {
+            Dynamo_Log.success(`${callParams.name} was successful`, res.data);
+          } else {
+            Dynamo_Log.success(`${callParams.name} was successful`);
+          }
         }
 
-        switch (callParams.type) {
-            case DynamoNTS_HttpCallType.get:
-                if (inputParams?.body) {
-                    Dynamo_Log.warn('WARNING you cant send body in get calls');
-                }
-                await privateAxiosInstance.get<T>(url, callParams.httpOptions).then((res: Axios.AxiosResponse ) => {
-                    if (callParams.getFullResponse) {
-                        a = res;
-                    } else {
-                        a = res.data;
-                    }
-
-                    if (dynamoNTS_globalSettings.logApiEvents) {
-                        if (dynamoNTS_globalSettings.logApiResponseContents) {
-                            Dynamo_Log.success(`${callParams.name} was successful`, res.data);
-                        } else {
-                            Dynamo_Log.success(`${callParams.name} was successful`);
-                        }
-                    }
-                });
-            break;
-            case DynamoNTS_HttpCallType.delete:
-                if (inputParams?.body) {
-                    Dynamo_Log.warn('WARNING you cant send body in delete calls');
-                }
-                await privateAxiosInstance.delete<T>(url, callParams.httpOptions).then((res: Axios.AxiosResponse ) => {
-                    if (callParams.getFullResponse) {
-                        a = res;
-                    }
-
-                    if (dynamoNTS_globalSettings.logApiEvents) {
-                        if (dynamoNTS_globalSettings.logApiResponseContents) {
-                            Dynamo_Log.success(`${callParams.name} was successful`, res.data);
-                        } else {
-                            Dynamo_Log.success(`${callParams.name} was successful`);
-                        }
-                    }
-                });
-            break;
-            case DynamoNTS_HttpCallType.post:
-            case DynamoNTS_HttpCallType.put:
-            case DynamoNTS_HttpCallType.patch:
-                if (!inputParams?.body) {
-                    if (!inputParams) {
-                        inputParams = {};
-                    }
-                    inputParams.body = {};
-                }
-                await privateAxiosInstance[callParams.type]<T>(url, inputParams.body, callParams.httpOptions).then((res: Axios.AxiosResponse ) => {
-                    if (callParams.getFullResponse) {
-                        a = res;
-                    } else {
-                        a = res.data;
-                    }
-
-                    if (dynamoNTS_globalSettings.logApiEvents) {
-                        if (dynamoNTS_globalSettings.logApiResponseContents) {
-                            Dynamo_Log.success(`>      ${callParams.name} api call was successful`, res.data);
-                        } else {
-                            Dynamo_Log.success(`>      ${callParams.name} api call was successful`);
-                        }
-                    }
-                });
-            break;
-            default:
-                Dynamo_Log.error('DYNAMOBE ERROR: \n wrong api call type'/* , '\n\n', new Error() */);
-            break;
+        if (callParams.getFullResponse) {
+          return res as T_Response;
+        }
+      }
+    );
+  }
+
+  private static async get<T_Response>(
+    axios: Axios.AxiosInstance,
+    url: string,
+    callParams: DynamoNTS_ApiCallParams
+  ): 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) {
+            Dynamo_Log.success(`${callParams.name} was successful`, res.data);
+          } else {
+            Dynamo_Log.success(`${callParams.name} was successful`);
+          }
         }
 
         if (callParams.getFullResponse) {
-            return a as Axios.AxiosResponse;
+          return res as T_Response;
         } else {
-            return a as T;
+          return res.data;
         }
-    } catch (error) {
+      }
+    );
+  }
+
+  private static logEvent<T_Body>(
+    url: string,
+    inputParams: DynamoNTS_ApiCallInputParams<T_Body>,
+    callParams: DynamoNTS_ApiCallParams
+  ): void {
+    if (dynamoNTS_globalSettings.logApiRequestContents) {
+      Dynamo_Log.log(`<      outgoing API call: ${url} \nbody:`, inputParams?.body);
+
+    } else {
+      Dynamo_Log.log(`<      outgoing API call: ${url}`);
+    }
+
+    if (dynamoNTS_globalSettings.logApiRequestSettings) {
+      Dynamo_Log.log(`callParams:`, callParams);
+      Dynamo_Log.log('inputParams:', {
+        pathParams: inputParams.pathParams ?? {},
+        body: inputParams.body ?? null,
+      });
+    }
+  }
+
+  private static setupHeaders(
+    callParams: DynamoNTS_ApiCallParams,
+    axios: Axios.AxiosInstance
+  ): void {
+    for (const headerKey in callParams.httpOptions.headers) {
+      if (callParams.httpOptions.headers[headerKey]) {
+        axios.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
+
+      } else {
         Dynamo_Log.error(
-            `\n>      API ERROR: ${callParams?.name} failed...` +
-            `\n${callParams?.baseUrl}${callParams?.endPoint}` +
-            `\ncallParams:`, callParams
+          'DYNAMOBE ERROR: \n missing header:',
+          headerKey
         );
+      }
+    }
+  }
 
-        if (callParams?.httpOptions?.responseType === DynamoNTS_HttpResponseType.text) {
-            error.error = JSON.parse(error.error);
-        }
-        
-        if (error?.response?.data?.flag?.includes('DYNAMO')) {
-            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`/* , new Error() */);
-
-            throw new Dynamo_Error({
-                ...this._getDefaultErrorSettings(
-                    callParams.name + ' startApiCall',
-                    error.response.data
-                ),
-
-                errorCode: 'NTS-API-SAC1',
-                message: 'API call failed on the other end! error response found...', 
-            });
-
-        } else if (error.code === 'ENOTFOUND') {
-            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`/* , new Error() */);
-
-            throw new Dynamo_Error({ 
-                ...this._getDefaultErrorSettings(
-                    callParams.name + ' startApiCall',
-                    error
-                ),
-
-                status: 404, 
-                errorCode: 'NTS-API-SAC2',
-                message: 'DNS error; address cannot be resolved!', 
-            });
-
-        } else if (error.code === 'ECONNREFUSED') {
-            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`/* , new Error() */);
-
-            throw new Dynamo_Error({ 
-                ...this._getDefaultErrorSettings(
-                    callParams.name + ' startApiCall',
-                    error
-                ),
-
-                status: 404, 
-                errorCode: 'NTS-API-SAC3',
-                message: `Can't connect to the endpoin!`, 
-            });
-
-        } else if (error.config && error.message) {
-
-            throw new Dynamo_Error({ 
-                ...this._getDefaultErrorSettings(
-                    callParams.name + ' startApiCall',
-                    error
-                ),
-
-                status: +error.message.substring(error.message.length - 4, 3), 
-                errorCode: 'NTS-API-SAC4',
-            });
-        } else {
-            Dynamo_Log.error(`\n${callParams.name} was UNSUCCESSFUL`, error/*, '\n\n' , new Error() */);
+  private static setupPathParams(
+    pathParams: { [param: string]: string; },
+    url: string
+  ): string {
+    for (const pathParamKey in pathParams) {
+      if (pathParams[pathParamKey]) {
+        const paramType = typeof pathParams[pathParamKey];
+
+        switch (paramType) {
+          case 'number':
+            url = url.replace(
+              `:${pathParamKey}`,
+              pathParams[pathParamKey].toString()
+            );
+            break;
+
+          case 'string':
+            url = url.replace(`:${pathParamKey}`, pathParams[pathParamKey]);
+            break;
 
-            throw error;
+          default:
+            Dynamo_Log.error(
+              `DYNAMOBE ERROR: \n wrong path param type: (${pathParamKey}): ${paramType} ` +
+              `\n${pathParams[pathParamKey]}` +
+              `\nMUST BE string or number` +
+              `\n\n`,
+              new Error()
+            );
+            break;
         }
+      } else {
+        Dynamo_Log.error(
+          'DYNAMOBE ERROR: \n missing pathParam:',
+          pathParamKey /* , '\n\n', new Error() */
+        );
+      }
     }
+
+    return url;
   }
-    
+
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
   private static _getDefaultErrorSettings(fnName: string, error: Error | Dynamo_Error) {
     return {
       status: (error as Dynamo_Error)?.___status ?? 500,
@@ -269,7 +399,7 @@ export class DynamoNTS_ApiService {
       userMessage: this.defaultErrorUserMsg,
       issuerService: `${this?.constructor?.name}-${this?.name}-DynamoNTS_ApiService`,
       error: error,
-    }
+    };
   }
 }
 

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

@@ -35,6 +35,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
    */
   static getTokenFromRequest(req: Request): string {
     const authHeader = req.headers['authorization'];
+
     if (!authHeader) {
       throw new Dynamo_Error({ 
         status: 401,
@@ -47,6 +48,7 @@ export abstract class DynamoNTS_AuthService extends DynamoNTS_SingletonService {
     }
 
     const token = authHeader.split(' ')[1];
+    
     if (!token) {
       throw new Dynamo_Error({ 
         status: 401,