@vtex/api 6.45.4

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

@@ -0,0 +1,9 @@
+import { MetricsAccumulator } from '../../metrics/MetricsAccumulator';
+import { MiddlewareContext } from '../typings';
+interface MetricsOpts {
+    metrics?: MetricsAccumulator;
+    serverTiming?: Record<string, string>;
+    name?: string;
+}
+export declare const metricsMiddleware: ({ metrics, serverTiming, name }: MetricsOpts) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export {};

package/lib/HttpClient/middlewares/metrics.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const RequestCancelledError_1 = require("../../errors/RequestCancelledError");
+const requestStats_1 = require("../../service/worker/runtime/http/middlewares/requestStats");
+const utils_1 = require("../../utils");
+const retry_1 = require("../../utils/retry");
+const status_1 = require("../../utils/status");
+exports.metricsMiddleware = ({ metrics, serverTiming, name }) => {
+    const serverTimingStart = process.hrtime();
+    const serverTimingLabel = utils_1.shrinkTimings(utils_1.formatTimingName({
+        hopNumber: 0,
+        source: process.env.VTEX_APP_NAME,
+        target: name || 'unknown',
+    }));
+    return async (ctx, next) => {
+        const start = process.hrtime();
+        let status = 'unknown';
+        let errorCode;
+        let errorStatus;
+        try {
+            if (ctx.config.verbose && ctx.config.label) {
+                console.log(`VERBOSE: ${name}.${ctx.config.label}`, `start`);
+            }
+            await next();
+            if (ctx.config.metric && ctx.response && ctx.response.status) {
+                status = status_1.statusLabel(ctx.response.status);
+            }
+        }
+        catch (err) {
+            const isCancelled = (err.message === requestStats_1.cancelMessage);
+            if (ctx.config.metric) {
+                errorCode = err.code;
+                errorStatus = err.response && err.response.status;
+                if (err.code === 'ECONNABORTED') {
+                    status = 'aborted';
+                }
+                else if (err.response && err.response.data && err.response.data.code === retry_1.TIMEOUT_CODE) {
+                    status = 'timeout';
+                }
+                else if (err.response && err.response.status) {
+                    status = status_1.statusLabel(err.response.status);
+                }
+                else if (isCancelled) {
+                    status = 'cancelled';
+                }
+                else {
+                    status = 'error';
+                }
+            }
+            throw isCancelled
+                ? new RequestCancelledError_1.RequestCancelledError(err.message)
+                : err;
+        }
+        finally {
+            if (ctx.config.metric && metrics) {
+                const label = `http-client-${ctx.config.metric}`;
+                const extensions = {};
+                Object.assign(extensions, { [status]: 1 });
+                if (ctx.cacheHit) {
+                    Object.assign(extensions, ctx.cacheHit, { [`${status}-hit`]: 1 });
+                }
+                else if (!ctx.inflightHit && !ctx.memoizedHit) {
+                    // Lets us know how many calls passed through to origin
+                    Object.assign(extensions, { [`${status}-miss`]: 1 });
+                }
+                if (ctx.inflightHit) {
+                    Object.assign(extensions, { [`${status}-inflight`]: 1 });
+                }
+                if (ctx.memoizedHit) {
+                    Object.assign(extensions, { [`${status}-memoized`]: 1 });
+                }
+                if (ctx.config.retryCount) {
+                    const retryCount = ctx.config.retryCount;
+                    if (retryCount > 0) {
+                        extensions[`retry-${status}-${retryCount}`] = 1;
+                    }
+                }
+                const end = status === 'success' && !ctx.cacheHit && !ctx.inflightHit && !ctx.memoizedHit
+                    ? process.hrtime(start)
+                    : undefined;
+                metrics.batch(label, end, extensions);
+                if (ctx.config.verbose) {
+                    console.log(`VERBOSE: ${name}.${ctx.config.label}`, {
+                        ...extensions,
+                        ...errorCode || errorStatus ? { errorCode, errorStatus } : null,
+                        millis: end
+                            ? utils_1.hrToMillis(end)
+                            : extensions.revalidated || extensions.router || status !== 'success'
+                                ? utils_1.hrToMillis(process.hrtime(start))
+                                : '(from cache)',
+                        status: ctx.response && ctx.response.status,
+                        headers: ctx.response && ctx.response.headers,
+                    });
+                }
+            }
+            else {
+                if (ctx.config.verbose) {
+                    console.warn(`PROTIP: Please add a metric property to ${name} client request to get metrics in Splunk`, { baseURL: ctx.config.baseURL, url: ctx.config.url });
+                }
+            }
+            if (serverTiming) {
+                // Timings in the client's perspective
+                const dur = utils_1.hrToMillis(process.hrtime(serverTimingStart));
+                if (!serverTiming[serverTimingLabel] || Number(serverTiming[serverTimingLabel]) < dur) {
+                    serverTiming[serverTimingLabel] = `${dur}`;
+                }
+            }
+        }
+    };
+};

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

@@ -0,0 +1,7 @@
+import { AxiosRequestConfig } from 'axios';
+import { MiddlewareContext } from '../typings';
+export declare const acceptNotFoundMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const notFoundFallbackMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare type IgnoreNotFoundRequestConfig = AxiosRequestConfig & {
+    nullIfNotFound?: boolean;
+};

package/lib/HttpClient/middlewares/notFound.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const addNotFound = (validateStatus) => (status) => validateStatus(status) || status === 404;
+function nullIfNotFound(config) {
+    return config && config.nullIfNotFound;
+}
+exports.acceptNotFoundMiddleware = async (ctx, next) => {
+    const { config } = ctx;
+    if (nullIfNotFound(config)) {
+        ctx.config.validateStatus = addNotFound(config.validateStatus);
+    }
+    await next();
+};
+exports.notFoundFallbackMiddleware = async (ctx, next) => {
+    await next();
+    const { config } = ctx;
+    if (nullIfNotFound(config) && ctx.response && ctx.response.status === 404) {
+        ctx.response.data = null;
+    }
+};

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

@@ -0,0 +1,3 @@
+import { MiddlewareContext } from '../typings';
+import { Recorder } from './../../service/worker/runtime/utils/recorder';
+export declare const recorderMiddleware: (recorder: Recorder) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;

package/lib/HttpClient/middlewares/recorder.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recorderMiddleware = (recorder) => async (ctx, next) => {
+    var _a;
+    if ((_a = ctx.config) === null || _a === void 0 ? void 0 : _a.ignoreRecorder) {
+        await next();
+        return;
+    }
+    try {
+        await next();
+        if (ctx.response) {
+            recorder.record(ctx.response.headers);
+        }
+    }
+    catch (err) {
+        if (err.response && err.response.headers && err.response.status === 404) {
+            recorder.record(err.response.headers);
+        }
+        throw err;
+    }
+};

package/lib/HttpClient/middlewares/request/HttpAgentSingleton.d.ts

@@ -0,0 +1,14 @@
+import HttpAgent from 'agentkeepalive';
+export declare class HttpAgentSingleton {
+    static getHttpAgent(): HttpAgent;
+    static httpAgentStats(): {
+        freeSockets: number;
+        freeSocketsPerOrigin: Record<string, number>;
+        pendingRequests: number;
+        pendingRequestsPerOrigin: Record<string, number>;
+        sockets: number;
+        socketsPerOrigin: Record<string, number>;
+    };
+    private static httpAgent;
+    private static countPerOrigin;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const agents_1 = require("../../agents");
+class HttpAgentSingleton {
+    static getHttpAgent() {
+        if (!HttpAgentSingleton.httpAgent) {
+            HttpAgentSingleton.httpAgent = agents_1.createHttpAgent();
+        }
+        return HttpAgentSingleton.httpAgent;
+    }
+    static httpAgentStats() {
+        const socketsPerOrigin = HttpAgentSingleton.countPerOrigin(HttpAgentSingleton.httpAgent.sockets);
+        const sockets = ramda_1.sum(ramda_1.values(socketsPerOrigin));
+        const freeSocketsPerOrigin = HttpAgentSingleton.countPerOrigin(HttpAgentSingleton.httpAgent.freeSockets);
+        const freeSockets = ramda_1.sum(ramda_1.values(freeSocketsPerOrigin));
+        const pendingRequestsPerOrigin = HttpAgentSingleton.countPerOrigin(HttpAgentSingleton.httpAgent.requests);
+        const pendingRequests = ramda_1.sum(ramda_1.values(pendingRequestsPerOrigin));
+        return {
+            freeSockets,
+            freeSocketsPerOrigin,
+            pendingRequests,
+            pendingRequestsPerOrigin,
+            sockets,
+            socketsPerOrigin,
+        };
+    }
+    static countPerOrigin(obj) {
+        try {
+            return ramda_1.mapObjIndexed(val => val.length, obj);
+        }
+        catch (_) {
+            return {};
+        }
+    }
+}
+exports.HttpAgentSingleton = HttpAgentSingleton;

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

@@ -0,0 +1,18 @@
+import { AxiosRequestConfig } from 'axios';
+import { Limit } from 'p-limit';
+import { MiddlewareContext } from '../../typings';
+export interface DefaultMiddlewareArgs {
+    baseURL: string | undefined;
+    rawHeaders: Record<string, string>;
+    params: Record<string, string> | undefined;
+    timeout: number;
+    retries?: number;
+    verbose?: boolean;
+    exponentialTimeoutCoefficient?: number;
+    initialBackoffDelay?: number;
+    exponentialBackoffCoefficient?: number;
+    httpsAgent?: AxiosRequestConfig['httpsAgent'];
+}
+export declare const defaultsMiddleware: ({ baseURL, rawHeaders, params, timeout, retries, verbose, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent }: DefaultMiddlewareArgs) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const routerCacheMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const requestMiddleware: (limit?: Limit | undefined) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;

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

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = setupAxios_1.getConfiguredAxios();
+const paramsSerializer = (params) => {
+    return qs_1.stringify(params, { arrayFormat: 'repeat' });
+};
+exports.defaultsMiddleware = ({ baseURL, rawHeaders, params, timeout, retries, verbose, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent }) => {
+    const countByMetric = {};
+    const headers = renameBy_1.renameBy(ramda_1.toLower, rawHeaders);
+    return (ctx, next) => {
+        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,
+                ...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 (ctx.tracing.isSampled) {
+            const { config } = ctx;
+            const fullUrl = buildFullPath_1.default(config.baseURL, http.getUri(config));
+            ctx.tracing.rootSpan.addTags({
+                [Tags_1.OpentracingTags.HTTP_METHOD]: config.method || 'get',
+                [Tags_1.OpentracingTags.HTTP_URL]: fullUrl,
+            });
+        }
+        return next();
+    };
+};
+const ROUTER_CACHE_KEY = 'x-router-cache';
+const ROUTER_CACHE_HIT = 'HIT';
+const ROUTER_CACHE_REVALIDATED = 'REVALIDATED';
+exports.routerCacheMiddleware = async (ctx, next) => {
+    var _a, _b, _c;
+    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) {
+        ctx.tracing.rootSpan.setTag("http.cache.router" /* 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.requestMiddleware = (limit) => async (ctx, next) => {
+    const makeRequest = () => http.request(ctx.config);
+    ctx.response = await (limit ? limit(makeRequest) : makeRequest());
+};

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

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,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) => {
+    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 = 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];
+        config.tracing.rootSpan.log({ event: "setup-request-retry" /* SETUP_REQUEST_RETRY */, ["retry-number" /* RETRY_NUMBER */]: config.retryCount, ["retry-in" /* RETRY_IN */]: delay });
+        return new Promise(resolve => setTimeout(() => resolve(http(config)), delay));
+    }
+    return Promise.reject(error);
+};
+exports.addExponentialBackoffResponseInterceptor = (http) => {
+    http.interceptors.response.use(undefined, onResponseError(http));
+};

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,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var exponentialBackoff_1 = require("./exponentialBackoff");
+exports.addExponentialBackoffResponseInterceptor = exponentialBackoff_1.addExponentialBackoffResponseInterceptor;
+var tracing_1 = require("./tracing");
+exports.addTracingPreRequestInterceptor = tracing_1.addTracingPreRequestInterceptor;
+exports.addTracingResponseInterceptor = 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,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) => {
+    if (!config.tracing || !config.tracing.isSampled) {
+        return config;
+    }
+    const { tracer, rootSpan, requestSpanNameSuffix } = config.tracing;
+    const spanName = requestSpanNameSuffix ? `${exports.requestSpanPrefix}:${requestSpanNameSuffix}` : exports.requestSpanPrefix;
+    const span = rootSpan
+        ? tracer.startSpan(spanName, {
+            references: [tracing_1.createSpanReference(rootSpan, SpanReferenceTypes_1.SpanReferenceTypes.CHILD_OF)],
+        })
+        : tracer.startSpan(spanName);
+    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) => {
+    if (!response.config.tracing || !response.config.tracing.isSampled) {
+        return response;
+    }
+    const requestSpan = response.config.tracing.requestSpan;
+    spanSetup_1.injectResponseInfoOnSpan(requestSpan, response);
+    requestSpan.finish();
+    return response;
+};
+const onResponseError = (err) => {
+    var _a, _b;
+    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) || !err.config.tracing.isSampled) {
+        return Promise.reject(err);
+    }
+    const { requestSpan } = err.config.tracing;
+    spanSetup_1.injectResponseInfoOnSpan(requestSpan, err.response);
+    tracing_1.ErrorReport.create({ originalError: err }).injectOnSpan(requestSpan, err.config.tracing.logger);
+    requestSpan.finish();
+    return Promise.reject(err);
+};
+exports.addTracingPreRequestInterceptor = (http) => {
+    const requestTracingInterceptor = http.interceptors.request.use(preRequestInterceptor(http), undefined);
+    return { requestTracingInterceptor };
+};
+exports.addTracingResponseInterceptor = (http) => {
+    const responseTracingInterceptor = http.interceptors.response.use(onResponseSuccess, onResponseError);
+    return { responseTracingInterceptor };
+};