@futdevpro/nts-dynamo 1.15.64 → 1.15.68

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

@@ -1,607 +1,607 @@
-
-import * as Axios from 'axios';
-
-import {
-  DyFM_AnyError, DyFM_Error, DyFM_Error_Settings,
-  DyFM_errorFlag,
-  DyFM_ErrorLevel,
-  DyFM_HttpCallType, DyFM_HttpResponseType,
-  DyFM_Log,
-  DyFM_HttpErrorResponse,
-  DyFM_Object,
-  DyFM_getLocalStackLocation
-} from '@futdevpro/fsm-dynamo';
-
-import { DyNTS_global_settings } from '../../_collections/global-settings.const';
-import {
-  DyNTS_ApiCall_Params
-} from '../../_models/control-models/api-call-params.control-model';
-
-export interface DyNTS_ApiCallInput_Params<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 DyNTS_ApiService {
-
-  static readonly defaultErrorUserMsg =
-    `We encountered a BackEnd API Error, ` +
-    `\nplease contact the responsible development team.\n` +
-    `\n(Internal BE to BE error)`;
-
-  /**
-   * if the callParams.getFullResponse is set to true, 
-   * use the Axios.AxiosResponse type as T_Response
-   * 
-   * @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 DyNTS_ApiCall_Params({ ... })
-     */
-    callParams: DyNTS_ApiCall_Params,
-    /**
-     * you can pass data and other inputs in this section
-     */
-    inputParams?: DyNTS_ApiCallInput_Params<T_Body>
-  ): Promise<T_Response /* | Axios.AxiosResponse */> {
-    let url: string;
-
-    try {
-      let a: T_Response;
-      url = callParams.baseUrl + callParams.endpoint;
-      const axios = Axios.default.create();
-
-      if (!callParams.baseUrl) {
-        DyFM_Log.warn(`WARNING: missing baseUrl in api call (${callParams.name})`);
-      }
-
-      if (!callParams.endpoint) {
-        DyFM_Log.warn(`WARNING: missing endpoint in api call (${callParams.name})`);
-      }
-
-      if (callParams.pathParamKeys.length) {
-        callParams.pathParamKeys.forEach(key => {
-          if (!inputParams?.pathParams?.[key]) {
-            throw new DyFM_Error({
-              ...this._getDefaultErrorSettings(
-                'startApiCall',
-                new Error(`missing pathParam: "${key}" (${callParams.name})`)
-              ),
-              errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SAC1`,
-            });
-          }
-        });
-      }
-
-      if (callParams?.httpOptions) {
-        this.setupAxiosConfig(callParams, axios);
-      }
-
-      if (inputParams?.pathParams) {
-        url = this.setupPathParams(inputParams.pathParams, url, callParams);
-      }
-
-      /* if (inputParams?.queryParams) {
-        this.setupQueryParams<T_Body>(inputParams, callParams);
-      } */
-
-      if (DyNTS_global_settings.log_settings.api_events) {
-        this.logEvent(url, inputParams, callParams);
-      }
-
-      switch (callParams.type) {
-        case DyFM_HttpCallType.get:
-          if (inputParams?.body) {
-            DyFM_Log.warn(`WARNING you cant send body in get calls (${callParams.name})`);
-          }
-
-          a = await this.get<T_Response>(axios, url, callParams);
-          break;
-
-        case DyFM_HttpCallType.delete:
-          if (inputParams?.body) {
-            DyFM_Log.warn('WARNING you cant send body in delete calls');
-          }
-
-          a = await this.delete<T_Response>(axios, url, callParams);
-          break;
-
-        case DyFM_HttpCallType.post:
-        case DyFM_HttpCallType.put:
-        case DyFM_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:
-          throw new DyFM_Error({
-            ...this._getDefaultErrorSettings(
-              'startApiCall',
-              new Error(`unknown api call type: ${callParams.type}`)
-            ),
-            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SAC0`,
-            additionalContent: {
-              callParams,
-              inputParams,
-            },
-          });
-      }
-
-      if ((a as DyFM_Error)?.flag?.includes(DyFM_errorFlag)) {
-        throw a;
-      }
-
-      return a;
-      /* if (callParams.getFullResponse) {
-        return a as T_Response Axios.AxiosResponse;
-
-      } else {
-        return a as T_Response;
-      } */
-    } catch (error) {
-      if ((error as DyFM_Error)?.flag?.includes(DyFM_errorFlag)) {
-        throw error;
-      /* } else if ((error?.response?.data as DyFM_Error)?.flag?.includes(DyFM_errorFlag) &&
-        [
-          DyFM_ErrorLevel.user,
-          DyFM_ErrorLevel.debug,
-          DyFM_ErrorLevel.info,
-          DyFM_ErrorLevel.known,
-          DyFM_ErrorLevel.warning,
-        ].includes((error?.response?.data as DyFM_Error)?.level)
-      ) {
-        return error; */
-      } else {
-        this.handleError<T_Body>(callParams, error, inputParams, url);
-      }
-    }
-  }
-
-  /* private static setupQueryParams<T_Body = any>(
-    inputParams: DyNTS_ApiCallInputParams<T_Body>, callParams: DyNTS_ApiCall_Params) {
-    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('DYNAMO-NTS ERROR: \n wrong query param type', '\n\n', new Error());
-            break;
-        }
-      }
-    }
-    callParams.httpOptions.params = httpParams;
-  } */
-
-  private static handleError<T_Body>(
-    callParams: DyNTS_ApiCall_Params,
-    error: DyFM_AnyError | Axios.AxiosError,
-    inputParams: {
-      pathParams?: { [param: string]: string; };
-      /**
-       * api call's body
-       */
-      body?: T_Body;
-    },
-    url: string
-  ): void {
-    const errorMsg: string = DyFM_Error.isDyFMError((error as Axios.AxiosError)?.response?.data) ?
-      DyFM_Error.getAnyMessage((error as Axios.AxiosError)?.response?.data as DyFM_AnyError) :
-      DyFM_Error.getAnyMessage(error);
-
-    let msg: string = 
-      `\n--->   API ERROR: "${callParams?.name}" failed (${DyFM_Error.getErrorStatus(error)})...` +
-      `\n         endpoint: ${callParams?.type} "${callParams?.baseUrl}${callParams?.endpoint}"` +
-      `\n         BE-BE requestStackLocation: "${callParams?.stack}"` +
-      `\n         error: "${DyFM_Error.getAnyMessage(error)}"` +
-      ((error as DyFM_Error)?.__localStack ? `\n         error localStack: "${(error as DyFM_Error)?.__localStack}"` : '') +
-      `\n         localStack: "${DyFM_getLocalStackLocation(1)}"`;
-
-    if (DyNTS_global_settings.log_settings.detailedErrors) {
-      DyFM_Log.S_error(`${msg}\ncallParams:`, callParams);
-    } else {
-      DyFM_Log.S_error(msg);
-    }
-
-    try {
-      const strError = JSON.stringify(error);
-      if (strError.length < 1000) {
-        msg += `\nerrorObject: ${JSON.stringify(strError, null, 2)}`;
-      }
-    } catch {
-      DyFM_Log.error(`error is not parsable`);
-    }
-
-    if (
-      error && 
-      typeof (error as DyFM_Error)?.error === 'string' && 
-      callParams?.httpOptions?.responseType === DyFM_HttpResponseType.text
-    ) {
-      (error as DyFM_Error).error = DyFM_Object.failableSafeParseJSON(
-        (error as DyFM_Error)?.error as any as string
-      );
-    }
-
-    if (DyFM_Error.isDyFMError((error as Axios.AxiosError)?.response?.data)) {
-      DyFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
-
-      const dyfmErrorInAxiosResponse = (error as Axios.AxiosError)?.response?.data as DyFM_AnyError;
-
-      throw new DyFM_Error({
-        ...this._getDefaultErrorSettings(
-          callParams.name + ' startApiCall',
-          dyfmErrorInAxiosResponse
-        ),
-
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-HE1`,
-        message: 
-          `API call "${callParams.name}" failed on the other end!`+
-          `\nurl: ${url}` +
-          `\nerror response found: ${errorMsg}`,
-        error: dyfmErrorInAxiosResponse,
-        additionalContent: {
-          callParams: callParams,
-          inputParams: inputParams,
-          response: (error as Axios.AxiosError)?.response,
-        },
-      });
-
-    } else if ((error as Axios.AxiosError)?.code === 'ENOTFOUND') {
-      DyFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
-
-      throw new DyFM_Error({
-        ...this._getDefaultErrorSettings(
-          callParams.name + ' startApiCall',
-          error
-        ),
-
-        status: 404,
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-HE2`,
-        message: 'DNS error; address cannot be resolved!',
-        additionalContent: {
-          callParams: callParams,
-          inputParams: inputParams,
-          response: (error as Axios.AxiosError)?.response,
-        },
-      });
-
-    } else if ((error as Axios.AxiosError)?.code === 'ECONNREFUSED') {
-      DyFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
-
-      throw new DyFM_Error({
-        ...this._getDefaultErrorSettings(
-          callParams.name + ' startApiCall',
-          error
-        ),
-
-        status: 404,
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-HE3`,
-        message: `Can't connect to the endpoint! \n(${callParams.type} "${url}")`,
-        additionalContent: {
-          callParams: callParams,
-          inputParams: inputParams,
-          url: url,
-          response: (error as Axios.AxiosError)?.response,
-        },
-      });
-
-    } else if ((error as Axios.AxiosError)?.config && (error as Axios.AxiosError)?.message) {
-
-      let msg: string = (error as Axios.AxiosError)?.message;
-      let status: number = (error as Axios.AxiosError)?.response?.status || 
-        (error as Axios.AxiosError)?.status || 
-        /* get status from "status code {3 digits}" that might be in the middle of the message */
-        +(error as Axios.AxiosError)?.message?.match?.(/status code (\d{3})/)?.[1] ||
-        500;
-
-      if ((error as Axios.AxiosError)?.message?.includes('status code')) {
-        msg += `"${callParams.name}"` +
-          `\nendpoint: ${callParams.type} "${callParams.baseUrl}${callParams.endpoint}"` +
-          `\nurl: ${url}` +
-          `\npathParams: ${
-            inputParams?.pathParams ? 
-              Object.keys(inputParams.pathParams).join(', ') : 
-              '-no path params-'
-          }` +
-          `\nenpointStackLocation: ${callParams.stack}`;
-      }
-
-      throw new DyFM_Error({
-        ...this._getDefaultErrorSettings(
-          callParams.name + ' startApiCall',
-          error
-        ),
-
-        status: status,
-        message: msg,
-        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-HE4`,
-        additionalContent: {
-          callParams: callParams,
-          inputParams: inputParams,
-          response: (error as Axios.AxiosError)?.response,
-        },
-      });
-    } else {
-      DyFM_Error.logSimple(`"${callParams.name}" api call was UNSUCCESSFUL`, error);
-      /* if (
-        DyNTS_global_settings.log_settings.detailedErrors ||
-        !(error instanceof DyFM_Error)
-      ) {
-        DyFM_Log.error(
-          `"${callParams.name}" api call was UNSUCCESSFUL`, 
-          '\nERROR:', error
-        );
-      } else {
-        error.logSimple(`"${callParams.name}" api call was UNSUCCESSFUL`);
-      } */
-
-      throw error;
-    }
-  }
-
-  private static async postPutPatch<T_Response, T_Body>(
-    axios: Axios.AxiosInstance,
-    callParams: DyNTS_ApiCall_Params,
-    url: string,
-    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 (DyNTS_global_settings.log_settings.api_events) {
-        if (DyNTS_global_settings.log_settings.api_responseContents) {
-          DyFM_Log.success(`--->   "${callParams.name}" api call was successful`, res.data);
-
-        } else {
-          DyFM_Log.success(`--->   "${callParams.name}" api call was successful`);
-        }
-      }
-
-      if (callParams.getFullResponse) {
-        return res as T_Response;
-      } else {
-        return res.data;
-      }
-    });
-  }
-
-  private static async delete<T_Response>(
-    axios: Axios.AxiosInstance,
-    url: string,
-    callParams: DyNTS_ApiCall_Params
-  ): Promise<T_Response> {
-    return await axios.delete<T_Response>(url, callParams.httpOptions).then(
-      (res: Axios.AxiosResponse): T_Response => {
-        if (DyNTS_global_settings.log_settings.api_events) {
-          if (DyNTS_global_settings.log_settings.api_responseContents) {
-            DyFM_Log.success(`"${callParams.name}" api call was successful`, res.data);
-          } else {
-            DyFM_Log.success(`"${callParams.name}" api call was successful`);
-          }
-        }
-
-        if (callParams.getFullResponse) {
-          return res as T_Response;
-        } else {
-          return res.data;
-        }
-      }
-    );
-  }
-
-  private static async get<T_Response>(
-    axios: Axios.AxiosInstance,
-    url: string,
-    callParams: DyNTS_ApiCall_Params
-  ): Promise<T_Response> {
-    return await axios.get<T_Response>(url, callParams.httpOptions).then(
-      (res: Axios.AxiosResponse): T_Response => {
-        if (DyNTS_global_settings.log_settings.api_events) {
-          if (DyNTS_global_settings.log_settings.api_responseContents) {
-            DyFM_Log.success(`"${callParams.name}" api call was successful`, res.data);
-          } else {
-            DyFM_Log.success(`"${callParams.name}" api call was successful`);
-          }
-        }
-
-        if (callParams.getFullResponse) {
-          return res as T_Response;
-        } else {
-          return res.data;
-        }
-      }
-    );
-  }
-
-  private static logEvent<T_Body>(
-    url: string,
-    inputParams: DyNTS_ApiCallInput_Params<T_Body>,
-    callParams: DyNTS_ApiCall_Params
-  ): void {
-    if (DyNTS_global_settings.log_settings.api_requestContents) {
-      DyFM_Log.log(
-        `<---   outgoing API call: "${callParams?.name}" ` +
-        `\n(${url})` +
-        `\nbody:`, inputParams?.body
-      );
-
-    } else {
-      DyFM_Log.log(`<---   outgoing API call: "${callParams?.name}"`);
-    }
-
-    if (DyNTS_global_settings.log_settings.api_requestSettings) {
-      DyFM_Log.log(`callParams:`, callParams);
-      DyFM_Log.log('inputParams:', {
-        pathParams: inputParams.pathParams ?? {},
-        body: inputParams.body ?? null,
-      });
-    }
-  }
-
-  private static setupAxiosConfig(
-    callParams: DyNTS_ApiCall_Params,
-    axios: Axios.AxiosInstance
-  ): void {
-    // Ensure axios.defaults exists
-    if (!axios.defaults) {
-      DyFM_Log.error(
-        `ERROR: axios.defaults is undefined in setupAxiosConfig for call (cant set headers and other options): "${callParams.name}"`,
-        '\n  stack:', callParams.stack
-      );
-
-      return;
-    }
-
-    // Set headers
-    if (callParams.httpOptions?.headers) {
-      axios.defaults.headers.common ??= {};
-
-      for (const headerKey in callParams.httpOptions.headers) {
-        if (!callParams.httpOptions.headers[headerKey]) {
-          throw new DyFM_Error({
-            ...this._getDefaultErrorSettings(
-              'setupHeaders',
-              new Error(`missing header: ${headerKey}`)
-            ),
-            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SH0`,
-          });
-        }
-          
-        axios.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
-      }
-    }
-
-    // Set other Axios configuration options
-    if (callParams.httpOptions?.httpsAgent) {
-      axios.defaults.httpsAgent = callParams.httpOptions.httpsAgent;
-    }
-    
-    if (callParams.httpOptions?.httpAgent) {
-      axios.defaults.httpAgent = callParams.httpOptions.httpAgent;
-    }
-
-    if (callParams.httpOptions?.timeout !== undefined) {
-      axios.defaults.timeout = callParams.httpOptions.timeout;
-    }
-
-    if (callParams.httpOptions?.maxRedirects !== undefined) {
-      axios.defaults.maxRedirects = callParams.httpOptions.maxRedirects;
-    }
-
-    if (callParams.httpOptions?.withCredentials !== undefined) {
-      axios.defaults.withCredentials = callParams.httpOptions.withCredentials;
-    }
-
-    if (callParams.httpOptions?.responseType !== undefined) {
-      axios.defaults.responseType = callParams.httpOptions.responseType;
-    }
-  }
-
-  private static setupPathParams(
-    pathParams: { [param: string]: string; },
-    url: string,
-    callParams: DyNTS_ApiCall_Params
-  ): 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;
-
-          default:
-            /* DyFM_Log.error(
-              `DYNAMO-NTS ERROR:`+
-              `\nwrong path param type: (${pathParamKey}): ${paramType} ` +
-              `\n${pathParams[pathParamKey]}` +
-              `\nMUST BE string or number` +
-              `\n\n`,
-              new Error()
-            ); */
-            throw new DyFM_Error({
-              ...this._getDefaultErrorSettings(
-                'setupPathParams',
-                new Error(
-                  `wrong path param type: (${pathParamKey}): "${paramType}" (${callParams.name})` +
-                  `\n${pathParams[pathParamKey]}`
-                )
-              ),
-              errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SP1`,
-              additionalContent: {
-                pathParams: pathParams,
-                url: url,
-              },
-            });
-        }
-      } else {
-        throw new DyFM_Error({
-          ...this._getDefaultErrorSettings(
-            'setupPathParams',
-            new Error(`missing pathParam: "${pathParamKey}" (${callParams.name})`)
-          ),
-          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SP0`,
-        });
-      }
-    }
-
-    return url;
-  }
-
-  private static _getDefaultErrorSettings(
-    fnName: string, 
-    error: DyFM_AnyError
-  ): DyFM_Error_Settings {
-    return {
-      status: (error as DyFM_Error)?.___status ?? 500,
-      message: (error as Error)?.message ?? 
-        (error as DyFM_Error)?._message ??
-        `${fnName} was UNSUCCESSFUL (NTS)`,
-      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
-      userMessage: (error as DyFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
-      issuerService: `${this?.constructor?.name}-${this?.name}-DyNTS_ApiService`,
-      error: error,
-    };
-  }
-}
-
+
+import * as Axios from 'axios';
+
+import {
+  DyFM_AnyError, DyFM_Error, DyFM_Error_Settings,
+  DyFM_errorFlag,
+  DyFM_ErrorLevel,
+  DyFM_HttpCallType, DyFM_HttpResponseType,
+  DyFM_Log,
+  DyFM_HttpErrorResponse,
+  DyFM_Object,
+  DyFM_getLocalStackLocation
+} from '@futdevpro/fsm-dynamo';
+
+import { DyNTS_global_settings } from '../../_collections/global-settings.const';
+import {
+  DyNTS_ApiCall_Params
+} from '../../_models/control-models/api-call-params.control-model';
+
+export interface DyNTS_ApiCallInput_Params<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 DyNTS_ApiService {
+
+  static readonly defaultErrorUserMsg =
+    `We encountered a BackEnd API Error, ` +
+    `\nplease contact the responsible development team.\n` +
+    `\n(Internal BE to BE error)`;
+
+  /**
+   * if the callParams.getFullResponse is set to true, 
+   * use the Axios.AxiosResponse type as T_Response
+   * 
+   * @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 DyNTS_ApiCall_Params({ ... })
+     */
+    callParams: DyNTS_ApiCall_Params,
+    /**
+     * you can pass data and other inputs in this section
+     */
+    inputParams?: DyNTS_ApiCallInput_Params<T_Body>
+  ): Promise<T_Response /* | Axios.AxiosResponse */> {
+    let url: string;
+
+    try {
+      let a: T_Response;
+      url = callParams.baseUrl + callParams.endpoint;
+      const axios = Axios.default.create();
+
+      if (!callParams.baseUrl) {
+        DyFM_Log.warn(`WARNING: missing baseUrl in api call (${callParams.name})`);
+      }
+
+      if (!callParams.endpoint) {
+        DyFM_Log.warn(`WARNING: missing endpoint in api call (${callParams.name})`);
+      }
+
+      if (callParams.pathParamKeys.length) {
+        callParams.pathParamKeys.forEach(key => {
+          if (!inputParams?.pathParams?.[key]) {
+            throw new DyFM_Error({
+              ...this._getDefaultErrorSettings(
+                'startApiCall',
+                new Error(`missing pathParam: "${key}" (${callParams.name})`)
+              ),
+              errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SAC1`,
+            });
+          }
+        });
+      }
+
+      if (callParams?.httpOptions) {
+        this.setupAxiosConfig(callParams, axios);
+      }
+
+      if (inputParams?.pathParams) {
+        url = this.setupPathParams(inputParams.pathParams, url, callParams);
+      }
+
+      /* if (inputParams?.queryParams) {
+        this.setupQueryParams<T_Body>(inputParams, callParams);
+      } */
+
+      if (DyNTS_global_settings.log_settings.api_events) {
+        this.logEvent(url, inputParams, callParams);
+      }
+
+      switch (callParams.type) {
+        case DyFM_HttpCallType.get:
+          if (inputParams?.body) {
+            DyFM_Log.warn(`WARNING you cant send body in get calls (${callParams.name})`);
+          }
+
+          a = await this.get<T_Response>(axios, url, callParams);
+          break;
+
+        case DyFM_HttpCallType.delete:
+          if (inputParams?.body) {
+            DyFM_Log.warn('WARNING you cant send body in delete calls');
+          }
+
+          a = await this.delete<T_Response>(axios, url, callParams);
+          break;
+
+        case DyFM_HttpCallType.post:
+        case DyFM_HttpCallType.put:
+        case DyFM_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:
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'startApiCall',
+              new Error(`unknown api call type: ${callParams.type}`)
+            ),
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SAC0`,
+            additionalContent: {
+              callParams,
+              inputParams,
+            },
+          });
+      }
+
+      if ((a as DyFM_Error)?.flag?.includes(DyFM_errorFlag)) {
+        throw a;
+      }
+
+      return a;
+      /* if (callParams.getFullResponse) {
+        return a as T_Response Axios.AxiosResponse;
+
+      } else {
+        return a as T_Response;
+      } */
+    } catch (error) {
+      if ((error as DyFM_Error)?.flag?.includes(DyFM_errorFlag)) {
+        throw error;
+      /* } else if ((error?.response?.data as DyFM_Error)?.flag?.includes(DyFM_errorFlag) &&
+        [
+          DyFM_ErrorLevel.user,
+          DyFM_ErrorLevel.debug,
+          DyFM_ErrorLevel.info,
+          DyFM_ErrorLevel.known,
+          DyFM_ErrorLevel.warning,
+        ].includes((error?.response?.data as DyFM_Error)?.level)
+      ) {
+        return error; */
+      } else {
+        this.handleError<T_Body>(callParams, error, inputParams, url);
+      }
+    }
+  }
+
+  /* private static setupQueryParams<T_Body = any>(
+    inputParams: DyNTS_ApiCallInputParams<T_Body>, callParams: DyNTS_ApiCall_Params) {
+    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('DYNAMO-NTS ERROR: \n wrong query param type', '\n\n', new Error());
+            break;
+        }
+      }
+    }
+    callParams.httpOptions.params = httpParams;
+  } */
+
+  private static handleError<T_Body>(
+    callParams: DyNTS_ApiCall_Params,
+    error: DyFM_AnyError | Axios.AxiosError,
+    inputParams: {
+      pathParams?: { [param: string]: string; };
+      /**
+       * api call's body
+       */
+      body?: T_Body;
+    },
+    url: string
+  ): void {
+    const errorMsg: string = DyFM_Error.isDyFMError((error as Axios.AxiosError)?.response?.data) ?
+      DyFM_Error.getAnyMessage((error as Axios.AxiosError)?.response?.data as DyFM_AnyError) :
+      DyFM_Error.getAnyMessage(error);
+
+    let msg: string = 
+      `\n--->   API ERROR: "${callParams?.name}" failed (${DyFM_Error.getErrorStatus(error)})...` +
+      `\n         endpoint: ${callParams?.type} "${callParams?.baseUrl}${callParams?.endpoint}"` +
+      `\n         BE-BE requestStackLocation: "${callParams?.stack}"` +
+      `\n         error: "${DyFM_Error.getAnyMessage(error)}"` +
+      ((error as DyFM_Error)?.__localStack ? `\n         error localStack: "${(error as DyFM_Error)?.__localStack}"` : '') +
+      `\n         localStack: "${DyFM_getLocalStackLocation(1)}"`;
+
+    if (DyNTS_global_settings.log_settings.detailedErrors) {
+      DyFM_Log.S_error(`${msg}\ncallParams:`, callParams);
+    } else {
+      DyFM_Log.S_error(msg);
+    }
+
+    try {
+      const strError = JSON.stringify(error);
+      if (strError.length < 1000) {
+        msg += `\nerrorObject: ${JSON.stringify(strError, null, 2)}`;
+      }
+    } catch {
+      DyFM_Log.error(`error is not parsable`);
+    }
+
+    if (
+      error && 
+      typeof (error as DyFM_Error)?.error === 'string' && 
+      callParams?.httpOptions?.responseType === DyFM_HttpResponseType.text
+    ) {
+      (error as DyFM_Error).error = DyFM_Object.failableSafeParseJSON(
+        (error as DyFM_Error)?.error as any as string
+      );
+    }
+
+    if (DyFM_Error.isDyFMError((error as Axios.AxiosError)?.response?.data)) {
+      DyFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
+
+      const dyfmErrorInAxiosResponse = (error as Axios.AxiosError)?.response?.data as DyFM_AnyError;
+
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings(
+          callParams.name + ' startApiCall',
+          dyfmErrorInAxiosResponse
+        ),
+
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-HE1`,
+        message: 
+          `API call "${callParams.name}" failed on the other end!`+
+          `\nurl: ${url}` +
+          `\nerror response found: ${errorMsg}`,
+        error: dyfmErrorInAxiosResponse,
+        additionalContent: {
+          callParams: callParams,
+          inputParams: inputParams,
+          response: (error as Axios.AxiosError)?.response,
+        },
+      });
+
+    } else if ((error as Axios.AxiosError)?.code === 'ENOTFOUND') {
+      DyFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
+
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings(
+          callParams.name + ' startApiCall',
+          error
+        ),
+
+        status: 404,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-HE2`,
+        message: 'DNS error; address cannot be resolved!',
+        additionalContent: {
+          callParams: callParams,
+          inputParams: inputParams,
+          response: (error as Axios.AxiosError)?.response,
+        },
+      });
+
+    } else if ((error as Axios.AxiosError)?.code === 'ECONNREFUSED') {
+      DyFM_Log.error(`\n'${callParams.name}' was UNSUCCESSFUL` /* , new Error() */);
+
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings(
+          callParams.name + ' startApiCall',
+          error
+        ),
+
+        status: 404,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-HE3`,
+        message: `Can't connect to the endpoint! \n(${callParams.type} "${url}")`,
+        additionalContent: {
+          callParams: callParams,
+          inputParams: inputParams,
+          url: url,
+          response: (error as Axios.AxiosError)?.response,
+        },
+      });
+
+    } else if ((error as Axios.AxiosError)?.config && (error as Axios.AxiosError)?.message) {
+
+      let msg: string = (error as Axios.AxiosError)?.message;
+      let status: number = (error as Axios.AxiosError)?.response?.status || 
+        (error as Axios.AxiosError)?.status || 
+        /* get status from "status code {3 digits}" that might be in the middle of the message */
+        +(error as Axios.AxiosError)?.message?.match?.(/status code (\d{3})/)?.[1] ||
+        500;
+
+      if ((error as Axios.AxiosError)?.message?.includes('status code')) {
+        msg += `"${callParams.name}"` +
+          `\nendpoint: ${callParams.type} "${callParams.baseUrl}${callParams.endpoint}"` +
+          `\nurl: ${url}` +
+          `\npathParams: ${
+            inputParams?.pathParams ? 
+              Object.keys(inputParams.pathParams).join(', ') : 
+              '-no path params-'
+          }` +
+          `\nenpointStackLocation: ${callParams.stack}`;
+      }
+
+      throw new DyFM_Error({
+        ...this._getDefaultErrorSettings(
+          callParams.name + ' startApiCall',
+          error
+        ),
+
+        status: status,
+        message: msg,
+        errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-HE4`,
+        additionalContent: {
+          callParams: callParams,
+          inputParams: inputParams,
+          response: (error as Axios.AxiosError)?.response,
+        },
+      });
+    } else {
+      DyFM_Error.logSimple(`"${callParams.name}" api call was UNSUCCESSFUL`, error);
+      /* if (
+        DyNTS_global_settings.log_settings.detailedErrors ||
+        !(error instanceof DyFM_Error)
+      ) {
+        DyFM_Log.error(
+          `"${callParams.name}" api call was UNSUCCESSFUL`, 
+          '\nERROR:', error
+        );
+      } else {
+        error.logSimple(`"${callParams.name}" api call was UNSUCCESSFUL`);
+      } */
+
+      throw error;
+    }
+  }
+
+  private static async postPutPatch<T_Response, T_Body>(
+    axios: Axios.AxiosInstance,
+    callParams: DyNTS_ApiCall_Params,
+    url: string,
+    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 (DyNTS_global_settings.log_settings.api_events) {
+        if (DyNTS_global_settings.log_settings.api_responseContents) {
+          DyFM_Log.success(`--->   "${callParams.name}" api call was successful`, res.data);
+
+        } else {
+          DyFM_Log.success(`--->   "${callParams.name}" api call was successful`);
+        }
+      }
+
+      if (callParams.getFullResponse) {
+        return res as T_Response;
+      } else {
+        return res.data;
+      }
+    });
+  }
+
+  private static async delete<T_Response>(
+    axios: Axios.AxiosInstance,
+    url: string,
+    callParams: DyNTS_ApiCall_Params
+  ): Promise<T_Response> {
+    return await axios.delete<T_Response>(url, callParams.httpOptions).then(
+      (res: Axios.AxiosResponse): T_Response => {
+        if (DyNTS_global_settings.log_settings.api_events) {
+          if (DyNTS_global_settings.log_settings.api_responseContents) {
+            DyFM_Log.success(`"${callParams.name}" api call was successful`, res.data);
+          } else {
+            DyFM_Log.success(`"${callParams.name}" api call was successful`);
+          }
+        }
+
+        if (callParams.getFullResponse) {
+          return res as T_Response;
+        } else {
+          return res.data;
+        }
+      }
+    );
+  }
+
+  private static async get<T_Response>(
+    axios: Axios.AxiosInstance,
+    url: string,
+    callParams: DyNTS_ApiCall_Params
+  ): Promise<T_Response> {
+    return await axios.get<T_Response>(url, callParams.httpOptions).then(
+      (res: Axios.AxiosResponse): T_Response => {
+        if (DyNTS_global_settings.log_settings.api_events) {
+          if (DyNTS_global_settings.log_settings.api_responseContents) {
+            DyFM_Log.success(`"${callParams.name}" api call was successful`, res.data);
+          } else {
+            DyFM_Log.success(`"${callParams.name}" api call was successful`);
+          }
+        }
+
+        if (callParams.getFullResponse) {
+          return res as T_Response;
+        } else {
+          return res.data;
+        }
+      }
+    );
+  }
+
+  private static logEvent<T_Body>(
+    url: string,
+    inputParams: DyNTS_ApiCallInput_Params<T_Body>,
+    callParams: DyNTS_ApiCall_Params
+  ): void {
+    if (DyNTS_global_settings.log_settings.api_requestContents) {
+      DyFM_Log.log(
+        `<---   outgoing API call: "${callParams?.name}" ` +
+        `\n(${url})` +
+        `\nbody:`, inputParams?.body
+      );
+
+    } else {
+      DyFM_Log.log(`<---   outgoing API call: "${callParams?.name}"`);
+    }
+
+    if (DyNTS_global_settings.log_settings.api_requestSettings) {
+      DyFM_Log.log(`callParams:`, callParams);
+      DyFM_Log.log('inputParams:', {
+        pathParams: inputParams.pathParams ?? {},
+        body: inputParams.body ?? null,
+      });
+    }
+  }
+
+  private static setupAxiosConfig(
+    callParams: DyNTS_ApiCall_Params,
+    axios: Axios.AxiosInstance
+  ): void {
+    // Ensure axios.defaults exists
+    if (!axios.defaults) {
+      DyFM_Log.error(
+        `ERROR: axios.defaults is undefined in setupAxiosConfig for call (cant set headers and other options): "${callParams.name}"`,
+        '\n  stack:', callParams.stack
+      );
+
+      return;
+    }
+
+    // Set headers
+    if (callParams.httpOptions?.headers) {
+      axios.defaults.headers.common ??= {};
+
+      for (const headerKey in callParams.httpOptions.headers) {
+        if (!callParams.httpOptions.headers[headerKey]) {
+          throw new DyFM_Error({
+            ...this._getDefaultErrorSettings(
+              'setupHeaders',
+              new Error(`missing header: ${headerKey}`)
+            ),
+            errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SH0`,
+          });
+        }
+          
+        axios.defaults.headers.common[headerKey] = callParams.httpOptions.headers[headerKey];
+      }
+    }
+
+    // Set other Axios configuration options
+    if (callParams.httpOptions?.httpsAgent) {
+      axios.defaults.httpsAgent = callParams.httpOptions.httpsAgent;
+    }
+    
+    if (callParams.httpOptions?.httpAgent) {
+      axios.defaults.httpAgent = callParams.httpOptions.httpAgent;
+    }
+
+    if (callParams.httpOptions?.timeout !== undefined) {
+      axios.defaults.timeout = callParams.httpOptions.timeout;
+    }
+
+    if (callParams.httpOptions?.maxRedirects !== undefined) {
+      axios.defaults.maxRedirects = callParams.httpOptions.maxRedirects;
+    }
+
+    if (callParams.httpOptions?.withCredentials !== undefined) {
+      axios.defaults.withCredentials = callParams.httpOptions.withCredentials;
+    }
+
+    if (callParams.httpOptions?.responseType !== undefined) {
+      axios.defaults.responseType = callParams.httpOptions.responseType;
+    }
+  }
+
+  private static setupPathParams(
+    pathParams: { [param: string]: string; },
+    url: string,
+    callParams: DyNTS_ApiCall_Params
+  ): 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;
+
+          default:
+            /* DyFM_Log.error(
+              `DYNAMO-NTS ERROR:`+
+              `\nwrong path param type: (${pathParamKey}): ${paramType} ` +
+              `\n${pathParams[pathParamKey]}` +
+              `\nMUST BE string or number` +
+              `\n\n`,
+              new Error()
+            ); */
+            throw new DyFM_Error({
+              ...this._getDefaultErrorSettings(
+                'setupPathParams',
+                new Error(
+                  `wrong path param type: (${pathParamKey}): "${paramType}" (${callParams.name})` +
+                  `\n${pathParams[pathParamKey]}`
+                )
+              ),
+              errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SP1`,
+              additionalContent: {
+                pathParams: pathParams,
+                url: url,
+              },
+            });
+        }
+      } else {
+        throw new DyFM_Error({
+          ...this._getDefaultErrorSettings(
+            'setupPathParams',
+            new Error(`missing pathParam: "${pathParamKey}" (${callParams.name})`)
+          ),
+          errorCode: `${DyNTS_global_settings.systemShortCodeName}|DyNTS-API-SP0`,
+        });
+      }
+    }
+
+    return url;
+  }
+
+  private static _getDefaultErrorSettings(
+    fnName: string, 
+    error: DyFM_AnyError
+  ): DyFM_Error_Settings {
+    return {
+      status: (error as DyFM_Error)?.___status ?? 500,
+      message: (error as Error)?.message ?? 
+        (error as DyFM_Error)?._message ??
+        `${fnName} was UNSUCCESSFUL (NTS)`,
+      addECToUserMsg: !(error as DyFM_Error)?.__userMessage,
+      userMessage: (error as DyFM_Error)?.__userMessage ?? this.defaultErrorUserMsg,
+      issuerService: `${this?.constructor?.name}-${this?.name}-DyNTS_ApiService`,
+      error: error,
+    };
+  }
+}
+