@autofleet/network 1.6.1-beta-194901dc.0 → 1.7.0

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@autofleet/network",
-  "version": "1.6.1-beta-194901dc.0",
+  "version": "1.7.0",
   "description": "",
+  "type": "module",
   "main": "index.js",
   "scripts": {
-    "test": "node --test"
+    "test": "tsx index.test.js",
+    "build": "tsup"
+  },
+  "engines": {
+    "node": ">=18"
   },
   "author": "Dor Shay",
   "license": "ISC",
@@ -13,17 +18,20 @@
     "agentkeepalive": "^4.6.0",
     "axios": "^0.29.0",
     "axios-retry": "^4.5.0",
-    "deepmerge": "^3.0.0",
+    "deepmerge": "^4.3.1",
     "qs": "^6.14.0"
   },
   "peerDependencies": {
-    "@autofleet/logger": ">=4.0.0"
+    "@autofleet/logger": ">=4.2.0"
   },
   "devDependencies": {
-    "@autofleet/logger": "^4.1.0",
-    "@types/axios": "^0.9.36",
+    "@autofleet/logger": "^4.2.0",
     "@types/node": "^18.19.75",
+    "@types/qs": "^6.9.18",
     "dotenv": "^16.4.7",
-    "nock": "^14.0.1"
+    "nock": "^14.0.1",
+    "tsup": "^8.3.6",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
   }
 }

package/{index.js → src/index.ts}

@@ -1,25 +1,19 @@
-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 { HttpAgent, HttpsAgent } = require('agentkeepalive');
-
-/**
- * Add support for nock testing
- * 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;
+import { createRequire } from 'node:module';
+import axios, { type CreateAxiosDefaults, type AxiosRequestConfig, type AxiosInstance, type AxiosResponse } from 'axios';
+import axiosRetry from 'axios-retry';
+import Logger from '@autofleet/logger';
+import merge from 'deepmerge';
+import axiosCacheAdapter from '@autofleet/axios-cache-adapter';
+import { HttpAgent, HttpsAgent } from 'agentkeepalive';
+import type { stringify } from 'qs';
+
+const { setup } = axiosCacheAdapter;
+const safeRequire = createRequire(import.meta.url);
+
+let qsStringify: typeof stringify | undefined;
+const lazilyLoadQsStringify = (...args: Parameters<typeof stringify>) => {
+  qsStringify ??= safeRequire('qs').stringify;
+  return qsStringify(...args);
 }
 
 const HTTPMethods = [
@@ -30,32 +24,31 @@ const HTTPMethods = [
   'put',
   'patch',
   'options',
-];
+] as const;
+
+const qsStringifyOptions: NonNullable<Parameters<typeof stringify>[1]> = { arrayFormat: 'brackets' };
+
+interface NetworkSettings extends CreateAxiosDefaults {
+  serviceName?: string;
+  serviceUrl?: string;
+  keepAlive?: boolean;
+  logger?: import('@autofleet/logger').LoggerInstanceManager;
+}
 
-const defaultSettings = {
+const defaultSettings: NetworkSettings = {
   timeout: 10_000,
   headers: {
     'X-AF-AUTH': 'ANYONE',
     'X-IAF-ORIGIN-SERVICE': process.env.AF_SERVICE_NAME || null,
   },
-  paramsSerializer: params => lazilyLoadQsStringify(params, { arrayFormat: 'brackets' }),
+  paramsSerializer: params => lazilyLoadQsStringify(params, qsStringifyOptions),
   'axios-retry': {
     shouldResetTimeout: true,
   },
   keepAlive: true,
 };
 
-/** @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
- */
+const createRequestString = (request: AxiosRequestConfig): string => `[${(request.method || '').toUpperCase()}] ${request.baseURL ?? 'unknown-base-url'}${request.url ?? '/unknown-url'}`;
 
 /*
   The default free socket keepalive timeout, in milliseconds.
@@ -66,31 +59,21 @@ const createRequestString = (request) => `[${(request.method || '').toUpperCase(
   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 || 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 = {}) {
+const FREE_SOCKET_TIMEOUT = Number.parseInt(process.env.FREE_SOCKET_TIMEOUT, 10) || 5_000;
+
+export default class Network {
+  private readonly settings: NetworkSettings;
+  private readonly axios: AxiosInstance;
+
+  public get: AxiosInstance['get'];
+  public post: AxiosInstance['post'];
+  public delete: AxiosInstance['delete'];
+  public head: AxiosInstance['head'];
+  public put: AxiosInstance['put'];
+  public patch: AxiosInstance['patch'];
+  public options: AxiosInstance['options'];
+
+  constructor(settings: NetworkSettings = {}) {
     this.settings = merge(defaultSettings, settings);
     if (this.settings.keepAlive) {
       this.settings.httpAgent = new HttpAgent({ freeSocketTimeout: FREE_SOCKET_TIMEOUT });
@@ -114,8 +97,7 @@ module.exports = class Network {
     this.#addLogs();
   }
 
-  /** @param {NetworkSettings} settings */
-  #addRetry(settings) {
+  #addRetry(settings: NetworkSettings): void {
     axiosRetry(this.axios, {
       retries: 0,
       retryDelay: axiosRetry.exponentialDelay,
@@ -123,7 +105,7 @@ module.exports = class Network {
     });
   }
 
-  #addLogs() {
+  #addLogs(): void {
     const logger = this.settings.logger ?? Logger();
     this.axios.interceptors.request.use((request) => {
       logger.info(`Start Request: ${createRequestString(request)}`);
@@ -134,7 +116,6 @@ module.exports = class Network {
       logger.info(`Finish Request: ${createRequestString(response.config)}`);
       return response;
     }, (error) => {
-      debugger;
       if(error.request?._currentRequest?.reusedSocket && ['ECONNRESET', 'EPIPE'].includes(error.code)) {
         // See https://www.npmjs.com/package/agentkeepalive
         // Support req.reusedSocket
@@ -154,7 +135,7 @@ module.exports = class Network {
     });
   }
 
-  #createBaseUrl() {
+  #createBaseUrl(): void {
     if (!this.settings.serviceUrl && !this.settings.serviceName) {
       throw new Error('At least one of the settings Missing serviceUrl or serviceName');
     }
@@ -174,29 +155,25 @@ module.exports = class Network {
   /**
    * Build class methods that wrap axios methods
    */
-  #buildClassHttpMethods() {
+  #buildClassHttpMethods(): void {
     HTTPMethods.forEach((method) => {
-      this[method] = (...args) => this.axios[method](...args);
+      this[method] = async <T = any, R = AxiosResponse<T>>(...args: Parameters<AxiosInstance[typeof method]>): Promise<R> => this.axios[method](...args as [url: string, leaveUsAlone?: unknown]);
     });
   }
 
   /**
-   * @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.
+   * @param url The endpoint URL to send the request to.
+   * @param options Additional options to include in the request payload.
+   * @returns 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;
+  public async getAllPages<T>(url: string, options: object = {}): Promise<T[]> {
+    let currentResult: T[] = [];
+    let resultsInFirstPage: number | null = null;
+    let lastResultsSize: number | null = null;
 
     const localOptions = { params: { page: 1 }, ...options };
     while ((localOptions.params.page === 1 || lastResultsSize === resultsInFirstPage) && lastResultsSize !== 0) {
-      const { data } = await this.get(url, localOptions);
+      const { data } = await this.get<T[]>(url, localOptions);
       lastResultsSize = data.length;
       if (localOptions.params.page === 1) {
         resultsInFirstPage = data.length;
@@ -213,21 +190,18 @@ module.exports = class Network {
    * 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.
+   * @param url The endpoint URL to send the request to.
+   * @param options Additional options to include in the request payload.
+   * @param pageLimit The maximum number of pages to fetch. Set to -1 for no limit.
+   * @returns A promise that resolves to an array of all results.
    */
-  async getAllPagesFromQueryEndpoint(url, options = {}, pageLimit = 100) {
-    /** @type {T[]} */
-    let currentResult = [];
+  public async getAllPagesFromQueryEndpoint<T>(url: string, options: object = {}, pageLimit: number = 100): Promise<T[]> {
+    let currentResult: T[] = [];
 
     let moreResultsToLoad = true;
     let page = 1;
     while (moreResultsToLoad && (pageLimit === -1 || page < pageLimit)) {
-      const { data } = await this.post(url, {
+      const { data } = await this.post<{ rows: T[]; count: number; }>(url, {
         ...options,
         page,
       });

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "declaration": true,
+    "outDir": "./lib",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "experimentalDecorators": false,
+    "emitDecoratorMetadata": false,
+    "allowJs": true,
+    "isolatedModules": true,
+    "removeComments": true,
+  },
+  "include": ["src", "tsup.config.ts"],
+  "exclude": ["node_modules"]
+}

package/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig((options) => ({
+  entry: ['src/index.ts'],
+  target: 'node18.0',
+  dts: true,
+  outDir: 'lib',
+  format: ['esm', 'cjs'],
+  clean: !options.watch,
+  minify: !options.watch,
+  removeNodeProtocol: false,
+  treeshake: true,
+  sourcemap: true,
+}));