@vtex/api 6.45.4

package/lib/HttpClient/agents.d.ts

@@ -0,0 +1,3 @@
+import HttpAgent, { HttpOptions as AgentHttpOptions, HttpsAgent, HttpsOptions as AgentHttpsOptions } from 'agentkeepalive';
+export declare const createHttpAgent: (opts?: Pick<AgentHttpOptions, "freeSocketKeepAliveTimeout" | "timeout" | "socketActiveTTL" | "keepAliveMsecs" | "maxSockets"> | undefined) => HttpAgent;
+export declare const createHttpsAgent: (opts?: Pick<AgentHttpsOptions, "freeSocketKeepAliveTimeout" | "timeout" | "socketActiveTTL" | "keepAliveMsecs" | "maxSockets" | "rejectUnauthorized" | "maxCachedSessions" | "host" | "port" | "path" | "socket" | "checkServerIdentity" | "servername" | "session" | "minDHSize" | "lookup" | "ca" | "cert" | "sigalgs" | "ciphers" | "clientCertEngine" | "crl" | "dhparam" | "ecdhCurve" | "honorCipherOrder" | "key" | "privateKeyEngine" | "privateKeyIdentifier" | "maxVersion" | "minVersion" | "passphrase" | "pfx" | "secureOptions" | "secureProtocol" | "sessionIdContext" | "secureContext" | "enableTrace" | "requestCert" | "ALPNProtocols" | "SNICallback"> | undefined) => HttpsAgent;

package/lib/HttpClient/agents.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const agentkeepalive_1 = __importStar(require("agentkeepalive"));
+exports.createHttpAgent = (opts) => new agentkeepalive_1.default({
+    ...opts,
+    freeSocketTimeout: 30 * 1000,
+    keepAlive: true,
+    maxFreeSockets: 256,
+    socketActiveTTL: 120 * 1000,
+});
+exports.createHttpsAgent = (opts) => new agentkeepalive_1.HttpsAgent({
+    ...opts,
+    freeSocketTimeout: 30 * 1000,
+    keepAlive: true,
+    maxFreeSockets: 256,
+    socketActiveTTL: 120 * 1000,
+});

package/lib/HttpClient/index.d.ts

@@ -0,0 +1,6 @@
+export * from './HttpClient';
+export * from './typings';
+export * from './GraphQLClient';
+export * from './agents';
+export { Cached, CacheType } from './middlewares/cache';
+export { inflightURL, inflightUrlWithQuery } from './middlewares/inflight';

package/lib/HttpClient/index.js

@@ -0,0 +1,14 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./HttpClient"));
+__export(require("./typings"));
+__export(require("./GraphQLClient"));
+__export(require("./agents"));
+var cache_1 = require("./middlewares/cache");
+exports.CacheType = cache_1.CacheType;
+var inflight_1 = require("./middlewares/inflight");
+exports.inflightURL = inflight_1.inflightURL;
+exports.inflightUrlWithQuery = inflight_1.inflightUrlWithQuery;

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

@@ -0,0 +1,35 @@
+/// <reference types="node" />
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+import { CacheLayer } from '../../caches/CacheLayer';
+import { MiddlewareContext, RequestConfig } from '../typings';
+export declare const cacheKey: (config: AxiosRequestConfig) => string;
+export declare function isLocallyCacheable(arg: RequestConfig, type: CacheType): arg is CacheableRequestConfig;
+export declare enum CacheType {
+    None = 0,
+    Memory = 1,
+    Disk = 2,
+    Any = 3
+}
+export declare const enum CacheResult {
+    HIT = "HIT",
+    MISS = "MISS",
+    STALE = "STALE"
+}
+interface CacheOptions {
+    type: CacheType;
+    storage: CacheLayer<string, Cached>;
+}
+export declare const cacheMiddleware: ({ type, storage }: CacheOptions) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export interface Cached {
+    etag: string;
+    expiration: number;
+    response: Partial<AxiosResponse>;
+    responseType?: string;
+    responseEncoding?: BufferEncoding;
+}
+export declare type CacheableRequestConfig = RequestConfig & {
+    url: string;
+    cacheable: CacheType;
+    memoizable: boolean;
+};
+export {};

package/lib/HttpClient/middlewares/cache.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const RANGE_HEADER_QS_KEY = '__range_header';
+const cacheableStatusCodes = [200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501]; // https://tools.ietf.org/html/rfc7231#section-6.1
+exports.cacheKey = (config) => {
+    const { baseURL = '', url = '', params, headers } = config;
+    const locale = headers[constants_1.LOCALE_HEADER];
+    const encodedBaseURL = baseURL.replace(/\//g, '\\');
+    const encodedURL = url.replace(/\//g, '\\');
+    let key = `${locale}--${encodedBaseURL}--${encodedURL}?`;
+    if (params) {
+        Object.keys(params).sort().forEach(p => key = key.concat(`--${p}=${params[p]}`));
+    }
+    if (headers === null || headers === void 0 ? void 0 : headers.range) {
+        key = key.concat(`--${RANGE_HEADER_QS_KEY}=${headers.range}`);
+    }
+    return key;
+};
+const parseCacheHeaders = (headers) => {
+    const { 'cache-control': cacheControl = '', etag, age: ageStr } = headers;
+    const cacheDirectives = cacheControl.split(',').map(d => d.trim());
+    const maxAgeDirective = cacheDirectives.find(d => d.startsWith('max-age'));
+    const [, maxAgeStr] = maxAgeDirective ? maxAgeDirective.split('=') : [null, null];
+    const maxAge = maxAgeStr ? parseInt(maxAgeStr, 10) : 0;
+    const age = ageStr ? parseInt(ageStr, 10) : 0;
+    return {
+        age,
+        etag,
+        maxAge,
+        noCache: cacheDirectives.indexOf('no-cache') !== -1,
+        noStore: cacheDirectives.indexOf('no-store') !== -1,
+    };
+};
+function isLocallyCacheable(arg, type) {
+    return arg && !!arg.cacheable
+        && (arg.cacheable === type || arg.cacheable === CacheType.Any || type === CacheType.Any);
+}
+exports.isLocallyCacheable = isLocallyCacheable;
+const addNotModified = (validateStatus) => (status) => validateStatus(status) || status === 304;
+var CacheType;
+(function (CacheType) {
+    CacheType[CacheType["None"] = 0] = "None";
+    CacheType[CacheType["Memory"] = 1] = "Memory";
+    CacheType[CacheType["Disk"] = 2] = "Disk";
+    CacheType[CacheType["Any"] = 3] = "Any";
+})(CacheType = exports.CacheType || (exports.CacheType = {}));
+const CacheTypeNames = {
+    [CacheType.None]: 'none',
+    [CacheType.Memory]: 'memory',
+    [CacheType.Disk]: 'disk',
+    [CacheType.Any]: 'any',
+};
+exports.cacheMiddleware = ({ type, storage }) => {
+    const CACHE_RESULT_TAG = type === CacheType.Disk ? "http.cache.disk" /* HTTP_DISK_CACHE_RESULT */ : "http.cache.memory" /* HTTP_MEMORY_CACHE_RESULT */;
+    const cacheType = CacheTypeNames[type];
+    return async (ctx, next) => {
+        if (!isLocallyCacheable(ctx.config, type)) {
+            return await next();
+        }
+        const span = ctx.tracing.rootSpan;
+        const key = exports.cacheKey(ctx.config);
+        const segmentToken = ctx.config.headers[constants_1.SEGMENT_HEADER];
+        const keyWithSegment = key + segmentToken;
+        span.log({
+            event: "cache-key-created" /* CACHE_KEY_CREATE */,
+            ["cache-type" /* CACHE_TYPE */]: cacheType,
+            ["key" /* KEY */]: key,
+            ["key-with-segment" /* KEY_WITH_SEGMENT */]: keyWithSegment,
+        });
+        const cacheHasWithSegment = await storage.has(keyWithSegment);
+        const cached = cacheHasWithSegment ? await storage.get(keyWithSegment) : await storage.get(key);
+        if (cached && cached.response) {
+            const { etag: cachedEtag, response, expiration, responseType, responseEncoding } = cached;
+            if (type === CacheType.Disk && responseType === 'arraybuffer') {
+                response.data = Buffer.from(response.data, responseEncoding);
+            }
+            const now = Date.now();
+            span.log({
+                event: "local-cache-hit-info" /* LOCAL_CACHE_HIT_INFO */,
+                ["cache-type" /* CACHE_TYPE */]: cacheType,
+                ["etag" /* ETAG */]: cachedEtag,
+                ["expiration-time" /* EXPIRATION_TIME */]: (expiration - now) / 1000,
+                ["response-type" /* RESPONSE_TYPE */]: responseType,
+                ["response-encoding" /* RESPONSE_ENCONDING */]: responseEncoding,
+            });
+            if (expiration > now) {
+                ctx.response = response;
+                ctx.cacheHit = {
+                    memory: 1,
+                    revalidated: 0,
+                    router: 0,
+                };
+                span.setTag(CACHE_RESULT_TAG, "HIT" /* HIT */);
+                return;
+            }
+            span.setTag(CACHE_RESULT_TAG, "STALE" /* STALE */);
+            const validateStatus = addNotModified(ctx.config.validateStatus);
+            if (cachedEtag && validateStatus(response.status)) {
+                ctx.config.headers['if-none-match'] = cachedEtag;
+                ctx.config.validateStatus = validateStatus;
+            }
+        }
+        else {
+            span.setTag(CACHE_RESULT_TAG, "MISS" /* MISS */);
+        }
+        await next();
+        if (!ctx.response) {
+            return;
+        }
+        const revalidated = ctx.response.status === 304;
+        if (revalidated && cached) {
+            ctx.response = cached.response;
+            ctx.cacheHit = {
+                memory: 1,
+                revalidated: 1,
+                router: 0,
+            };
+        }
+        const { data, headers, status } = ctx.response;
+        const { age, etag, maxAge: headerMaxAge, noStore, noCache } = parseCacheHeaders(headers);
+        const { forceMaxAge } = ctx.config;
+        const maxAge = forceMaxAge && cacheableStatusCodes.includes(status) ? Math.max(forceMaxAge, headerMaxAge) : headerMaxAge;
+        span.log({
+            event: "cache-config" /* CACHE_CONFIG */,
+            ["cache-type" /* CACHE_TYPE */]: cacheType,
+            ["age" /* AGE */]: age,
+            ["calculated-max-age" /* CALCULATED_MAX_AGE */]: maxAge,
+            ["max-age" /* MAX_AGE */]: headerMaxAge,
+            ["force-max-age" /* FORCE_MAX_AGE */]: forceMaxAge,
+            ["etag" /* ETAG */]: etag,
+            ["no-cache" /* NO_CACHE */]: noCache,
+            ["no-store" /* NO_STORE */]: noStore,
+        });
+        // Indicates this should NOT be cached and this request will not be considered a miss.
+        if (!forceMaxAge && (noStore || (noCache && !etag))) {
+            span.log({ event: "no-local-cache-save" /* NO_LOCAL_CACHE_SAVE */, ["cache-type" /* CACHE_TYPE */]: cacheType });
+            return;
+        }
+        const shouldCache = maxAge || etag;
+        const varySession = ctx.response.headers.vary && ctx.response.headers.vary.includes(constants_1.SESSION_HEADER);
+        if (shouldCache && !varySession) {
+            const { responseType, responseEncoding: configResponseEncoding } = ctx.config;
+            const currentAge = revalidated ? 0 : age;
+            const varySegment = ctx.response.headers.vary && ctx.response.headers.vary.includes(constants_1.SEGMENT_HEADER);
+            const setKey = varySegment ? keyWithSegment : key;
+            const responseEncoding = configResponseEncoding || (responseType === 'arraybuffer' ? 'base64' : undefined);
+            const cacheableData = type === CacheType.Disk && responseType === 'arraybuffer'
+                ? data.toString(responseEncoding)
+                : data;
+            const expiration = Date.now() + (maxAge - currentAge) * 1000;
+            await storage.set(setKey, {
+                etag,
+                expiration,
+                response: { data: cacheableData, headers, status },
+                responseEncoding,
+                responseType,
+            });
+            span.log({
+                event: "local-cache-saved" /* LOCAL_CACHE_SAVED */,
+                ["cache-type" /* CACHE_TYPE */]: cacheType,
+                ["key-set" /* KEY_SET */]: setKey,
+                ["age" /* AGE */]: currentAge,
+                ["etag" /* ETAG */]: etag,
+                ["expiration-time" /* EXPIRATION_TIME */]: (expiration - Date.now()) / 1000,
+                ["response-encoding" /* RESPONSE_ENCONDING */]: responseEncoding,
+                ["response-type" /* RESPONSE_TYPE */]: responseType,
+            });
+            return;
+        }
+        span.log({ event: "no-local-cache-save" /* NO_LOCAL_CACHE_SAVE */, ["cache-type" /* CACHE_TYPE */]: cacheType });
+    };
+};

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

@@ -0,0 +1,3 @@
+import { Cancellation } from '../../service/worker/runtime/typings';
+import { MiddlewareContext } from '../typings';
+export declare const cancellationToken: (cancellation?: Cancellation | undefined) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;

package/lib/HttpClient/middlewares/cancellationToken.js

@@ -0,0 +1,72 @@
+"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 constants_1 = require("../../constants");
+const production = process.env.VTEX_PRODUCTION === 'true';
+const handleCancellation = (ctx, cancellation) => {
+    let cancellable = true;
+    return {
+        cancelToken: new axios_1.default.CancelToken((canceller) => {
+            cancellation.source.token.promise.then(cancel => {
+                if (cancellable) {
+                    canceller(cancel.message);
+                }
+            });
+        }),
+        onRequestFinish: () => {
+            if (!ctx.config.cancelToken) {
+                // don't have cancelToken: not cancelable
+                cancellable = false;
+            }
+            else if (!ctx.response) {
+                // response is not ready: cancelable
+                cancellable = true;
+            }
+            else if (ctx.config.responseType !== 'stream') {
+                // response is ready and it is not a stream: not cancelable
+                cancellable = false;
+            }
+            else if (ctx.response.data.readableEnded) {
+                // response stream has ended: not cancelable
+                cancellable = false;
+            }
+            else {
+                // when response stream ends: not cancelable
+                ctx.response.data.on('end', function streamEnded() {
+                    cancellable = false;
+                });
+            }
+        },
+    };
+};
+exports.cancellationToken = (cancellation) => async (ctx, next) => {
+    const { config: { method } } = ctx;
+    if (!cancellation) {
+        return await next();
+    }
+    if (method && !constants_1.cancellableMethods.has(method.toUpperCase())) {
+        cancellation.cancelable = false;
+    }
+    if (!cancellation.cancelable || !cancellation.source) {
+        return await next();
+    }
+    if (!cancellation.source.token.throwIfRequested) {
+        if (!production) {
+            throw new Error('Missing cancellation function. Are you trying to use HttpClient via workers threads?');
+        }
+        else {
+            return await next();
+        }
+    }
+    const { onRequestFinish, cancelToken } = handleCancellation(ctx, cancellation);
+    ctx.config.cancelToken = cancelToken;
+    try {
+        await next();
+    }
+    finally {
+        onRequestFinish();
+    }
+};

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

@@ -0,0 +1,5 @@
+import { InflightKeyGenerator, MiddlewareContext } from '../typings';
+export declare type Inflight = Required<Pick<MiddlewareContext, 'cacheHit' | 'response'>>;
+export declare const singleFlightMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const inflightURL: InflightKeyGenerator;
+export declare const inflightUrlWithQuery: InflightKeyGenerator;

package/lib/HttpClient/middlewares/inflight.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const qs_1 = require("qs");
+const inflight = new Map();
+let metricsAdded = false;
+exports.singleFlightMiddleware = async (ctx, next) => {
+    const { inflightKey } = ctx.config;
+    if (!inflightKey) {
+        return await next();
+    }
+    // We cannot allow single flight requests to
+    // cancel any request
+    ctx.config.cancelToken = undefined;
+    if (!metricsAdded) {
+        metrics.addOnFlushMetric(() => ({
+            name: 'node-vtex-api-inflight-map-size',
+            size: inflight.entries.length,
+        }));
+        metricsAdded = true;
+    }
+    const key = inflightKey(ctx.config);
+    const isInflight = !!inflight.has(key);
+    if (isInflight) {
+        const memoized = await inflight.get(key);
+        ctx.inflightHit = isInflight;
+        ctx.response = memoized.response;
+        return;
+    }
+    else {
+        const promise = new Promise(async (resolve, reject) => {
+            try {
+                await next();
+                resolve({
+                    cacheHit: ctx.cacheHit,
+                    response: ctx.response,
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+            finally {
+                inflight.delete(key);
+            }
+        });
+        inflight.set(key, promise);
+        await promise;
+    }
+};
+exports.inflightURL = ({ baseURL, url }) => baseURL + url;
+exports.inflightUrlWithQuery = ({ baseURL, url, params }) => baseURL + url + qs_1.stringify(params, { arrayFormat: 'repeat', addQueryPrefix: true });

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

@@ -0,0 +1,7 @@
+import { MiddlewareContext } from '../typings';
+export declare type Memoized = Required<Pick<MiddlewareContext, 'cacheHit' | 'response'>>;
+interface MemoizationOptions {
+    memoizedCache: Map<string, Promise<Memoized>>;
+}
+export declare const memoizationMiddleware: ({ memoizedCache }: MemoizationOptions) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export {};

package/lib/HttpClient/middlewares/memoization.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cache_1 = require("./cache");
+exports.memoizationMiddleware = ({ memoizedCache }) => {
+    return async (ctx, next) => {
+        if (!cache_1.isLocallyCacheable(ctx.config, cache_1.CacheType.Any) || !ctx.config.memoizable) {
+            return next();
+        }
+        const span = ctx.tracing.rootSpan;
+        const key = cache_1.cacheKey(ctx.config);
+        const isMemoized = !!memoizedCache.has(key);
+        span.log({ event: "cache-key-created" /* CACHE_KEY_CREATE */, ["cache-type" /* CACHE_TYPE */]: 'memoization', ["key" /* KEY */]: key });
+        if (isMemoized) {
+            span.setTag("http.cache.memoization" /* HTTP_MEMOIZATION_CACHE_RESULT */, "HIT" /* HIT */);
+            const memoized = await memoizedCache.get(key);
+            ctx.memoizedHit = isMemoized;
+            ctx.response = memoized.response;
+            return;
+        }
+        else {
+            span.setTag("http.cache.memoization" /* HTTP_MEMOIZATION_CACHE_RESULT */, "MISS" /* MISS */);
+            const promise = new Promise(async (resolve, reject) => {
+                try {
+                    await next();
+                    resolve({
+                        cacheHit: ctx.cacheHit,
+                        response: ctx.response,
+                    });
+                    span.log({ event: "memoization-cache-saved" /* MEMOIZATION_CACHE_SAVED */, ["key-set" /* KEY_SET */]: key });
+                }
+                catch (err) {
+                    reject(err);
+                    span.log({ event: "memoization-cache-saved-error" /* MEMOIZATION_CACHE_SAVED_ERROR */, ["key-set" /* KEY_SET */]: key });
+                }
+            });
+            memoizedCache.set(key, promise);
+            await promise;
+        }
+    };
+};