@autofleet/network 1.5.2-beta-1 → 1.6.0

package/index.js

@@ -1,22 +1,27 @@
-const axios = require('axios');
-const axiosRetry = require('axios-retry');
-const Logger = require('@autofleet/logger');
-const qs = require('qs');
-const httpAdapter = require('axios/lib/adapters/http');
+const { default: axios } = require('axios');
+const { default: axiosRetry } = require('axios-retry');
+const { default: Logger } = require('@autofleet/logger');
 const merge = require('deepmerge');
 const { setup } = require('@autofleet/axios-cache-adapter');
-const Agent = require('agentkeepalive');
-const HttpsAgent = require('agentkeepalive').HttpsAgent;
+const { HttpAgent, HttpsAgent } = require('agentkeepalive');
 
-require('dotenv').config();
 /**
  * Add support for nock testing
- * see s://github.com/axios/axios/issues/305
+ * see https://github.com/axios/axios/issues/305
  */
 if (process.env.NODE_ENV === 'test') {
+  require('dotenv').config();
+  const httpAdapter = require('axios/lib/adapters/http');
   axios.defaults.adapter = httpAdapter;
 }
 
+/** @type {import('qs').stringify | undefined} */
+let qsStringify;
+const lazilyLoadQsStringify = () => {
+  qsStringify ??= require('qs').stringify;
+  return qsStringify;
+}
+
 const HTTPMethods = [
   'get',
   'post',
@@ -27,20 +32,33 @@ const HTTPMethods = [
   'options',
 ];
 
+/** @type {NonNullable<Parameters<import('qs').stringify>[1]>} */
+const qsStringifyOptions = { arrayFormat: 'brackets' };
+
 const defaultSettings = {
-  timeout: 10000,
+  timeout: 10_000,
   headers: {
     'X-AF-AUTH': 'ANYONE',
     'X-IAF-ORIGIN-SERVICE': process.env.AF_SERVICE_NAME || null,
   },
-  paramsSerializer: params => qs.stringify(params, { arrayFormat: 'brackets' }),
+  paramsSerializer: params => lazilyLoadQsStringify(params, qsStringifyOptions),
   'axios-retry': {
     shouldResetTimeout: true,
   },
   keepAlive: true,
 };
 
-const createRequestString = (request) => `[${(request.method || '').toUpperCase()}] ${request.baseURL}${request.url}`;
+/** @param {import('axios').AxiosRequestConfig} request @returns {string} */
+const createRequestString = (request) => `[${(request.method || '').toUpperCase()}] ${request.baseURL ?? 'unknown-base-url'}${request.url ?? '/unknown-url'}`;
+
+/**
+ * @typedef {object} NetworkSettingsBase
+ * @property {string} [serviceName]
+ * @property {string} [serviceUrl]
+ * @property {boolean} [keepAlive]
+ * @property {import('@autofleet/logger').LoggerInstanceManager} [logger]
+ * @typedef {import('axios').CreateAxiosDefaults & NetworkSettingsBase} NetworkSettings
+ */
 
 /*
   The default free socket keepalive timeout, in milliseconds.
@@ -48,45 +66,59 @@ const createRequestString = (request) => `[${(request.method || '').toUpperCase(
   and we want to make sure we don't have any socket issues.
   See https://www.npmjs.com/package/agentkeepalive
 
-  There is also autoscaling reason for that, if we dont timeout at some point,
+  There is also autoscaling reason for that, if we don't timeout at some point,
   new pods that were auto scaled will not be used.
 */
-const FREE_SOCKET_TIMEOUT = process.env.FREE_SOCKET_TIMEOUT || 5000;
+const FREE_SOCKET_TIMEOUT = process.env.FREE_SOCKET_TIMEOUT || 5_000;
 
 module.exports = class Network {
+  /** @private @readonly @type {NetworkSettings} */
+  settings;
+  /** @private @readonly @type {import('axios').AxiosInstance} */
+  axios;
+
+  /** @type {import('axios').AxiosInstance['get']} */
+  get;
+  /** @type {import('axios').AxiosInstance['post']} */
+  post;
+  /** @type {import('axios').AxiosInstance['delete']} */
+  delete;
+  /** @type {import('axios').AxiosInstance['head']} */
+  head;
+  /** @type {import('axios').AxiosInstance['put']} */
+  put;
+  /** @type {import('axios').AxiosInstance['patch']} */
+  patch;
+  /** @type {import('axios').AxiosInstance['options']} */
+  options;
+
+  /** @param {NetworkSettings} [settings]  */
   constructor(settings = {}) {
     this.settings = merge(defaultSettings, settings);
     if (this.settings.keepAlive) {
-      const keepaliveAgent = new Agent({
-        freeSocketTimeout: FREE_SOCKET_TIMEOUT,
-      });
-      const keepaliveHttpsAgent = new HttpsAgent({
-        freeSocketTimeout: FREE_SOCKET_TIMEOUT,
-      });
-      this.settings.httpAgent = keepaliveAgent;
-      this.settings.httpsAgent = keepaliveHttpsAgent;
+      this.settings.httpAgent = new HttpAgent({ freeSocketTimeout: FREE_SOCKET_TIMEOUT });
+      this.settings.httpsAgent = new HttpsAgent({ freeSocketTimeout: FREE_SOCKET_TIMEOUT });
       delete this.settings.keepAlive;
     }
-    this.createBaseUrl();
+    this.#createBaseUrl();
 
     if(settings.cache) {
       this.settings.cache = {
         maxAge: 15 * 60 * 1000,
-        exclude: {
-          // Store responses from requests with query parameters in cache
-          query: false
-        },
+        // Store responses from requests with query parameters in cache
+        exclude: { query: false },
         ...settings.cache,
       }
     }
 
     this.axios = settings.cache ? setup(this.settings) : axios.create(this.settings);
-    this.addRetry(settings);
-    this.buildClassHttpMethods();
-    this.addLogs();
+    this.#addRetry(settings);
+    this.#buildClassHttpMethods();
+    this.#addLogs();
   }
 
-  addRetry(settings) {
+  /** @param {NetworkSettings} settings */
+  #addRetry(settings) {
     axiosRetry(this.axios, {
       retries: 0,
       retryDelay: axiosRetry.exponentialDelay,
@@ -94,8 +126,8 @@ module.exports = class Network {
     });
   }
 
-  addLogs() {
-    const logger = Logger();
+  #addLogs() {
+    const logger = this.settings.logger ?? Logger();
     this.axios.interceptors.request.use((request) => {
       logger.info(`Start Request: ${createRequestString(request)}`);
       return request;
@@ -105,10 +137,7 @@ module.exports = class Network {
       logger.info(`Finish Request: ${createRequestString(response.config)}`);
       return response;
     }, (error) => {
-      if(error.request && error.request._currentRequest &&
-          error.request._currentRequest.reusedSocket &&
-          ['ECONNRESET', 'EPIPE'].includes(error.code)
-        ) {
+      if(error.request?._currentRequest?.reusedSocket && ['ECONNRESET', 'EPIPE'].includes(error.code)) {
         // See https://www.npmjs.com/package/agentkeepalive
         // Support req.reusedSocket
         // https://code-examples.net/en/q/28a8069
@@ -118,16 +147,16 @@ module.exports = class Network {
         })
         return this.axios.request(error.config);
       }
-      const request = error.request;
+      const request = error.config?.baseURL ? error.config : error.request;
       logger.error(`Finish Request with error ${request ? createRequestString(request) : ''}`, {
         status: error.status,
-        data: error.response && error.response.data
+        data: error.response?.data,
       });
       throw error;
     });
   }
 
-  createBaseUrl() {
+  #createBaseUrl() {
     if (!this.settings.serviceUrl && !this.settings.serviceName) {
       throw new Error('At least one of the settings Missing serviceUrl or serviceName');
     }
@@ -147,46 +176,66 @@ module.exports = class Network {
   /**
    * Build class methods that wrap axios methods
    */
-  buildClassHttpMethods() {
+  #buildClassHttpMethods() {
     HTTPMethods.forEach((method) => {
       this[method] = (...args) => this.axios[method](...args);
     });
   }
 
+  /**
+   * @template T
+   * @param {string} url - The endpoint URL to send the request to.
+   * @param {object} [options={}] - Additional options to include in the request payload.
+   * @returns {Promise<T[]>} - A promise that resolves to an array of all results.
+   */
   async getAllPages(url, options = {}) {
+    /** @type {T[]} */
     let currentResult = [];
+    /** @type {number | null} */
     let resultsInFirstPage = null;
+    /** @type {number | null} */
     let lastResultsSize = null;
 
-    const localOptions = { params: {}, ...options };
-    localOptions.params.page = 1;
-    while((localOptions.params.page === 1 || lastResultsSize === resultsInFirstPage) && lastResultsSize !== 0) {
+    const localOptions = { params: { page: 1 }, ...options };
+    while ((localOptions.params.page === 1 || lastResultsSize === resultsInFirstPage) && lastResultsSize !== 0) {
       const { data } = await this.get(url, localOptions);
       lastResultsSize = data.length;
-      if(localOptions.params.page === 1) {
+      if (localOptions.params.page === 1) {
         resultsInFirstPage = data.length;
       }
 
       localOptions.params.page += 1;
-      currentResult = currentResult.concat(data);
+      Array.prototype.push.apply(currentResult, data);
     }
 
     return currentResult;
   }
 
-  async getAllPagesFromQueryEndpoint(url, options = {}) {
+  /**
+   * Fetches all pages from a paginated API endpoint until all results are retrieved 
+   * or an optional page limit is reached.
+   *
+   * @template T
+   * @param {string} url - The endpoint URL to send the request to.
+   * @param {object} [options={}] - Additional options to include in the request payload.
+   * @param {number} [pageLimit=100] - The maximum number of pages to fetch.
+   *                                    Set to -1 for no limit.
+   * @returns {Promise<T[]>} - A promise that resolves to an array of all results.
+   */
+  async getAllPagesFromQueryEndpoint(url, options = {}, pageLimit = 100) {
+    /** @type {T[]} */
     let currentResult = [];
 
     let moreResultsToLoad = true;
     let page = 1;
-    while(moreResultsToLoad && page < 100) {
+    while (moreResultsToLoad && (pageLimit === -1 || page < pageLimit)) {
       const { data } = await this.post(url, {
         ...options,
-        page: page,
+        page,
       });
       const { rows, count } = data;
       page += 1;
-      currentResult = currentResult.concat(rows);
+      Array.prototype.push.apply(currentResult, rows);
       moreResultsToLoad = currentResult.length < count;
     }
 

package/package.json

@@ -1,27 +1,29 @@
 {
   "name": "@autofleet/network",
-  "version": "1.5.2-beta-1",
+  "version": "1.6.0",
   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "jest --forceExit --runInBand",
-    "test-auto": "jest --watch --runInBand",
-    "linter": "./node_modules/.bin/eslint ."
+    "test": "node --test"
   },
   "author": "Dor Shay",
   "license": "ISC",
   "dependencies": {
     "@autofleet/axios-cache-adapter": "^2.7.3-hotfix-1",
-    "@autofleet/logger": "^4.0.0-beta-2",
-    "agentkeepalive": "^4.3.0",
-    "axios": "^0.26.1",
-    "axios-retry": "^3.2.4",
+    "agentkeepalive": "^4.6.0",
+    "axios": "^0.29.0",
+    "axios-retry": "^4.5.0",
     "deepmerge": "^3.0.0",
-    "dotenv": "^6.0.0",
-    "qs": "^6.5.2"
+    "qs": "^6.14.0"
+  },
+  "peerDependencies": {
+    "@autofleet/logger": ">=4.0.0"
   },
   "devDependencies": {
-    "jest": "^27.0.6",
-    "nock": "^10.0.0"
+    "@autofleet/logger": "^4.1.0",
+    "@types/axios": "^0.9.36",
+    "@types/node": "^18.19.75",
+    "dotenv": "^16.4.7",
+    "nock": "^14.0.1"
   }
 }