@vtex/api 6.48.1-beta → 6.48.1-beta.2

package/lib/HttpClient/middlewares/request/index.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestMiddleware = exports.routerCacheMiddleware = exports.defaultsMiddleware = void 0;
+const buildFullPath_1 = __importDefault(require("axios/lib/core/buildFullPath"));
+const qs_1 = require("qs");
+const ramda_1 = require("ramda");
+const Tags_1 = require("../../../tracing/Tags");
+const renameBy_1 = require("../../../utils/renameBy");
+const setupAxios_1 = require("./setupAxios");
+const http = (0, setupAxios_1.getConfiguredAxios)();
+const paramsSerializer = (params) => {
+    return (0, qs_1.stringify)(params, { arrayFormat: 'repeat' });
+};
+const defaultsMiddleware = ({ baseURL, rawHeaders, params, timeout, retries, verbose, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent }) => {
+    const countByMetric = {};
+    const headers = (0, renameBy_1.renameBy)(ramda_1.toLower, rawHeaders);
+    return (ctx, next) => {
+        var _a, _b, _c;
+        ctx.config = {
+            baseURL,
+            exponentialBackoffCoefficient,
+            exponentialTimeoutCoefficient,
+            httpsAgent: ctx.config.httpsAgent || httpsAgent,
+            initialBackoffDelay,
+            maxRedirects: 0,
+            retries,
+            timeout,
+            validateStatus: status => (status >= 200 && status < 300),
+            verbose,
+            ...ctx.config,
+            headers: {
+                ...headers,
+                ...(0, renameBy_1.renameBy)(ramda_1.toLower, ctx.config.headers),
+            },
+            params: {
+                ...params,
+                ...ctx.config.params,
+            },
+            paramsSerializer,
+            retryCount: 0,
+        };
+        if (ctx.config.verbose && ctx.config.metric) {
+            const current = countByMetric[ctx.config.metric];
+            countByMetric[ctx.config.metric] = (current || 0) + 1;
+            ctx.config.count = countByMetric[ctx.config.metric];
+            ctx.config.label = `${ctx.config.metric}#${ctx.config.count}`;
+        }
+        if ((_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.isSampled) {
+            const { config } = ctx;
+            const fullUrl = (0, buildFullPath_1.default)(config.baseURL, http.getUri(config));
+            (_c = (_b = ctx.tracing) === null || _b === void 0 ? void 0 : _b.rootSpan) === null || _c === void 0 ? void 0 : _c.addTags({
+                [Tags_1.OpentracingTags.HTTP_METHOD]: config.method || 'get',
+                [Tags_1.OpentracingTags.HTTP_URL]: fullUrl,
+            });
+        }
+        return next();
+    };
+};
+exports.defaultsMiddleware = defaultsMiddleware;
+const ROUTER_CACHE_KEY = 'x-router-cache';
+const ROUTER_CACHE_HIT = 'HIT';
+const ROUTER_CACHE_REVALIDATED = 'REVALIDATED';
+const routerCacheMiddleware = async (ctx, next) => {
+    var _a, _b, _c, _d, _e;
+    await next();
+    const routerCacheHit = (_b = (_a = ctx.response) === null || _a === void 0 ? void 0 : _a.headers) === null || _b === void 0 ? void 0 : _b[ROUTER_CACHE_KEY];
+    const status = (_c = ctx.response) === null || _c === void 0 ? void 0 : _c.status;
+    if (routerCacheHit) {
+        (_e = (_d = ctx.tracing) === null || _d === void 0 ? void 0 : _d.rootSpan) === null || _e === void 0 ? void 0 : _e.setTag("http.cache.router" /* CustomHttpTags.HTTP_ROUTER_CACHE_RESULT */, routerCacheHit);
+    }
+    if (routerCacheHit === ROUTER_CACHE_HIT || (routerCacheHit === ROUTER_CACHE_REVALIDATED && status !== 304)) {
+        ctx.cacheHit = {
+            memory: 0,
+            revalidated: 0,
+            ...ctx.cacheHit,
+            router: 1,
+        };
+    }
+};
+exports.routerCacheMiddleware = routerCacheMiddleware;
+const requestMiddleware = (limit) => async (ctx, next) => {
+    const makeRequest = () => http.request(ctx.config);
+    ctx.response = await (limit ? limit(makeRequest) : makeRequest());
+};
+exports.requestMiddleware = requestMiddleware;

package/lib/HttpClient/middlewares/request/setupAxios/index.d.ts

@@ -0,0 +1 @@
+export declare const getConfiguredAxios: () => import("axios").AxiosInstance;

package/lib/HttpClient/middlewares/request/setupAxios/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfiguredAxios = void 0;
+const axios_1 = __importDefault(require("axios"));
+const HttpAgentSingleton_1 = require("../HttpAgentSingleton");
+const interceptors_1 = require("./interceptors");
+const getConfiguredAxios = () => {
+    const httpAgent = HttpAgentSingleton_1.HttpAgentSingleton.getHttpAgent();
+    const http = axios_1.default.create({
+        httpAgent,
+    });
+    (0, interceptors_1.addTracingPreRequestInterceptor)(http);
+    // Do not change this order, otherwise each request span will
+    // wait all retries to finish before finishing the span 
+    (0, interceptors_1.addTracingResponseInterceptor)(http);
+    (0, interceptors_1.addExponentialBackoffResponseInterceptor)(http);
+    return http;
+};
+exports.getConfiguredAxios = getConfiguredAxios;

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/exponentialBackoff.d.ts

@@ -0,0 +1,2 @@
+import { AxiosInstance } from 'axios';
+export declare const addExponentialBackoffResponseInterceptor: (http: AxiosInstance) => void;

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/exponentialBackoff.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addExponentialBackoffResponseInterceptor = void 0;
+const retry_1 = require("../../../../../utils/retry");
+function fixConfig(axiosInstance, config) {
+    if (axiosInstance.defaults.httpAgent === config.httpAgent) {
+        delete config.httpAgent;
+    }
+    if (axiosInstance.defaults.httpsAgent === config.httpsAgent) {
+        delete config.httpsAgent;
+    }
+}
+const exponentialDelay = (initialBackoffDelay, exponentialBackoffCoefficient, retryNumber) => {
+    const delay = initialBackoffDelay *
+        Math.pow(exponentialBackoffCoefficient, retryNumber - 1);
+    const randomSum = delay * 0.2 * Math.random();
+    return delay + randomSum;
+};
+// A lot of this code is based on:
+// https://github.com/softonic/axios-retry/blob/ffd4327f31d063522e58c525d28d4c5053d0ea7b/es/index.js#L109
+const onResponseError = (http) => (error) => {
+    var _a, _b, _c, _d;
+    if (error.config == null) {
+        return Promise.reject(error);
+    }
+    const config = error.config;
+    if (config.retries == null || config.retries === 0) {
+        return Promise.reject(error);
+    }
+    const { initialBackoffDelay = 200, exponentialBackoffCoefficient = 2, exponentialTimeoutCoefficient, } = config;
+    const retryCount = config.retryCount || 0;
+    const shouldRetry = (0, retry_1.isAbortedOrNetworkErrorOrRouterTimeout)(error) && retryCount < config.retries;
+    if (shouldRetry) {
+        config.retryCount = retryCount + 1;
+        const delay = exponentialDelay(initialBackoffDelay, exponentialBackoffCoefficient, config.retryCount);
+        // Axios fails merging this configuration to the default configuration because it has an issue
+        // with circular structures: https://github.com/mzabriskie/axios/issues/370
+        fixConfig(http, config);
+        config.timeout = exponentialTimeoutCoefficient
+            ? config.timeout * exponentialTimeoutCoefficient
+            : config.timeout;
+        config.transformRequest = [data => data];
+        (_b = (_a = config.tracing) === null || _a === void 0 ? void 0 : _a.rootSpan) === null || _b === void 0 ? void 0 : _b.log({ event: "setup-request-retry" /* HttpLogEvents.SETUP_REQUEST_RETRY */, ["retry-number" /* HttpRetryLogFields.RETRY_NUMBER */]: config.retryCount, ["retry-in" /* HttpRetryLogFields.RETRY_IN */]: delay });
+        (_d = (_c = config.tracing) === null || _c === void 0 ? void 0 : _c.rootSpan) === null || _d === void 0 ? void 0 : _d.addTags({
+            ["http.retry.count" /* CustomHttpTags.HTTP_RETRY_COUNT */]: config.retryCount,
+            ["http.retry.error.code" /* CustomHttpTags.HTTP_RETRY_ERROR_CODE */]: error.code,
+        });
+        return new Promise(resolve => setTimeout(() => resolve(http(config)), delay));
+    }
+    return Promise.reject(error);
+};
+const addExponentialBackoffResponseInterceptor = (http) => {
+    http.interceptors.response.use(undefined, onResponseError(http));
+};
+exports.addExponentialBackoffResponseInterceptor = addExponentialBackoffResponseInterceptor;

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/index.d.ts

@@ -0,0 +1,2 @@
+export { addExponentialBackoffResponseInterceptor } from './exponentialBackoff';
+export { addTracingPreRequestInterceptor, addTracingResponseInterceptor } from './tracing';

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTracingResponseInterceptor = exports.addTracingPreRequestInterceptor = exports.addExponentialBackoffResponseInterceptor = void 0;
+var exponentialBackoff_1 = require("./exponentialBackoff");
+Object.defineProperty(exports, "addExponentialBackoffResponseInterceptor", { enumerable: true, get: function () { return exponentialBackoff_1.addExponentialBackoffResponseInterceptor; } });
+var tracing_1 = require("./tracing");
+Object.defineProperty(exports, "addTracingPreRequestInterceptor", { enumerable: true, get: function () { return tracing_1.addTracingPreRequestInterceptor; } });
+Object.defineProperty(exports, "addTracingResponseInterceptor", { enumerable: true, get: function () { return tracing_1.addTracingResponseInterceptor; } });

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/index.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from 'axios';
+export declare const requestSpanPrefix = "http-request";
+export declare const addTracingPreRequestInterceptor: (http: AxiosInstance) => {
+    requestTracingInterceptor: number;
+};
+export declare const addTracingResponseInterceptor: (http: AxiosInstance) => {
+    responseTracingInterceptor: number;
+};

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTracingResponseInterceptor = exports.addTracingPreRequestInterceptor = exports.requestSpanPrefix = void 0;
+const opentracing_1 = require("opentracing");
+const tracing_1 = require("../../../../../../tracing");
+const SpanReferenceTypes_1 = require("../../../../../../tracing/spanReference/SpanReferenceTypes");
+const spanSetup_1 = require("./spanSetup");
+exports.requestSpanPrefix = 'http-request';
+const preRequestInterceptor = (http) => (config) => {
+    var _a;
+    if (!config.tracing || !((_a = config.tracing) === null || _a === void 0 ? void 0 : _a.isSampled)) {
+        return config;
+    }
+    const { tracer, rootSpan, requestSpanNameSuffix } = config.tracing;
+    const spanName = requestSpanNameSuffix ? `${exports.requestSpanPrefix}:${requestSpanNameSuffix}` : exports.requestSpanPrefix;
+    const span = rootSpan
+        ? tracer.startSpan(spanName, {
+            references: [(0, tracing_1.createSpanReference)(rootSpan, SpanReferenceTypes_1.SpanReferenceTypes.CHILD_OF)],
+        })
+        : tracer.startSpan(spanName);
+    (0, spanSetup_1.injectRequestInfoOnSpan)(span, http, config);
+    config.tracing.requestSpan = span;
+    tracer.inject(span, opentracing_1.FORMAT_HTTP_HEADERS, config.headers);
+    return config;
+};
+const onResponseSuccess = (response) => {
+    var _a, _b;
+    if (!response.config.tracing || !((_a = response.config.tracing) === null || _a === void 0 ? void 0 : _a.isSampled)) {
+        return response;
+    }
+    const requestSpan = (_b = response.config.tracing) === null || _b === void 0 ? void 0 : _b.requestSpan;
+    (0, spanSetup_1.injectResponseInfoOnSpan)(requestSpan, response);
+    requestSpan === null || requestSpan === void 0 ? void 0 : requestSpan.finish();
+    return response;
+};
+const onResponseError = (err) => {
+    var _a, _b, _c;
+    if (!((_b = (_a = err === null || err === void 0 ? void 0 : err.config) === null || _a === void 0 ? void 0 : _a.tracing) === null || _b === void 0 ? void 0 : _b.requestSpan) || !((_c = err.config.tracing) === null || _c === void 0 ? void 0 : _c.isSampled)) {
+        return Promise.reject(err);
+    }
+    const { requestSpan } = err.config.tracing;
+    (0, spanSetup_1.injectResponseInfoOnSpan)(requestSpan, err.response);
+    tracing_1.ErrorReport.create({ originalError: err }).injectOnSpan(requestSpan, err.config.tracing.logger);
+    requestSpan.finish();
+    return Promise.reject(err);
+};
+const addTracingPreRequestInterceptor = (http) => {
+    const requestTracingInterceptor = http.interceptors.request.use(preRequestInterceptor(http), undefined);
+    return { requestTracingInterceptor };
+};
+exports.addTracingPreRequestInterceptor = addTracingPreRequestInterceptor;
+const addTracingResponseInterceptor = (http) => {
+    const responseTracingInterceptor = http.interceptors.response.use(onResponseSuccess, onResponseError);
+    return { responseTracingInterceptor };
+};
+exports.addTracingResponseInterceptor = addTracingResponseInterceptor;

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/spanSetup.d.ts

@@ -0,0 +1,4 @@
+import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { Span } from 'opentracing';
+export declare const injectRequestInfoOnSpan: (span: Span | undefined, http: AxiosInstance, config: AxiosRequestConfig) => void;
+export declare const injectResponseInfoOnSpan: (span: Span | undefined, response: AxiosResponse<any> | undefined) => void;

package/lib/HttpClient/middlewares/request/setupAxios/interceptors/tracing/spanSetup.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectResponseInfoOnSpan = exports.injectRequestInfoOnSpan = void 0;
+const buildFullPath_1 = __importDefault(require("axios/lib/core/buildFullPath"));
+const constants_1 = require("../../../../../../constants");
+const Tags_1 = require("../../../../../../tracing/Tags");
+const utils_1 = require("../../../../../../tracing/utils");
+const injectRequestInfoOnSpan = (span, http, config) => {
+    span === null || span === void 0 ? void 0 : span.addTags({
+        [Tags_1.OpentracingTags.SPAN_KIND]: Tags_1.OpentracingTags.SPAN_KIND_RPC_CLIENT,
+        [Tags_1.OpentracingTags.HTTP_METHOD]: config.method,
+        [Tags_1.OpentracingTags.HTTP_URL]: (0, buildFullPath_1.default)(config.baseURL, http.getUri(config)),
+    });
+    span === null || span === void 0 ? void 0 : span.log({ 'request-headers': (0, utils_1.cloneAndSanitizeHeaders)(config.headers) });
+};
+exports.injectRequestInfoOnSpan = injectRequestInfoOnSpan;
+// Response may be undefined in case of client timeout, invalid URL, ...
+const injectResponseInfoOnSpan = (span, response) => {
+    if (!response) {
+        span === null || span === void 0 ? void 0 : span.setTag("http.no_response" /* CustomHttpTags.HTTP_NO_RESPONSE */, 'true');
+        return;
+    }
+    span === null || span === void 0 ? void 0 : span.log({ 'response-headers': (0, utils_1.cloneAndSanitizeHeaders)(response.headers) });
+    span === null || span === void 0 ? void 0 : span.setTag(Tags_1.OpentracingTags.HTTP_STATUS_CODE, response.status);
+    if (response.headers[constants_1.ROUTER_CACHE_HEADER]) {
+        span === null || span === void 0 ? void 0 : span.setTag("http.cache.router" /* CustomHttpTags.HTTP_ROUTER_CACHE_RESULT */, response.headers[constants_1.ROUTER_CACHE_HEADER]);
+    }
+};
+exports.injectResponseInfoOnSpan = injectResponseInfoOnSpan;

package/lib/HttpClient/middlewares/tracing.d.ts

@@ -0,0 +1,15 @@
+import { MiddlewaresTracingContext, RequestConfig } from '..';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { MiddlewareContext } from '../typings';
+interface HttpClientTracingMiddlewareConfig {
+    clientName: string;
+    tracer: IOContext['tracer'];
+    logger: IOContext['logger'];
+    hasMemoryCacheMiddleware: boolean;
+    hasDiskCacheMiddleware: boolean;
+}
+export interface TraceableRequestConfig extends RequestConfig {
+    tracing: MiddlewaresTracingContext;
+}
+export declare const createHttpClientTracingMiddleware: ({ tracer, logger, clientName, hasMemoryCacheMiddleware, hasDiskCacheMiddleware, }: HttpClientTracingMiddlewareConfig) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export {};

package/lib/HttpClient/middlewares/tracing.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpClientTracingMiddleware = void 0;
+const axios_1 = require("axios");
+const tracing_1 = require("../../tracing");
+const Tags_1 = require("../../tracing/Tags");
+const cache_1 = require("./cache");
+const createHttpClientTracingMiddleware = ({ tracer, logger, clientName, hasMemoryCacheMiddleware, hasDiskCacheMiddleware, }) => {
+    return async function tracingMiddleware(ctx, next) {
+        var _a;
+        if (!tracer.isTraceSampled) {
+            await next();
+            return;
+        }
+        const rootSpan = tracer.fallbackSpanContext();
+        const { requestSpanNameSuffix } = ctx.config.tracing || {};
+        const spanName = requestSpanNameSuffix ? `request:${requestSpanNameSuffix}` : 'request';
+        const span = tracer.startSpan(spanName, { childOf: rootSpan });
+        ctx.tracing = {
+            ...ctx.config.tracing,
+            isSampled: (0, tracing_1.getTraceInfo)(span).isSampled,
+            logger,
+            rootSpan: span,
+            tracer,
+        };
+        ctx.config.tracing = ctx.tracing;
+        const hasMemoCache = !(!(0, cache_1.isLocallyCacheable)(ctx.config, cache_1.CacheType.Any) || !ctx.config.memoizable);
+        const hasMemoryCache = hasMemoryCacheMiddleware && !!(0, cache_1.isLocallyCacheable)(ctx.config, cache_1.CacheType.Memory);
+        const hasDiskCache = hasDiskCacheMiddleware && !!(0, cache_1.isLocallyCacheable)(ctx.config, cache_1.CacheType.Disk);
+        span === null || span === void 0 ? void 0 : span.addTags({
+            ["http.cache.memoization.enabled" /* CustomHttpTags.HTTP_MEMOIZATION_CACHE_ENABLED */]: hasMemoCache,
+            ["http.cache.memory.enabled" /* CustomHttpTags.HTTP_MEMORY_CACHE_ENABLED */]: hasMemoryCache,
+            ["http.cache.disk.enabled" /* CustomHttpTags.HTTP_DISK_CACHE_ENABLED */]: hasDiskCache,
+            ["http.client.name" /* CustomHttpTags.HTTP_CLIENT_NAME */]: clientName,
+        });
+        let response;
+        try {
+            await next();
+            response = ctx.response;
+        }
+        catch (err) {
+            if (!(err instanceof axios_1.AxiosError)) {
+                throw err;
+            }
+            response = err.response;
+            if ((_a = ctx.tracing) === null || _a === void 0 ? void 0 : _a.isSampled) {
+                tracing_1.ErrorReport.create({ originalError: err }).injectOnSpan(span, logger);
+            }
+            throw err;
+        }
+        finally {
+            if (response) {
+                span === null || span === void 0 ? void 0 : span.setTag(Tags_1.OpentracingTags.HTTP_STATUS_CODE, response.status);
+            }
+            else {
+                span === null || span === void 0 ? void 0 : span.setTag("http.no_response" /* CustomHttpTags.HTTP_NO_RESPONSE */, true);
+            }
+            span === null || span === void 0 ? void 0 : span.finish();
+        }
+    };
+};
+exports.createHttpClientTracingMiddleware = createHttpClientTracingMiddleware;

package/lib/HttpClient/typings.d.ts

@@ -1,13 +1,28 @@
 /// <reference types="node" />
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { IAxiosRetryConfig } from 'axios-retry';
 import { Middleware } from 'koa-compose';
+import { Span } from 'opentracing';
 import { CacheLayer } from '../caches/CacheLayer';
 import { MetricsAccumulator } from '../metrics/MetricsAccumulator';
+import { IOContext } from '../service/worker/runtime/typings';
+import { SpanReferenceTypes } from '../tracing';
+import { IUserLandTracer } from '../tracing/UserLandTracer';
 import { Cached, CacheType } from './middlewares/cache';
-export declare type InflightKeyGenerator = (x: RequestConfig) => string;
-export interface RequestConfig extends AxiosRequestConfig {
-    'axios-retry'?: IAxiosRetryConfig;
+export type InflightKeyGenerator = (x: RequestConfig) => string;
+interface RequestTracingUserConfig {
+    rootSpan?: Span;
+    referenceType?: SpanReferenceTypes;
+    requestSpanNameSuffix?: string;
+}
+export interface RequestTracingConfig {
+    tracing?: RequestTracingUserConfig;
+}
+export interface RequestConfig extends AxiosRequestConfig, RequestTracingConfig {
+    retries?: number;
+    exponentialTimeoutCoefficient?: number;
+    initialBackoffDelay?: number;
+    exponentialBackoffCoefficient?: number;
+    retryCount?: number;
     /**
      * Identifies the type of request for metrification purposes. Should vary with client method.
      */
@@ -29,8 +44,9 @@ export interface RequestConfig extends AxiosRequestConfig {
     memoizeable?: boolean;
     inflightKey?: InflightKeyGenerator;
     forceMaxAge?: number;
-    responseEncoding?: BufferEncoding;
+    responseEncoding?: BufferEncoding | string;
     nullIfNotFound?: boolean;
+    ignoreRecorder?: boolean;
 }
 export interface CacheHit {
     disk?: 0 | 1;
@@ -38,27 +54,42 @@ export interface CacheHit {
     revalidated?: 0 | 1;
     router?: 0 | 1;
 }
+export interface MiddlewaresTracingContext extends Omit<RequestTracingUserConfig, 'rootSpan'> {
+    tracer: IUserLandTracer;
+    logger: IOContext['logger'];
+    rootSpan?: Span;
+    isSampled: boolean;
+}
 export interface MiddlewareContext {
     config: RequestConfig;
+    tracing?: MiddlewaresTracingContext;
     response?: AxiosResponse;
     cacheHit?: CacheHit;
     inflightHit?: boolean;
     memoizedHit?: boolean;
 }
-export declare type CacheStorage = CacheLayer<string, Cached>;
-export { Recorder } from './middlewares/recorder';
+export type CacheStorage = CacheLayer<string, Cached>;
 export interface InstanceOptions {
     authType?: AuthType;
     timeout?: number;
     memoryCache?: CacheLayer<string, Cached>;
     diskCache?: CacheLayer<string, Cached>;
-    baseURL?: string;
-    retries?: number;
+    asyncSetCache?: boolean;
     /**
-     * @deprecated use retries instead.
-     * @memberof InstanceOptions
+     * Enables memoization, ephemeral within each request, for all requests of this client.
+     * Useful for services that makes recursive requests, like graphql resolvers, which
+     * might fetch the same endpoint more than once.
+     * If that's not the case for your service, disabling it might improve the CPU and
+     * memory usage.
+     *
+     * Default value: true
      */
-    retryConfig?: void;
+    memoizable?: boolean;
+    baseURL?: string;
+    retries?: number;
+    exponentialTimeoutCoefficient?: number;
+    initialBackoffDelay?: number;
+    exponentialBackoffCoefficient?: number;
     metrics?: MetricsAccumulator;
     /**
      * Maximum number of concurrent requests
@@ -85,6 +116,8 @@ export interface InstanceOptions {
     verbose?: boolean;
     name?: string;
     serverTimings?: Record<string, string>;
+    httpsAgent?: AxiosRequestConfig['httpsAgent'];
+    cacheableType?: CacheType;
 }
 export interface IOResponse<T> {
     data: T;
@@ -99,3 +132,4 @@ export declare enum AuthType {
      */
     token = "token"
 }
+export {};

package/lib/HttpClient/typings.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthType = void 0;
 var AuthType;
 (function (AuthType) {
     AuthType["basic"] = "Basic";

package/lib/caches/DiskCache.d.ts

@@ -11,7 +11,7 @@ export declare class DiskCache<V> implements CacheLayer<string, V> {
     constructor(cachePath: string, readFile?: typeof readJSON, writeFile?: typeof outputJSON);
     has: (key: string) => boolean;
     getStats: (name?: string) => DiskStats;
-    get: (key: string) => Promise<void | V>;
+    get: (key: string) => Promise<V | void>;
     set: (key: string, value: V) => Promise<boolean>;
     private getPathKey;
 }

package/lib/caches/DiskCache.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiskCache = void 0;
 const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const rwlock_1 = __importDefault(require("rwlock"));
@@ -15,7 +16,7 @@ class DiskCache {
         this.total = 0;
         this.has = (key) => {
             const pathKey = this.getPathKey(key);
-            return fs_extra_1.pathExistsSync(pathKey);
+            return (0, fs_extra_1.pathExistsSync)(pathKey);
         };
         this.getStats = (name = 'disk-cache') => {
             const stats = {
@@ -63,7 +64,7 @@ class DiskCache {
             });
             return !failure;
         };
-        this.getPathKey = (key) => path_1.join(this.cachePath, key);
+        this.getPathKey = (key) => (0, path_1.join)(this.cachePath, key);
         this.lock = new rwlock_1.default();
     }
 }

package/lib/caches/LRUCache.d.ts

@@ -8,9 +8,9 @@ export declare class LRUCache<K, V> implements CacheLayer<K, V> {
     private total;
     private disposed;
     constructor(options: LRU.Options<K, V>);
-    get: (key: K) => void | V;
-    getOrSet: (key: K, fetcher?: (() => Promise<FetchResult<V>>) | undefined) => Promise<void | V>;
-    set: (key: K, value: V, maxAge?: number | undefined) => boolean;
+    get: (key: K) => V | void;
+    getOrSet: (key: K, fetcher?: () => Promise<FetchResult<V>>) => Promise<V | void>;
+    set: (key: K, value: V, maxAge?: number) => boolean;
     has: (key: K) => boolean;
     getStats: (name?: string) => LRUStats;
 }

package/lib/caches/LRUCache.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUCache = void 0;
 const lru_cache_1 = __importDefault(require("lru-cache"));
 const MultilayeredCache_1 = require("./MultilayeredCache");
 class LRUCache {
@@ -37,7 +38,11 @@ class LRUCache {
         this.hits = 0;
         this.total = 0;
         this.disposed = 0;
-        this.storage = new lru_cache_1.default(Object.assign({}, options, { dispose: () => this.disposed += 1, noDisposeOnSet: true }));
+        this.storage = new lru_cache_1.default({
+            ...options,
+            dispose: () => this.disposed += 1,
+            noDisposeOnSet: true,
+        });
         this.multilayer = new MultilayeredCache_1.MultilayeredCache([this]);
     }
 }

package/lib/caches/LRUDiskCache.d.ts

@@ -14,8 +14,8 @@ export declare class LRUDiskCache<V> implements CacheLayer<string, V> {
     constructor(cachePath: string, options: LRUDiskCacheOptions, readFile?: typeof readJSON, writeFile?: typeof outputJSON);
     has: (key: string) => boolean;
     getStats: (name?: string) => LRUStats;
-    get: (key: string) => Promise<void | V>;
-    set: (key: string, value: V, maxAge?: number | undefined) => Promise<boolean>;
+    get: (key: string) => Promise<V | void>;
+    set: (key: string, value: V, maxAge?: number) => Promise<boolean>;
     private getPathKey;
     private deleteFile;
 }

package/lib/caches/LRUDiskCache.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LRUDiskCache = void 0;
 const fs_extra_1 = require("fs-extra");
 const lru_cache_1 = __importDefault(require("lru-cache"));
 const path_1 = require("path");
@@ -92,7 +93,7 @@ class LRUDiskCache {
             return !failure;
         };
         this.getPathKey = (key) => {
-            return path_1.join(this.cachePath, key);
+            return (0, path_1.join)(this.cachePath, key);
         };
         this.deleteFile = async (key) => {
             const pathKey = this.getPathKey(key);
@@ -100,7 +101,7 @@ class LRUDiskCache {
             const failure = new Promise(resolve => {
                 this.lock.writeLock(key, async (release) => {
                     try {
-                        const removePromise = await fs_extra_1.remove(pathKey);
+                        const removePromise = await (0, fs_extra_1.remove)(pathKey);
                         release();
                         resolve(removePromise);
                     }
@@ -121,7 +122,11 @@ class LRUDiskCache {
             this.keyToBeDeleted = key;
             this.disposed += 1;
         };
-        const lruOptions = Object.assign({}, options, { dispose, noDisposeOnSet: true });
+        const lruOptions = {
+            ...options,
+            dispose,
+            noDisposeOnSet: true,
+        };
         this.lruStorage = new lru_cache_1.default(lruOptions);
     }
 }

package/lib/caches/MultilayeredCache.d.ts

@@ -5,8 +5,8 @@ export declare class MultilayeredCache<K, V> implements CacheLayer<K, V> {
     private hits;
     private total;
     constructor(caches: Array<CacheLayer<K, V>>);
-    get: (key: K, fetcher?: (() => Promise<FetchResult<V>>) | undefined) => Promise<void | V>;
-    set: (key: K, value: V, maxAge?: number | undefined) => Promise<boolean>;
+    get: (key: K, fetcher?: () => Promise<FetchResult<V>>) => Promise<V | void>;
+    set: (key: K, value: V, maxAge?: number) => Promise<boolean>;
     has: (key: K) => Promise<boolean>;
     getStats: (name?: string) => MultilayerStats;
     private findIndex;