@mimik/request-retry 4.0.9 → 4.0.10

package/README.md

@@ -9,41 +9,17 @@ import rp from '@mimik/request-retry';
 ```
 <a name="module_request-retry..rpRetry"></a>
 
-### request-retry~rpRetry(options) ⇒ <code>Promise.&lt;object&gt;</code>
+### request-retry~rpRetry(options) ⇒ <code>Promise.&lt;\*&gt;</code>
 Make a request with retries.
 
 **Kind**: inner method of [<code>request-retry</code>](#module_request-retry)  
-**Returns**: <code>Promise.&lt;object&gt;</code> - A bluebird promise (supports cancellation).  
+**Returns**: <code>Promise.&lt;\*&gt;</code> - A bluebird promise (supports cancellation).  
 **Category**: async  
 **Throws**:
 
 - <code>Error</code> An error produced by `getRichError`, wrapping an
 [Axios](https://www.npmjs.com/package/axios) error or a `TimeoutError`.
 
-The following properties may be added to the `options` object under the `retry` property:
-- retries `{int}`: Maximum number of retries, independent of the `retryStrategy`. Default: `2`.
-  If the value is `< 0` it is set to `0`; if `> 15` it is set to `15`.
-- delay `{int}`: Delay between retries in milliseconds when no `delayStrategy` is provided. Default: `1000`.
-  If the value is `< 20` it is set to `20`; if `> 30000` it is set to `30000`.
-- delayStrategy `{function}`: A function that returns the delay (in milliseconds) to wait before the next retry.
-  Signature: `(nbRetry, err, options, correlationId)`. Must return a number `> 0` and `< 30000`; otherwise `delay` is used.
-- logLevel `{object}`: Controls logging behavior:
-   - *response*: Log level for responses. Invalid values fall back to `silly`.
-   - *error*: Log level for errors. Invalid values fall back to `silly`.
-   - *request*: Log level for requests. Invalid values fall back to `silly`.
-   - *responseDetails*: Detail level when displaying the response: `count`, `type`, or `full`. Default: `type`
-     (invalid values fall back to `type`).
-   - *responseName*: Label associated with the response. Default: `response`
-     (non-string or empty values fall back to `response`).
-- timeout `{int}`: Request timeout (in seconds) applied to the initial request and all retries.
-  If reached, a `TimeoutError` is thrown. Default: `50`. Values `< 10` are set to `10`; values `> 120` are set to `120`.
-- retryStrategy `{function}`: A function that decides whether to retry. Signature:
-  `(nbRetry, err, options, correlationId)`. Must return a boolean; otherwise it is ignored.
-
-The following properties may be added to the `options` object under the `metrics` property:
-- HTTPRequestDuration `{function}`: A `prom-client` metric function to measure request duration.
-- url `{string}`: Optional URL label for the metric. If omitted, the request URL is used.
-
 The **default** `retryStrategy` is:
 
 ```javascript
@@ -55,10 +31,6 @@ defaultRetry = (...args) => {
 };
 ```
 
-If `logLevel` is empty, requests and responses are logged at `info`, the response is logged with full details
-under the `response` property, and request errors generate a `warn`. If logLevel is provided but incomplete,
-only the provided keys are active; missing keys disable that logging.
-
 If not already set, the `User-Agent` header is set to:
 `mimik-{serverType}/{serverVersion}/{serverId} {architecture} {node}`.
 
@@ -70,7 +42,22 @@ To ease migration from `request-promise`, the following adjustments are applied
 **Requires**: <code>module:@mimik/sumologic-winston-logger</code>, <code>module:@mimik/response-helper</code>  
 **Fulfil**: <code>object</code> - The Axios response when `resolveWithFullResponse` is `true`; otherwise `response.data`.  
 
-| Param | Type | Description |
-| --- | --- | --- |
-| options | <code>object</code> | Options for the request (similar to [axios](https://www.npmjs.com/package/axios)). The `validateStatus` option is disabled: an error is thrown for status codes outside **[200, 300)**. An additional option, `resolveWithFullResponse`, controls the return shape: when `true`, the full Axios response object is returned; when `false` or omitted, only `response.data` is returned. |
+| Param | Type | Default | Description |
+| --- | --- | --- | --- |
+| options | <code>object</code> |  | Options for the request (similar to [axios](https://www.npmjs.com/package/axios)). The `validateStatus` option is disabled: an error is thrown for status codes outside **[200, 300)**. An additional option, `resolveWithFullResponse`, controls the return shape: when `true`, the full Axios response object is returned; when `false` or omitted, only `response.data` is returned. |
+| [options.retry] | <code>object</code> |  | Retry configuration. |
+| [options.retry.retries] | <code>number</code> | <code>2</code> | Maximum number of retries, independent of the `retryStrategy`.   If the value is `< 0` it is set to `0`; if `> 15` it is set to `15`. |
+| [options.retry.delay] | <code>number</code> | <code>1000</code> | Delay between retries in milliseconds when no `delayStrategy` is provided.   If the value is `< 20` it is set to `20`; if `> 30000` it is set to `30000`. |
+| [options.retry.delayStrategy] | <code>function</code> |  | A function that returns the delay (in milliseconds) to wait before the next retry.   Signature: `(nbRetry, err, options, correlationId)`. Must return a number `> 0` and `< 30000`; otherwise `delay` is used. |
+| [options.retry.retryStrategy] | <code>function</code> |  | A function that decides whether to retry. Signature:   `(nbRetry, err, options, correlationId)`. Must return a boolean; otherwise it is ignored. |
+| [options.retry.timeout] | <code>number</code> | <code>50</code> | Request timeout (in seconds) applied to the initial request and all retries.   If reached, a `TimeoutError` is thrown. Values `< 10` are set to `10`; values `> 120` are set to `120`. |
+| [options.retry.logLevel] | <code>object</code> |  | Controls logging behavior.   When omitted, requests and responses are logged at `info` with full details, and errors at `warn`.   When provided but incomplete, only the provided keys are active; missing keys disable that logging.   Non-object values are ignored and defaults apply. |
+| [options.retry.logLevel.response] | <code>string</code> |  | Log level for responses. Invalid values fall back to `silly`. |
+| [options.retry.logLevel.error] | <code>string</code> |  | Log level for errors. Invalid values fall back to `silly`. |
+| [options.retry.logLevel.request] | <code>string</code> |  | Log level for requests. Invalid values fall back to `silly`. |
+| [options.retry.logLevel.responseDetails] | <code>string</code> | <code>&quot;&#x27;type&#x27;&quot;</code> | Detail level for the response: `count`, `type`, or `full`.   Invalid values fall back to `type`. When `logLevel` is omitted entirely, the default is `full`. |
+| [options.retry.logLevel.responseName] | <code>string</code> | <code>&quot;&#x27;response&#x27;&quot;</code> | Label associated with the response.   Non-string or empty values fall back to `response`. |
+| [options.metrics] | <code>object</code> |  | Metrics configuration. |
+| [options.metrics.HTTPRequestDuration] | <code>function</code> |  | A `prom-client` metric function to measure request duration. |
+| [options.metrics.url] | <code>string</code> |  | Optional URL label for the metric. If omitted, the request URL is used. |
 

package/index.js

@@ -26,7 +26,7 @@ const DEFAULT_LOGLEVEL_ERROR = 'warn';
 const DEFAULT_LOGLEVEL_REQUEST = 'info';
 
 const MILLI = 1000;
-const NANO_TO_MS = 1000000;
+const NS_PER_MS = 1000000;
 
 Promise.config({ cancellation: true });
 
@@ -49,34 +49,35 @@ Promise.config({ cancellation: true });
  * The `validateStatus` option is disabled: an error is thrown for status codes outside **[200, 300)**.
  * An additional option, `resolveWithFullResponse`, controls the return shape:
  * when `true`, the full Axios response object is returned; when `false` or omitted, only `response.data` is returned.
- * @return {Promise<object>} A bluebird promise (supports cancellation).
- * @fulfil {object} - The Axios response when `resolveWithFullResponse` is `true`; otherwise `response.data`.
- * @throws {Error} An error produced by `getRichError`, wrapping an
- * [Axios](https://www.npmjs.com/package/axios) error or a `TimeoutError`.
- *
- * The following properties may be added to the `options` object under the `retry` property:
- * - retries `{int}`: Maximum number of retries, independent of the `retryStrategy`. Default: `2`.
+ * @param {object} [options.retry] - Retry configuration.
+ * @param {number} [options.retry.retries=2] - Maximum number of retries, independent of the `retryStrategy`.
  *   If the value is `< 0` it is set to `0`; if `> 15` it is set to `15`.
- * - delay `{int}`: Delay between retries in milliseconds when no `delayStrategy` is provided. Default: `1000`.
+ * @param {number} [options.retry.delay=1000] - Delay between retries in milliseconds when no `delayStrategy` is provided.
  *   If the value is `< 20` it is set to `20`; if `> 30000` it is set to `30000`.
- * - delayStrategy `{function}`: A function that returns the delay (in milliseconds) to wait before the next retry.
+ * @param {Function} [options.retry.delayStrategy] - A function that returns the delay (in milliseconds) to wait before the next retry.
  *   Signature: `(nbRetry, err, options, correlationId)`. Must return a number `> 0` and `< 30000`; otherwise `delay` is used.
- * - logLevel `{object}`: Controls logging behavior:
- *    - *response*: Log level for responses. Invalid values fall back to `silly`.
- *    - *error*: Log level for errors. Invalid values fall back to `silly`.
- *    - *request*: Log level for requests. Invalid values fall back to `silly`.
- *    - *responseDetails*: Detail level when displaying the response: `count`, `type`, or `full`. Default: `type`
- *      (invalid values fall back to `type`).
- *    - *responseName*: Label associated with the response. Default: `response`
- *      (non-string or empty values fall back to `response`).
- * - timeout `{int}`: Request timeout (in seconds) applied to the initial request and all retries.
- *   If reached, a `TimeoutError` is thrown. Default: `50`. Values `< 10` are set to `10`; values `> 120` are set to `120`.
- * - retryStrategy `{function}`: A function that decides whether to retry. Signature:
+ * @param {Function} [options.retry.retryStrategy] - A function that decides whether to retry. Signature:
  *   `(nbRetry, err, options, correlationId)`. Must return a boolean; otherwise it is ignored.
- *
- * The following properties may be added to the `options` object under the `metrics` property:
- * - HTTPRequestDuration `{function}`: A `prom-client` metric function to measure request duration.
- * - url `{string}`: Optional URL label for the metric. If omitted, the request URL is used.
+ * @param {number} [options.retry.timeout=50] - Request timeout (in seconds) applied to the initial request and all retries.
+ *   If reached, a `TimeoutError` is thrown. Values `< 10` are set to `10`; values `> 120` are set to `120`.
+ * @param {object} [options.retry.logLevel] - Controls logging behavior.
+ *   When omitted, requests and responses are logged at `info` with full details, and errors at `warn`.
+ *   When provided but incomplete, only the provided keys are active; missing keys disable that logging.
+ *   Non-object values are ignored and defaults apply.
+ * @param {string} [options.retry.logLevel.response] - Log level for responses. Invalid values fall back to `silly`.
+ * @param {string} [options.retry.logLevel.error] - Log level for errors. Invalid values fall back to `silly`.
+ * @param {string} [options.retry.logLevel.request] - Log level for requests. Invalid values fall back to `silly`.
+ * @param {string} [options.retry.logLevel.responseDetails='type'] - Detail level for the response: `count`, `type`, or `full`.
+ *   Invalid values fall back to `type`. When `logLevel` is omitted entirely, the default is `full`.
+ * @param {string} [options.retry.logLevel.responseName='response'] - Label associated with the response.
+ *   Non-string or empty values fall back to `response`.
+ * @param {object} [options.metrics] - Metrics configuration.
+ * @param {Function} [options.metrics.HTTPRequestDuration] - A `prom-client` metric function to measure request duration.
+ * @param {string} [options.metrics.url] - Optional URL label for the metric. If omitted, the request URL is used.
+ * @return {Promise<*>} A bluebird promise (supports cancellation).
+ * @fulfil {object} - The Axios response when `resolveWithFullResponse` is `true`; otherwise `response.data`.
+ * @throws {Error} An error produced by `getRichError`, wrapping an
+ * [Axios](https://www.npmjs.com/package/axios) error or a `TimeoutError`.
  *
  * The **default** `retryStrategy` is:
  *
@@ -89,10 +90,6 @@ Promise.config({ cancellation: true });
  * };
  * ```
  *
- * If `logLevel` is empty, requests and responses are logged at `info`, the response is logged with full details
- * under the `response` property, and request errors generate a `warn`. If logLevel is provided but incomplete,
- * only the provided keys are active; missing keys disable that logging.
- *
  * If not already set, the `User-Agent` header is set to:
  * `mimik-{serverType}/{serverVersion}/{serverId} {architecture} {node}`.
  *
@@ -103,20 +100,21 @@ Promise.config({ cancellation: true });
  */
 export const rpRetry = (origOptions) => {
   const startHrTime = process.hrtime.bigint();
-  const options = origOptions;
+  const options = { ...origOptions };
   const { metrics } = options;
-  const enteredUrl = options.uri || options.url;
+  delete options.metrics;
+  const enteredUrl = options.uri || options.url || '';
   const correlationId = (options.headers && options.headers['x-correlation-id']) ? options.headers['x-correlation-id'] : getCorrelationId();
   const errors = [];
   const delayPromises = [];
   const criteria = validateOptions(options, correlationId);
   const { logLevel } = criteria;
-  const logLevelLength = Object.keys(logLevel).length;
+  const hasLogLevel = Object.keys(logLevel).length > 0;
   let nbRetries = 0;
   let mainTimeout;
   const measure = (statusCode) => {
     if (metrics && metrics.HTTPRequestDuration) {
-      const elapsedTimeInMs = Number(process.hrtime.bigint() - startHrTime) / NANO_TO_MS;
+      const elapsedTimeInMs = Number(process.hrtime.bigint() - startHrTime) / NS_PER_MS;
 
       metrics.HTTPRequestDuration
         .labels('rpRetry', options.method, metrics.url || enteredUrl, enteredUrl.includes('?'), statusCode)
@@ -127,7 +125,6 @@ export const rpRetry = (origOptions) => {
   if (!options.headers) options.headers = { 'user-agent': setUserAgent() };
   else if (!options.headers['user-agent']) options.headers['user-agent'] = setUserAgent();
   const optionsInfo = { ...options };
-  delete optionsInfo.metrics;
 
   const retryProcess = nbRetry => rp(options)
     .then((response) => {
@@ -137,7 +134,7 @@ export const rpRetry = (origOptions) => {
         info[logLevel.responseName] = setResponse(response, logLevel.responseDetails);
         logger[logLevel.response]('request response', info, correlationId);
       }
-      else if (logLevelLength === 0) {
+      else if (!hasLogLevel) {
         info[DEFAULT_RESPONSE_NAME] = setResponse(response, DEFAULT_LOGLEVEL_DETAILS);
         logger[DEFAULT_LOGLEVEL_RESPONSE]('request response', info, correlationId);
       }
@@ -150,7 +147,10 @@ export const rpRetry = (origOptions) => {
         const delayPromise = Promise.delay(calculateDelay(options, nbRetry, criteria, err, correlationId));
 
         delayPromises.unshift(delayPromise);
-        return delayPromise.then(() => retryProcess(nbRetry + 1));
+        return delayPromise.then(() => {
+          delayPromises.pop();
+          return retryProcess(nbRetry + 1);
+        });
       }
       const error = err;
 
@@ -166,12 +166,13 @@ export const rpRetry = (origOptions) => {
         'request error response',
         { options: optionsInfo },
         error,
-        logLevel.error || ((logLevelLength === 0) ? DEFAULT_LOGLEVEL_ERROR : undefined),
+        logLevel.error || (hasLogLevel ? undefined : DEFAULT_LOGLEVEL_ERROR),
         correlationId,
       );
     });
 
   const retryPromise = retryProcess(0);
+  // bluebird Promise — .cancel() requires cancellation: true (line 31)
   const mainTimeoutPromise = new Promise((resolve, reject) => {
     mainTimeout = setTimeout(() => {
       delayPromises.forEach(delayPromise => delayPromise.cancel(`retry timeout delay, ${criteria.timeout}, ${nbRetries}`));
@@ -186,7 +187,7 @@ export const rpRetry = (origOptions) => {
         'request error response',
         { options: optionsInfo },
         error,
-        logLevel.error || ((logLevelLength === 0) ? DEFAULT_LOGLEVEL_ERROR : undefined),
+        logLevel.error || (hasLogLevel ? undefined : DEFAULT_LOGLEVEL_ERROR),
         correlationId,
       );
       reject(error);
@@ -194,7 +195,7 @@ export const rpRetry = (origOptions) => {
   });
 
   if (logLevel.request) logger[logLevel.request]('making a request', { options: optionsInfo, criteria }, correlationId);
-  else if (logLevelLength === 0) logger[DEFAULT_LOGLEVEL_REQUEST]('making a request', { options: optionsInfo, criteria }, correlationId);
+  else if (!hasLogLevel) logger[DEFAULT_LOGLEVEL_REQUEST]('making a request', { options: optionsInfo, criteria }, correlationId);
   return Promise.race([retryPromise, mainTimeoutPromise])
     .then((result) => {
       mainTimeoutPromise.cancel('main timeout');

package/lib/common.js

@@ -1,13 +1,9 @@
-const PARAMETER_ERROR = 400;
 const TOO_MANY_REQUESTS_ERROR = 429;
 const SYSTEM_ERROR = 500;
 const OK = 200;
-const CREATED = 201;
 
 export {
-  PARAMETER_ERROR,
   TOO_MANY_REQUESTS_ERROR,
   SYSTEM_ERROR,
   OK,
-  CREATED,
 };

package/lib/rp-axios-wrapper.js

@@ -4,7 +4,6 @@ import { getRichError } from '@mimik/response-helper';
 const rp = (origOptions) => {
   const options = { ...origOptions }; // we will not do deep manipulation
 
-  if (options.metrics) delete options.metrics; // metrics has circular references
   if (options.uri) options.url = options.uri;
   delete options.uri;
   delete options.validateStatus;

package/lib/validate.js

@@ -2,9 +2,9 @@ import { TOO_MANY_REQUESTS_ERROR } from './common.js';
 import logger from '@mimik/sumologic-winston-logger';
 
 const DETAILS = ['full', 'type', 'count'];
-const [, TYPE/* type */] = DETAILS;
+const [, TYPE] = DETAILS;
 const RESPONSE = 'response';
-const [, , , , , DEFAULT_LOGLEVEL/* 'silly' */] = logger.LEVELS;
+const DEFAULT_LOGLEVEL = 'silly';
 const DEFAULT_RETRIES = 2;
 const MIN_RETRIES = 0;
 const MAX_RETRIES = 15;
@@ -47,7 +47,7 @@ const validateOptions = (options, correlationId) => {
     timeout,
   } = options.retry;
   const validateLogLevel = (val, name) => {
-    if (!val[name]) return null;
+    if (val[name] === undefined || val[name] === null) return null;
     if (!logger.LEVELS.includes(val[name])) {
       logger.warn(`invalid logLevel.${name}, reset to default`, { name, value: val[name], default: DEFAULT_LOGLEVEL }, correlationId);
       return DEFAULT_LOGLEVEL;
@@ -78,7 +78,7 @@ const validateOptions = (options, correlationId) => {
     return val;
   };
   const validateResponseName = (val, name, defaultValue) => {
-    if (!val && val !== '') return defaultValue;
+    if (val === undefined || val === null) return defaultValue;
     if (typeof val !== 'string' || val.length === 0 || val.trim().length === 0) {
       logger.warn(`invalid logLevel.${name}, reset to default`, { name, value: val, defaultValue }, correlationId);
       return defaultValue;
@@ -91,25 +91,28 @@ const validateOptions = (options, correlationId) => {
   delay = validateValue(delay, 'delay', DEFAULT_DELAY, MIN_DELAY, MAX_DELAY);
   retries = validateValue(retries, 'retries', DEFAULT_RETRIES, MIN_RETRIES, MAX_RETRIES);
   if (typeof delayStrategy !== 'function') {
-    if (delayStrategy) {
-      logger.warn('invalid delayStrategy, using delay', { strategyType: typeof delayStrategy, delay, default: DEFAULT_DELAY }, correlationId);
-      delayStrategy = setDelay;
-    }
-    else delayStrategy = setDelay;
+    if (delayStrategy) logger.warn('invalid delayStrategy, using delay', { strategyType: typeof delayStrategy, delay, default: DEFAULT_DELAY }, correlationId);
+    delayStrategy = setDelay;
   }
   if (typeof retryStrategy !== 'function') {
     if (retryStrategy) {
-      logger.warn('invalid retryStrategy, ignoring', { strategyType: typeof retryStrategy, using: unknownRetry }, correlationId);
+      logger.warn('invalid retryStrategy, ignoring', { strategyType: typeof retryStrategy, using: 'unknownRetry (always retry)' }, correlationId);
       retryStrategy = unknownRetry;
     }
     else retryStrategy = defaultRetry;
   }
-  if (logLevel) {
-    logLevel.response = validateLogLevel(logLevel, 'response');
-    logLevel.error = validateLogLevel(logLevel, 'error');
-    logLevel.request = validateLogLevel(logLevel, 'request');
-    logLevel.responseDetails = validateResponseDetails(logLevel.responseDetails, 'responseDetails', TYPE);
-    logLevel.responseName = validateResponseName(logLevel.responseName, 'responseName', RESPONSE);
+  if (logLevel && typeof logLevel === 'object' && !Array.isArray(logLevel)) {
+    const validated = {};
+    const response = validateLogLevel(logLevel, 'response');
+    const error = validateLogLevel(logLevel, 'error');
+    const request = validateLogLevel(logLevel, 'request');
+
+    if (response) validated.response = response;
+    if (error) validated.error = error;
+    if (request) validated.request = request;
+    validated.responseDetails = validateResponseDetails(logLevel.responseDetails, 'responseDetails', TYPE);
+    validated.responseName = validateResponseName(logLevel.responseName, 'responseName', RESPONSE);
+    logLevel = validated;
   }
   else {
     logLevel = {};
@@ -146,20 +149,20 @@ const calculateDelay = (options, nbRetry, criteria, err, correlationId) => {
 };
 
 const isRetry = (options, nbRetry, criteria, err, correlationId) => {
-  let iRetry;
+  let shouldRetry;
 
   try {
-    iRetry = criteria.retryStrategy(nbRetry, err, options, correlationId);
+    shouldRetry = criteria.retryStrategy(nbRetry, err, options, correlationId);
   }
   catch (error) {
     logger.warn('bad retry strategy', { error }, correlationId);
-    iRetry = true;
+    shouldRetry = true;
   }
-  if (typeof iRetry !== 'boolean') {
-    logger.warn('bad retry strategy', { error: `return of retryStrategy is a ${typeof iRetry}` }, correlationId);
-    iRetry = true;
+  if (typeof shouldRetry !== 'boolean') {
+    logger.warn('bad retry strategy', { error: `return of retryStrategy is a ${typeof shouldRetry}` }, correlationId);
+    shouldRetry = true;
   }
-  return iRetry;
+  return shouldRetry;
 };
 
 const setResponse = (response, details) => {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@mimik/request-retry",
-  "version": "4.0.9",
+  "version": "4.0.10",
   "description": "Request retry wrapping axios",
   "main": "./index.js",
   "type": "module",
   "scripts": {
-    "lint": "eslint . --no-error-on-unmatched-pattern",
     "docs": "jsdoc2md index.js > README.md",
+    "lint": "eslint . --no-error-on-unmatched-pattern",
     "test": "mocha --reporter mochawesome --bail --check-leaks --exit test/",
     "test-ci": "c8 --reporter=lcov --reporter=text npm test",
     "prepublishOnly": "npm run docs && npm run lint && npm run test-ci",
@@ -18,32 +18,36 @@
   ],
   "author": "mimik technology inc <support@mimik.com> (https://developer.mimik.com/)",
   "license": "MIT",
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "repository": {
     "type": "git",
     "url": "https://bitbucket.org/mimiktech/request-retry"
   },
   "dependencies": {
-    "@mimik/request-helper": "^2.0.5",
-    "@mimik/response-helper": "^4.0.10",
-    "@mimik/sumologic-winston-logger": "^2.1.12",
-    "axios": "1.13.5",
+    "@mimik/request-helper": "^2.0.6",
+    "@mimik/response-helper": "^4.0.11",
+    "@mimik/sumologic-winston-logger": "^2.2.1",
+    "axios": "1.13.6",
     "bluebird": "3.7.2"
   },
   "devDependencies": {
-    "@eslint/js": "9.39.2",
-    "@mimik/eslint-plugin-document-env": "^2.0.8",
-    "@stylistic/eslint-plugin": "5.9.0",
+    "@eslint/js": "9.39.4",
+    "@mimik/eslint-plugin-document-env": "^2.0.9",
+    "@mimik/eslint-plugin-logger": "1.0.3",
+    "@stylistic/eslint-plugin": "5.10.0",
     "body-parser": "2.2.2",
-    "c8": "10.1.3",
+    "c8": "11.0.0",
     "chai": "6.2.2",
-    "eslint": "9.39.2",
+    "eslint": "9.39.4",
     "eslint-plugin-import": "2.32.0",
     "express": "5.2.1",
-    "globals": "17.3.0",
+    "globals": "17.4.0",
     "husky": "9.1.7",
     "jsdoc-to-markdown": "9.1.3",
     "mocha": "11.7.5",
     "mochawesome": "7.1.4",
-    "sinon": "21.0.1"
+    "sinon": "21.0.2"
   }
 }

package/.husky/pre-commit

@@ -1,2 +0,0 @@
-#!/bin/sh
-npm run commit-ready

package/.husky/pre-push

@@ -1,2 +0,0 @@
-#!/bin/sh
-npm run test

package/eslint.config.js

@@ -1,70 +0,0 @@
-import globals from 'globals';
-import importPlugin from 'eslint-plugin-import';
-import js from '@eslint/js';
-import processDoc from '@mimik/eslint-plugin-document-env';
-import stylistic from '@stylistic/eslint-plugin';
-
-const MAX_LENGTH_LINE = 180;
-const MAX_FUNCTION_PARAMETERS = 6;
-const MAX_LINES_IN_FILES = 600;
-const MAX_LINES_IN_FUNCTION = 150;
-const MAX_STATEMENTS_IN_FUNCTION = 45;
-const MIN_KEYS_IN_OBJECT = 10;
-const MAX_COMPLEXITY = 30;
-const ECMA_VERSION = 'latest';
-const MAX_DEPTH = 6;
-const ALLOWED_CONSTANTS = [0, 1, -1];
-
-export default [
-  {
-    ignores: ['coverage/**', 'mochawesome-report/**', 'node_modules/**', 'dist/**'],
-  },
-  importPlugin.flatConfigs.recommended,
-  stylistic.configs.recommended,
-  js.configs.all,
-  {
-    plugins: {
-      processDoc,
-    },
-    languageOptions: {
-      ecmaVersion: ECMA_VERSION,
-      globals: {
-        ...globals.mocha,
-        ...globals.nodeBuiltin,
-      },
-      sourceType: 'module',
-    },
-    rules: {
-      '@stylistic/brace-style': ['warn', 'stroustrup', { allowSingleLine: true }],
-      '@stylistic/line-comment-position': ['off'],
-      '@stylistic/max-len': ['warn', MAX_LENGTH_LINE, { ignoreComments: true, ignoreStrings: true, ignoreRegExpLiterals: true }],
-      '@stylistic/quotes': ['warn', 'single'],
-      '@stylistic/semi': ['error', 'always'],
-      'capitalized-comments': ['off'],
-      'complexity': ['error', MAX_COMPLEXITY],
-      'curly': ['off'],
-      'id-length': ['error', { exceptions: ['x', 'y', 'z', 'i', 'j', 'k'] }],
-      'import/no-extraneous-dependencies': ['error', { devDependencies: true }],
-      'import/no-unresolved': ['error', { amd: true, caseSensitiveStrict: true, commonjs: true }],
-      'init-declarations': ['off'],
-      'linebreak-style': ['off'],
-      'max-depth': ['error', MAX_DEPTH],
-      'max-len': ['off'],
-      'max-lines': ['warn', { max: MAX_LINES_IN_FILES, skipComments: true, skipBlankLines: true }],
-      'max-lines-per-function': ['warn', { max: MAX_LINES_IN_FUNCTION, skipComments: true, skipBlankLines: true }],
-      'max-params': ['error', MAX_FUNCTION_PARAMETERS],
-      'max-statements': ['warn', MAX_STATEMENTS_IN_FUNCTION],
-      'no-confusing-arrow': ['off'],
-      'no-inline-comments': ['off'],
-      'no-magic-numbers': ['error', { ignore: ALLOWED_CONSTANTS, enforceConst: true, detectObjects: false }],
-      'no-process-env': ['error'],
-      'no-ternary': ['off'],
-      'no-undefined': ['off'],
-      'one-var': ['error', 'never'],
-      'processDoc/validate-document-env': ['error'],
-      'quotes': ['off'],
-      'sort-imports': ['error', { allowSeparatedGroups: true }],
-      'sort-keys': ['error', 'asc', { caseSensitive: true, minKeys: MIN_KEYS_IN_OBJECT, natural: false, allowLineSeparatedGroups: true }],
-    },
-  },
-];

package/manual-test/httpMock.js

@@ -1,19 +0,0 @@
-/* eslint-disable no-console */
-import { OK } from '../lib/common.js';
-import bodyParser from 'body-parser';
-import express from 'express';
-
-const PORT = 9000;
-
-const app = express();
-
-app.use(bodyParser.json());
-app.get('/success', (req, res) => {
-  res.statusCode = OK;
-
-  res.send({ statusCode: OK });
-});
-
-app.listen(PORT, () => {
-  console.log('----->', `retry mock at ${PORT}`);
-});

package/manual-test/man.js

@@ -1,26 +0,0 @@
-/* eslint-disable no-console */
-import './testEnv.js';
-import { rpRetry } from '../index.js';
-
-const DELAY = 1000;
-const RETRY_TIMEOUT = 10;
-const RETRY_RETRIES = 2;
-
-const correlationId = `--request-retry-test--/${new Date().toISOString()}`;
-
-const options = {
-  method: 'GET',
-  headers: {
-    'x-correlation-id': correlationId,
-  },
-  url: 'http://localhost:9080/test/retry',
-  json: true,
-  retry: {},
-};
-
-options.retry.delayStrategy = () => DELAY;
-options.retry.timeout = RETRY_TIMEOUT;
-options.retry.retries = RETRY_RETRIES;
-
-rpRetry(options)
-  .catch(err => console.log(err));

package/manual-test/retryMockMan.js

@@ -1,69 +0,0 @@
-/* eslint-disable no-console */
-import { CREATED, OK, SYSTEM_ERROR } from '../lib/common.js';
-import bodyParser from 'body-parser';
-import express from 'express';
-import { setTimeout } from 'node:timers';
-
-const PORT = 9080;
-const GET_NB_RETRY = 400;
-const GET_TIMEOUT = 4000;
-
-const app = express();
-
-const config = {
-  port: PORT,
-  path: '/retry',
-  base: '/test',
-  get: {
-    nbRetry: GET_NB_RETRY,
-    success: OK,
-    error: SYSTEM_ERROR,
-    timeout: GET_TIMEOUT,
-  },
-  post: {
-    success: CREATED,
-  },
-};
-let nbRequest = 0;
-let time = 0;
-let message;
-
-app.use(bodyParser.json());
-app.get(`${config.base}${config.path}`, (req, res) => {
-  if (nbRequest === 0) message = 'Received first request';
-  else {
-    const timeLapse = Date.now() - time;
-
-    message = `Received ${nbRequest} retry with timelapse ${timeLapse}`;
-  }
-  console.log('----->', message);
-  time = Date.now();
-
-  if (nbRequest === config.get.nbRetry) {
-    res.statusCode = config.get.success;
-    res.send({ statusCode: config.get.success });
-    return;
-  }
-  nbRequest += 1;
-  setTimeout(() => {
-    res.statusCode = config.get.error;
-    res.send({ statusCode: config.get.error });
-  }, config.get.timeout);
-});
-app.post(`${config.base}${config.path}`, (req, res) => {
-  console.log('----->', 'Received a POST request');
-  res.statusCode = config.post.success;
-  res.send({ statusCode: config.post.success });
-});
-
-app.post('/logs/:id', (req, res) => {
-  console.log('--->', 'Received a log');
-  console.log('---> id:', req.params.id);
-  console.log('---> body:', req.body);
-  res.statusCode = config.post.success;
-  res.send({ statusCode: config.post.success });
-});
-
-app.listen(config.port, () => {
-  console.log('----->', `retry mock at ${config.port}`);
-});

package/manual-test/testEnv.js

@@ -1,25 +0,0 @@
-/* eslint no-process-env: "off" */
-import process from 'node:process';
-
-/**
- * The following environment variables are set for the test:
- *
- * | Env variable name | Description | Default | Comments |
- * | ----------------- | ----------- | ------- | -------- |
- * | SUMO_LOGIC_ENDPOINT | endpoint to use to log on sumologic | null
- * | SUMO_LOGIC_COLLECTOR_CODE | code to use to log on sumologic | null
- * | NO_STACK | flag to have a stack associated with the log | yes
- * | LOG_LEVEL | log level to log | error
- * | CONSOLE_LEVEL | log level to display | debug
- * | LOG_MODE | log mode | none
- */
-/*
- *process.env.SUMO_LOGIC_ENDPOINT = 'http://localhost:9080/logs/';
- *process.env.SUMO_LOGIC_COLLECTOR_CODE = '1234';
- */
-process.env.SUMO_LOGIC_ENDPOINT = null;
-process.env.SUMO_LOGIC_COLLECTOR_CODE = null;
-process.env.NO_STACK = 'yes';
-process.env.LOG_LEVEL = 'debug';
-process.env.CONSOLE_LEVEL = 'debug';
-process.env.LOG_MODE = 'none';

package/manual-test/testRace.js

@@ -1,35 +0,0 @@
-/* eslint-disable no-console */
-import { clearTimeout, setTimeout } from 'node:timers';
-
-const MAX_INCR = 100000000;
-const MAIN_TIMEOUT = 1; // in millisecond
-
-const doSomething = () => {
-  let add = 0;
-
-  for (let i = 0; i < MAX_INCR; i += 1) {
-    add += 1;
-    console.log(add);
-  }
-  return add;
-};
-const timeout = MAIN_TIMEOUT;
-
-const race = () => {
-  let result;
-  const mainTimeout = setTimeout(() => {
-    throw new Error('timeout');
-  }, timeout);
-
-  try {
-    result = doSomething();
-  }
-  catch (err) {
-    console.log(err);
-    result = 0;
-  }
-  clearTimeout(mainTimeout);
-  return result;
-};
-
-console.log(race());

package/manual-test/testRetry.js

@@ -1,64 +0,0 @@
-/* eslint-disable no-console */
-import '../test/testEnv.js';
-import { rpRetry } from '../index.js';
-
-const TIMEOUT = 20000; // in millisecond
-
-const options = {
-  method: 'GET',
-  url: 'http://api.swaggerhub.com/apis/mimik/Boxes/1.2.1', // 'http://www.google.com', // 'http://blah.com', // 'http://localhost:9070/test/retry', // 'http://www.google.com', // 'http://localhost:8080/mIT/v1/admin/healthCheck1', // 'http://blah.com'
-  headers: {
-    'x-correlation-id': '---test-request-retry---',
-  },
-  json: true,
-  timeout: TIMEOUT,
-  /*
-   * retry: {
-   * all default: maxRetry: 2, retryDelay: 1000ms, maxTimeout: 50s, logLevel: 3 silly, type response, retryDelayStrategy: setDelay, retryStrategy: defaultRetry
-   * retries: -1,  // => 0
-   * retries: 20, // => 15
-   * retries: 'joe', // => 2
-   * retries: 0, // OK
-   * delay: 0, // => 20ms
-   * delay: 100000, // => 30000ms
-   * delay: 'joe', // => 1000ms
-   * delay: 1, // => 20ms
-   * delayStrategy: 'joe', // => setDelay returning retryDelay
-   * delayStrategy: function badDelay() { return 'joe' }, // => no change then bad delay strategy => retryDelay
-   * delayStrategy: function userDelay(...args) { return (Math.pow(2, args[0]) * 100) + Math.floor(Math.random() * 50) }, // OK
-   * retryStrategy: 'joe', // => unknownRetry returning false
-   * retryStrategy: function badRetry() { return 'joe' }, // => no change then bad retry strategy => false
-   * retryStrategy: function userRetry(...args) { // OK
-   *   const { statusCode } = args[1]; // err
-   *
-   *   return statusCode && (Math.floor(statusCode/100) !== 5 || statusCode !== 429); // retry if there is no statusCode or if there is 500 range statusCode or 429
-   * },
-   * retryStrategy: function invalidRetry(...args) { // defaultRetry
-   *   const { statusCode } = args[34]; // null value
-   *
-   *   return true // no retry
-   * },
-   * timeout: 0, // => 10s
-   * timeout: 150, // => 120s
-   * timeout: 'joe', // => 50s
-   * logLevel: {
-   *   response: 'test', // silly with warning
-   *   error: 1234, // => silly with warning
-   *   request: null, // => silly no warning
-   *   responseDetails: 'test', // => type with warning
-   *   responseName: '', // => response with warning
-   * },
-   * logLevel: {
-   *   response: 'info', // ok all the other value to default no warning
-   * },
-   * }
-   */
-};
-
-const sDate = Date.now();
-
-rpRetry(options)
-  .then(response => console.log('success', { response: typeof response }, Date.now() - sDate))
-  .catch((err) => {
-    console.log('failure', { error: err, info: err.info }, Date.now() - sDate);
-  });

package/test/retryMock.js

@@ -1,74 +0,0 @@
-/* eslint-disable no-console */
-import { CREATED, OK, SYSTEM_ERROR } from '../lib/common.js';
-import bodyParser from 'body-parser';
-import express from 'express';
-import process from 'node:process';
-import { setTimeout } from 'node:timers';
-
-const TIMEOUT = 3000;
-const EXIT_OK = 0;
-const PORT = 9070;
-const GET_NB_RETRY = 400;
-
-const app = express();
-const config = {
-  port: PORT,
-  path: '/retry',
-  base: '/test',
-  get: {
-    nbRetry: GET_NB_RETRY,
-    success: OK,
-    error: SYSTEM_ERROR,
-  },
-  post: {
-    success: CREATED,
-  },
-};
-let nbRequest = 0;
-let time = 0;
-let message;
-
-app.use(bodyParser.json());
-app.get(`${config.base}${config.path}`, (req, res) => {
-  if (nbRequest === 0) message = 'Received first request';
-  else {
-    const timeLapse = Date.now() - time;
-
-    message = `Received ${nbRequest} retry with timelapse ${timeLapse}`;
-  }
-  console.log('----->', message);
-  time = Date.now();
-
-  if (nbRequest === config.get.nbRetry) {
-    res.statusCode = config.get.success;
-    res.send({ statusCode: config.get.success });
-    return;
-  }
-  nbRequest += 1;
-  res.statusCode = config.get.error;
-
-  res.send({ statusCode: config.get.error });
-});
-app.post(`${config.base}${config.path}`, (req, res) => {
-  console.log('----->', 'Received a POST request');
-  res.statusCode = config.post.success;
-  res.send({ statusCode: config.post.success });
-});
-app.get('/stop', (req, res) => {
-  console.log('----->', 'Received a stop');
-  res.statusCode = config.get.success;
-  res.send({ statusCode: config.get.success });
-  setTimeout(() => {
-    process.exit(EXIT_OK);
-  }, TIMEOUT);
-});
-
-const listen = () => {
-  app.listen(config.port, () => {
-    console.log('----->', `retry mock at ${config.port}`);
-  });
-};
-
-export {
-  listen,
-};

package/test/rpRetry.spec.js

@@ -1,432 +0,0 @@
-/* eslint-disable max-lines-per-function */
-import './testEnv.js';
-import { afterEach, before, beforeEach, describe, it } from 'mocha';
-import { assert, spy } from 'sinon';
-import { expect } from 'chai';
-import { getCorrelationId } from '@mimik/request-helper';
-import { listen } from './retryMock.js';
-import logger from '@mimik/sumologic-winston-logger';
-import { rpRetry } from '../index.js';
-
-const TIMEOUT = 50000;
-const RETRY_DELAY = 10000;
-const OUT_OF_SCOPE_RETRY_DELAY = 100000;
-const IN_SCOPE_RETRY_DELAY = 20000;
-const RETRY_TIMEOUT = 10;
-const OUT_OF_SCOPE_RETRY_TIMEOUT = 150;
-const IN_SCOPE_RETRY_TIMEOUT = 50;
-const RETRY_RETRIES = 2;
-const OUT_OF_SCOPE_RETRIES = 20;
-const IN_SCOPE_RETRIES = 10;
-const DELAY_STRATEGY_RESPONSE_1 = -20;
-const DELAY_STRATEGY_RESPONSE_2 = 50;
-const DELAY_STRATEGY_RESPONSE_3 = 100;
-const CALL_ARG_MESSAGE = 0;
-const FIRST_CALL = 0;
-/*
- * const DEFAULT_NO_MESSAGE = 'no message';
- * const NO_ERROR = 'not an error object';
- */
-
-describe('request-retry Unit Tests', () => {
-  const correlationId = getCorrelationId('--request-retry-test--');
-  // let loggerSpyError;
-  let loggerSpyWarn;
-  let loggerSpyInfo;
-
-  before(() => {
-    listen();
-  });
-
-  describe('rpRetry(options) options validations prerun', () => {
-    const options = {
-      method: 'POST',
-      headers: {
-        'x-correlation-id': correlationId,
-      },
-      url: 'http://localhost:9070/test/retry',
-      json: true,
-      retry: {},
-    };
-    beforeEach(() => {
-      loggerSpyWarn = spy(logger, 'warn');
-    });
-    afterEach(() => {
-      options.retry = {};
-      loggerSpyWarn.restore();
-    });
-    it('should not generate warning: null retry, using default', () => {
-      options.retry = null;
-      return rpRetry(options).then(() => {
-        assert.notCalled(loggerSpyWarn);
-      });
-    });
-    it('should not generate warning: empty retry, using default', () => rpRetry(options).then(() => {
-      assert.notCalled(loggerSpyWarn);
-    }));
-    it('should generate warning: out of scope retries: -1 becoming min', () => {
-      options.retry.retries = -1;
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope retries, reset to min');
-      });
-    });
-    it('should generate warning: out of scope retries: 20 becoming max', () => {
-      options.retry.retries = OUT_OF_SCOPE_RETRIES;
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope retries, reset to max');
-      });
-    });
-    it('should not generate warning: in scope retries', () => {
-      options.retry.retries = IN_SCOPE_RETRIES;
-      return rpRetry(options).then(() => {
-        assert.notCalled(loggerSpyWarn);
-      });
-    });
-    it('should generate warning: invalid retries: "notANumber" becoming default', () => {
-      options.retry.retries = 'notANumber';
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid retries, reset to default');
-      });
-    });
-    it('should generate warning: out of scope delay: 0 becoming min', () => {
-      options.retry.delay = 0;
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope delay, reset to min');
-      });
-    });
-    it('should generate warning: out of scope delay: 100000 becoming max', () => {
-      options.retry.delay = OUT_OF_SCOPE_RETRY_DELAY;
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope delay, reset to max');
-      });
-    });
-    it('should generate warning: invalid delay: "notANumber" becoming default', () => {
-      options.retry.delay = 'notANumber';
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid delay, reset to default');
-      });
-    });
-    it('should not generate warning: in scope delay', () => {
-      options.retry.delay = IN_SCOPE_RETRY_DELAY;
-      return rpRetry(options).then(() => {
-        assert.notCalled(loggerSpyWarn);
-      });
-    });
-    it('should generate warning: out of scope timeout: 0 becoming min', () => {
-      options.retry.timeout = 0;
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope timeout, reset to min');
-      });
-    });
-    it('should generate warning: out of scope timeout: 150 becoming max', () => {
-      options.retry.timeout = OUT_OF_SCOPE_RETRY_TIMEOUT;
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('out of scope timeout, reset to max');
-      });
-    });
-    it('should generate warning: invalid timeout: "notANumber" becoming default', () => {
-      options.retry.timeout = 'notANumber';
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid timeout, reset to default');
-      });
-    });
-    it('should not generate warning: in scope timeout', () => {
-      options.retry.timeout = IN_SCOPE_RETRY_TIMEOUT;
-      return rpRetry(options).then(() => {
-        assert.notCalled(loggerSpyWarn);
-      });
-    });
-    it('should generate warning: invalid retryStrategy: "notAFunction" becoming default function', () => {
-      options.retry.retryStrategy = 'notAFunction';
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid retryStrategy, ignoring');
-      });
-    });
-    it('should generate warning: invalid delayStrategy: "notAFunction" becoming delay or default', () => {
-      options.retry.delayStrategy = 'notAFunction';
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid delayStrategy, using delay');
-      });
-    });
-    it('should generate multiple warnings', () => {
-      options.retry.delayStrategy = 'notAFunction';
-      options.retry.retries = 'notANumber';
-      return rpRetry(options).then(() => {
-        assert.calledTwice(loggerSpyWarn);
-      });
-    });
-    it('should generate warning: invalid logLevel.request, reset to default', () => {
-      options.retry.logLevel = {
-        request: 'unknownLevel',
-      };
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid logLevel.request, reset to default');
-      });
-    });
-    it('should not generate warning: correct logLevel (info)', () => {
-      loggerSpyInfo = spy(logger, 'info');
-      options.retry.logLevel = {
-        response: 'info',
-      };
-      return rpRetry(options).then(() => {
-        assert.notCalled(loggerSpyWarn);
-        assert.calledOnce(loggerSpyInfo);
-        loggerSpyInfo.restore();
-      });
-    });
-    it('should generate warning: invalid logLevel.responseDetails, reset to default', () => {
-      options.retry.logLevel = {
-        responseDetails: 'unknownDetails',
-      };
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid logLevel.responseDetails, reset to default');
-      });
-    });
-    it('should not generate warning: correct logLevelResponseName', () => {
-      options.retry.logLevel = {
-        responseName: 'aName',
-      };
-      return rpRetry(options).then(() => {
-        assert.notCalled(loggerSpyWarn);
-      });
-    });
-    it('should generate warning: invalid logLevel.responseName (""), reset to default', () => {
-      options.retry.logLevel = {
-        responseName: '',
-      };
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid logLevel.responseName, reset to default');
-      });
-    });
-    it('should generate warning: invalid logLevel.responseName (" "), reset to default', () => {
-      options.retry.logLevel = {
-        responseName: '    ',
-      };
-      return rpRetry(options).then(() => {
-        assert.calledOnce(loggerSpyWarn);
-        const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-        expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-        expect(callArgs[CALL_ARG_MESSAGE]).to.equal('invalid logLevel.responseName, reset to default');
-      });
-    });
-  });
-  describe('rpRetry(options) request mapping and response details', () => {
-    it('should succeed with body mapped to axios data', () => rpRetry({
-      method: 'POST',
-      headers: { 'x-correlation-id': correlationId },
-      url: 'http://localhost:9070/test/retry',
-      body: { test: 'data' },
-      retry: {},
-    }).then((response) => {
-      expect(response).to.have.property('statusCode');
-    }));
-    it('should succeed with json object mapped to axios data', () => rpRetry({
-      method: 'POST',
-      headers: { 'x-correlation-id': correlationId },
-      url: 'http://localhost:9070/test/retry',
-      json: { test: 'data' },
-      retry: {},
-    }).then((response) => {
-      expect(response).to.have.property('statusCode');
-    }));
-    it('should succeed with qs mapped to axios params', () => rpRetry({
-      method: 'POST',
-      headers: { 'x-correlation-id': correlationId },
-      url: 'http://localhost:9070/test/retry',
-      json: true,
-      qs: { key: 'value' },
-      retry: {},
-    }).then((response) => {
-      expect(response).to.have.property('statusCode');
-    }));
-    it('should throw a System error on network failure', () => rpRetry({
-      method: 'GET',
-      headers: { 'x-correlation-id': correlationId },
-      url: 'http://localhost:1/unreachable',
-      retry: { retries: 0, timeout: 10 },
-    }).catch((err) => {
-      expect(err.name).to.be.a('string');
-    }));
-    it('should log response with count details', () => {
-      const loggerSpySilly = spy(logger, 'silly');
-
-      return rpRetry({
-        method: 'POST',
-        headers: { 'x-correlation-id': correlationId },
-        url: 'http://localhost:9070/test/retry',
-        json: true,
-        retry: {
-          logLevel: {
-            response: 'silly',
-            responseDetails: 'count',
-          },
-        },
-      }).then(() => {
-        assert.calledOnce(loggerSpySilly);
-        loggerSpySilly.restore();
-      });
-    });
-  });
-  describe('rpRetry(options) options validation run', function Test() {
-    this.timeout(TIMEOUT);
-    const options = {
-      method: 'GET',
-      headers: {
-        'x-correlation-id': correlationId,
-      },
-      url: 'http://localhost:9070/test/retry',
-      json: true,
-      retry: {},
-    };
-    beforeEach(() => {
-      loggerSpyWarn = spy(logger, 'warn');
-    });
-    afterEach(() => {
-      options.retry = {};
-      loggerSpyWarn.restore();
-    });
-    it('should generate warning: bad retry strategy (throwing an error), ignoring and using default retries', () => {
-      options.retry.retryStrategy = () => {
-        throw new Error('this is a test');
-      };
-      options.retry.retries = RETRY_RETRIES;
-      return rpRetry(options)
-        .catch(() => {
-          assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('bad retry strategy');
-        });
-    });
-    it('should generate warning: bad retry strategy (not returning a boolean), ignoring and using default retries', () => {
-      options.retry.retryStrategy = () => 'notABoolean';
-      options.retry.retries = RETRY_RETRIES;
-      return rpRetry(options)
-        .catch(() => {
-          assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('bad retry strategy');
-        });
-    });
-    it('should not generate warning for retry strategy, but warn on request error', () => {
-      options.retry.retryStrategy = () => false;
-      options.retry.retries = RETRY_RETRIES;
-      return rpRetry(options)
-        .catch(() => {
-          assert.called(loggerSpyWarn);
-        });
-    });
-    it('should generate warning: bad delay strategy (throwing an error), ignoring and using default delay', () => {
-      options.retry.delayStrategy = () => {
-        throw new Error('this is a test');
-      };
-      options.retry.retries = RETRY_RETRIES;
-      return rpRetry(options)
-        .catch(() => {
-          assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('bad delay strategy');
-        });
-    });
-    it('should generate warning: bad delay strategy (not returning a number), ignoring and using default delay', () => {
-      options.retry.delayStrategy = () => 'notANumber';
-      options.retry.retries = RETRY_RETRIES;
-      return rpRetry(options)
-        .catch(() => {
-          assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('bad delay strategy');
-        });
-    });
-    it('should generate warning: bad delay strategy (returning an out of scope number), ignoring and using default delay', () => {
-      options.retry.delayStrategy = () => DELAY_STRATEGY_RESPONSE_1;
-      options.retry.retries = RETRY_RETRIES;
-      return rpRetry(options)
-        .catch(() => {
-          assert.called(loggerSpyWarn);
-          const callArgs = loggerSpyWarn.getCall(FIRST_CALL).args;
-          expect(callArgs[CALL_ARG_MESSAGE]).to.be.a('string');
-          expect(callArgs[CALL_ARG_MESSAGE]).to.equal('calculated delay out of scope: using delay or default');
-        });
-    });
-    it('should not generate warning for delay strategy, but warn on request error', () => {
-      options.retry.delayStrategy = () => DELAY_STRATEGY_RESPONSE_2;
-      options.retry.retries = RETRY_RETRIES;
-      return rpRetry(options)
-        .catch(() => {
-          assert.called(loggerSpyWarn);
-        });
-    });
-    it('should generate a timeout error', () => {
-      options.retry.delayStrategy = () => RETRY_DELAY;
-      options.retry.timeout = RETRY_TIMEOUT;
-      options.retry.retries = RETRY_RETRIES;
-      return rpRetry(options)
-        .catch((err) => {
-          expect(err.name).to.equal('System');
-          expect(err.cause.name).to.equal('TimeoutError');
-          // assert.called(loggerSpyWarn);
-        });
-    });
-    it('should stop mock server', () => rpRetry({
-      method: 'GET',
-      headers: {
-        'x-correlation-id': correlationId,
-      },
-      url: 'http://localhost:9070/stop',
-      retry: {
-        delayStrategy: () => DELAY_STRATEGY_RESPONSE_3,
-        retries: 1,
-      },
-    })
-      .catch((err) => {
-        expect(err.name).to.equal('System');
-        expect(err.cause.name).to.equal('TimeoutError');
-      }));
-  });
-});

package/test/testEnv.js

@@ -1,26 +0,0 @@
-/* eslint no-process-env: "off" */
-import process from 'node:process';
-
-/**
- * The following environment variables are set for the test:
- *
- * | Env variable name | Description | Default | Comments |
- * | ----------------- | ----------- | ------- | -------- |
- * | SUMO_LOGIC_ENDPOINT | endpoint to use to log on sumologic | null
- * | SUMO_LOGIC_COLLECTOR_CODE | code to use to log on sumologic | null
- * | NO_STACK | flag to have a stack associated with the log | yes
- * | LOG_LEVEL | log level to log | error
- * | CONSOLE_LEVEL | log level to display | debug
- * | LOG_MODE | log mode | none
- */
-
-/*
- * process.env.SUMO_LOGIC_ENDPOINT = 'http://localhost:9080/logs/';
- * process.env.SUMO_LOGIC_COLLECTOR_CODE = '1234';
- */
-process.env.SUMO_LOGIC_ENDPOINT = null;
-process.env.SUMO_LOGIC_COLLECTOR_CODE = null;
-process.env.NO_STACK = 'yes';
-process.env.LOG_LEVEL = 'debug';
-process.env.CONSOLE_LEVEL = 'debug';
-process.env.LOG_MODE = 'none';