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

package/gen/manifest.schema

@@ -3,8 +3,8 @@
     "definitions": {
         "BILLING_TYPE": {
             "enum": [
-                "billable",
                 "free",
+                "billable",
                 "sponsored"
             ],
             "type": "string"
@@ -110,6 +110,9 @@
                 "email": {
                     "type": "string"
                 },
+                "phone": {
+                    "type": "string"
+                },
                 "url": {
                     "type": "string"
                 }
@@ -169,8 +172,7 @@
             },
             "type": "array"
         },
-        "settingsSchema": {
-        },
+        "settingsSchema": {},
         "title": {
             "type": "string"
         },

package/lib/HttpClient/GraphQLClient.d.ts

@@ -6,6 +6,7 @@ interface QueryOptions<Variables extends object> {
     variables: Variables;
     inflight?: boolean;
     throwOnError?: boolean;
+    extensions?: Record<string, any>;
 }
 interface MutateOptions<Variables extends object> {
     mutate: string;
@@ -21,7 +22,7 @@ export interface GraphQLResponse<T extends Serializable> {
 export declare class GraphQLClient {
     private http;
     constructor(http: HttpClient);
-    query: <Data extends Serializable, Variables extends object>({ query, variables, inflight, throwOnError }: QueryOptions<Variables>, config?: RequestConfig) => Promise<GraphQLResponse<Data>>;
+    query: <Data extends Serializable, Variables extends object>({ query, variables, inflight, extensions, throwOnError }: QueryOptions<Variables>, config?: RequestConfig) => Promise<GraphQLResponse<Data>>;
     mutate: <Data extends Serializable, Variables extends object>({ mutate, variables, throwOnError }: MutateOptions<Variables>, config?: RequestConfig) => Promise<GraphQLResponse<Data>>;
 }
 export {};

package/lib/HttpClient/GraphQLClient.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.GraphQLClient = void 0;
 const customGraphQLError_1 = __importDefault(require("../errors/customGraphQLError"));
 const inflight_1 = require("./middlewares/inflight");
 const throwOnGraphQLErrors = (message, response) => {
@@ -14,7 +15,10 @@ const throwOnGraphQLErrors = (message, response) => {
 class GraphQLClient {
     constructor(http) {
         this.http = http;
-        this.query = ({ query, variables, inflight, throwOnError }, config = {}) => this.http.getWithBody(config.url || '', { query, variables }, Object.assign({ inflightKey: inflight !== false ? inflight_1.inflightUrlWithQuery : undefined }, config))
+        this.query = ({ query, variables, inflight, extensions, throwOnError }, config = {}) => this.http.getWithBody(config.url || '', { query, variables, extensions }, {
+            inflightKey: inflight !== false ? inflight_1.inflightUrlWithQuery : undefined,
+            ...config,
+        })
             .then(graphqlResponse => throwOnError === false
             ? graphqlResponse
             : throwOnGraphQLErrors(this.http.name, graphqlResponse));

package/lib/HttpClient/HttpClient.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="node" />
 import { AxiosResponse } from 'axios';
 import { IncomingMessage } from 'http';
-import { IOContext } from '../service/typings';
+import { IOContext } from '../service/worker/runtime/typings';
 import { InstanceOptions, IOResponse, RequestConfig } from './typings';
 declare type ClientOptions = IOContext & Partial<InstanceOptions>;
 export declare class HttpClient {
-    static forWorkspace: (service: string, context: IOContext, opts: InstanceOptions) => HttpClient;
-    static forRoot: (service: string, context: IOContext, opts: InstanceOptions) => HttpClient;
-    static forExternal: (baseURL: string, context: IOContext, opts: InstanceOptions) => HttpClient;
     name: string;
+    private logger;
+    private cacheableType;
+    private memoizable;
     private runMiddlewares;
     constructor(opts: ClientOptions);
     get: <T = any>(url: string, config?: RequestConfig) => Promise<T>;
@@ -20,12 +20,13 @@ export declare class HttpClient {
     }>;
     getStream: (url: string, config?: RequestConfig) => Promise<IncomingMessage>;
     put: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
+    putRaw: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<IOResponse<T>>;
     post: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
     postRaw: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<IOResponse<T>>;
     patch: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
     head: (url: string, config?: RequestConfig) => Promise<IOResponse<void>>;
     delete: <T = void>(url: string, config?: RequestConfig | undefined) => Promise<IOResponse<T>>;
-    protected request: (config: RequestConfig) => Promise<AxiosResponse<any, any>>;
+    protected request: (config: RequestConfig) => Promise<AxiosResponse>;
     private getConfig;
 }
 export {};

package/lib/HttpClient/HttpClient.js

@@ -3,13 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
 const crypto_1 = require("crypto");
 const koa_compose_1 = __importDefault(require("koa-compose"));
 const p_limit_1 = __importDefault(require("p-limit"));
 const constants_1 = require("../constants");
 const binding_1 = require("../utils/binding");
 const tenant_1 = require("../utils/tenant");
-const factories_1 = require("./factories");
 const cache_1 = require("./middlewares/cache");
 const cancellationToken_1 = require("./middlewares/cancellationToken");
 const inflight_1 = require("./middlewares/inflight");
@@ -18,6 +18,7 @@ const metrics_1 = require("./middlewares/metrics");
 const notFound_1 = require("./middlewares/notFound");
 const recorder_1 = require("./middlewares/recorder");
 const request_1 = require("./middlewares/request");
+const tracing_1 = require("./middlewares/tracing");
 const DEFAULT_TIMEOUT_MS = 1000;
 const noTransforms = [(data) => data];
 class HttpClient {
@@ -31,40 +32,63 @@ class HttpClient {
             return this.request(cacheableConfig);
         };
         this.getWithBody = (url, data, config = {}) => {
-            const bodyHash = crypto_1.createHash('md5').update(JSON.stringify(data, null, 2)).digest('hex');
-            const cacheableConfig = this.getConfig(url, Object.assign({}, config, { data, params: Object.assign({}, config.params, { [constants_1.BODY_HASH]: bodyHash }) }));
+            const deterministicReplacer = (_, v) => {
+                try {
+                    return typeof v !== 'object' || v === null || Array.isArray(v) ? v :
+                        Object.fromEntries(Object.entries(v).sort(([ka], [kb]) => ka < kb ? -1 : ka > kb ? 1 : 0));
+                }
+                catch (error) {
+                    // I don't believe this will ever happen, but just in case
+                    // Also, I didn't include error as I am unsure if it would have sensitive information
+                    this.logger.warn({ message: 'Error while sorting object for cache key' });
+                    return v;
+                }
+            };
+            const bodyHash = crypto_1.createHash('md5').update(JSON.stringify(data, deterministicReplacer)).digest('hex');
+            const cacheableConfig = this.getConfig(url, {
+                ...config,
+                data,
+                params: {
+                    ...config.params,
+                    [constants_1.BODY_HASH]: bodyHash,
+                },
+            });
             return this.request(cacheableConfig).then(response => response.data);
         };
         this.getBuffer = (url, config = {}) => {
-            const bufferConfig = Object.assign({ cacheable: cache_1.CacheType.Disk }, config, { url, responseType: 'arraybuffer', transformResponse: noTransforms });
+            const bufferConfig = { cacheable: cache_1.CacheType.Disk, ...config, url, responseType: 'arraybuffer', transformResponse: noTransforms };
             return this.request(bufferConfig);
         };
         this.getStream = (url, config = {}) => {
-            const streamConfig = Object.assign({}, config, { url, responseType: 'stream', transformResponse: noTransforms });
+            const streamConfig = { ...config, url, responseType: 'stream', transformResponse: noTransforms };
             return this.request(streamConfig).then(response => response.data);
         };
         this.put = (url, data, config = {}) => {
-            const putConfig = Object.assign({}, config, { url, data, method: 'put' });
+            const putConfig = { ...config, url, data, method: 'put' };
             return this.request(putConfig).then(response => response.data);
         };
+        this.putRaw = (url, data, config = {}) => {
+            const putConfig = { ...config, url, data, method: 'put' };
+            return this.request(putConfig);
+        };
         this.post = (url, data, config = {}) => {
-            const postConfig = Object.assign({}, config, { url, data, method: 'post' });
+            const postConfig = { ...config, url, data, method: 'post' };
             return this.request(postConfig).then(response => response.data);
         };
         this.postRaw = (url, data, config = {}) => {
-            const postConfig = Object.assign({}, config, { url, data, method: 'post' });
+            const postConfig = { ...config, url, data, method: 'post' };
             return this.request(postConfig);
         };
         this.patch = (url, data, config = {}) => {
-            const patchConfig = Object.assign({}, config, { url, data, method: 'patch' });
+            const patchConfig = { ...config, url, data, method: 'patch' };
             return this.request(patchConfig).then(response => response.data);
         };
         this.head = (url, config = {}) => {
-            const headConfig = Object.assign({}, config, { url, method: 'head' });
+            const headConfig = { ...config, url, method: 'head' };
             return this.request(headConfig);
         };
         this.delete = (url, config) => {
-            const deleteConfig = Object.assign({}, config, { url, method: 'delete' });
+            const deleteConfig = { ...config, url, method: 'delete' };
             return this.request(deleteConfig);
         };
         this.request = async (config) => {
@@ -72,32 +96,51 @@ class HttpClient {
             await this.runMiddlewares(context);
             return context.response;
         };
-        this.getConfig = (url, config = {}) => (Object.assign({ cacheable: cache_1.CacheType.Memory, memoizable: true }, config, { url }));
-        const { baseURL, authToken, authType, memoryCache, diskCache, locale, name, metrics, product, serverTiming, recorder, userAgent, timeout = DEFAULT_TIMEOUT_MS, segmentToken, sessionToken, retries, concurrency, headers: defaultHeaders, host, params, operationId, tenant, binding, verbose, cancellation, } = opts;
+        this.getConfig = (url, config = {}) => ({
+            cacheable: this.cacheableType,
+            memoizable: this.memoizable,
+            ...config,
+            url,
+        });
+        const { baseURL, authToken, authType, memoryCache, diskCache, memoizable = true, asyncSetCache, locale, name, metrics, product, serverTiming, recorder, userAgent, timeout = DEFAULT_TIMEOUT_MS, segmentToken, sessionToken, retries, concurrency, headers: defaultHeaders, host, params, operationId, tenant, binding, verbose, cancellation, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent, tracer, logger, cacheableType = cache_1.CacheType.Memory, } = opts;
         this.name = name || baseURL || 'unknown';
+        this.logger = logger;
+        this.cacheableType = cacheableType;
+        this.memoizable = memoizable;
         const limit = concurrency && concurrency > 0 && p_limit_1.default(concurrency) || undefined;
-        const headers = Object.assign({}, defaultHeaders, { 'Accept-Encoding': 'gzip', 'User-Agent': userAgent }, host ? { [constants_1.FORWARDED_HOST_HEADER]: host } : null, tenant ? { [constants_1.TENANT_HEADER]: tenant_1.formatTenantHeaderValue(tenant) } : null, binding ? { [constants_1.BINDING_HEADER]: binding_1.formatBindingHeaderValue(binding) } : null, locale ? { [constants_1.LOCALE_HEADER]: locale } : null, operationId ? { 'x-vtex-operation-id': operationId } : null, product ? { [constants_1.PRODUCT_HEADER]: product } : null, segmentToken ? { [constants_1.SEGMENT_HEADER]: segmentToken } : null, sessionToken ? { [constants_1.SESSION_HEADER]: sessionToken } : null);
+        const headers = {
+            ...defaultHeaders,
+            'Accept-Encoding': 'gzip',
+            'User-Agent': userAgent,
+            ...host ? { [constants_1.FORWARDED_HOST_HEADER]: host } : null,
+            ...tenant ? { [constants_1.TENANT_HEADER]: tenant_1.formatTenantHeaderValue(tenant) } : null,
+            ...binding ? { [constants_1.BINDING_HEADER]: binding_1.formatBindingHeaderValue(binding) } : null,
+            ...locale ? { [constants_1.LOCALE_HEADER]: locale } : null,
+            ...operationId ? { 'x-vtex-operation-id': operationId } : null,
+            ...product ? { [constants_1.PRODUCT_HEADER]: product } : null,
+            ...segmentToken ? { [constants_1.SEGMENT_HEADER]: segmentToken } : null,
+            ...sessionToken ? { [constants_1.SESSION_HEADER]: sessionToken } : null,
+        };
         if (authType && authToken) {
             headers['Authorization'] = `${authType} ${authToken}`; // tslint:disable-line
         }
         const memoizedCache = new Map();
-        this.runMiddlewares = koa_compose_1.default([...opts.middlewares || [],
-            request_1.defaultsMiddleware(baseURL, headers, params, timeout, retries, verbose),
+        this.runMiddlewares = koa_compose_1.default([
+            tracing_1.createHttpClientTracingMiddleware({ tracer, logger, clientName: this.name, hasDiskCacheMiddleware: !!diskCache, hasMemoryCacheMiddleware: !!memoryCache }),
+            ...(opts.middlewares || []),
+            request_1.defaultsMiddleware({ baseURL, rawHeaders: headers, params, timeout, retries, verbose, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent }),
             metrics_1.metricsMiddleware({ metrics, serverTiming, name }),
             memoization_1.memoizationMiddleware({ memoizedCache }),
             ...recorder ? [recorder_1.recorderMiddleware(recorder)] : [],
             cancellationToken_1.cancellationToken(cancellation),
             inflight_1.singleFlightMiddleware,
             notFound_1.acceptNotFoundMiddleware,
-            ...memoryCache ? [cache_1.cacheMiddleware({ type: cache_1.CacheType.Memory, storage: memoryCache })] : [],
-            ...diskCache ? [cache_1.cacheMiddleware({ type: cache_1.CacheType.Disk, storage: diskCache })] : [],
+            ...memoryCache ? [cache_1.cacheMiddleware({ type: cache_1.CacheType.Memory, storage: memoryCache, asyncSet: asyncSetCache })] : [],
+            ...diskCache ? [cache_1.cacheMiddleware({ type: cache_1.CacheType.Disk, storage: diskCache, asyncSet: asyncSetCache })] : [],
             notFound_1.notFoundFallbackMiddleware,
             request_1.routerCacheMiddleware,
             request_1.requestMiddleware(limit),
         ]);
     }
 }
-HttpClient.forWorkspace = factories_1.forWorkspace;
-HttpClient.forRoot = factories_1.forRoot;
-HttpClient.forExternal = factories_1.forExternal;
 exports.HttpClient = HttpClient;

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,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpsAgent = exports.createHttpAgent = void 0;
+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

@@ -1,12 +1,6 @@
-export * from './AppClient';
-export * from './ExternalClient';
 export * from './HttpClient';
-export * from './InfraClient';
-export * from './IOClient';
-export * from './JanusClient';
 export * from './typings';
 export * from './GraphQLClient';
-export * from './AppGraphQLClient';
-export * from './IOGraphQLClient';
+export * from './agents';
 export { Cached, CacheType } from './middlewares/cache';
 export { inflightURL, inflightUrlWithQuery } from './middlewares/inflight';

package/lib/HttpClient/index.js

@@ -1,20 +1,21 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./AppClient"));
-__export(require("./ExternalClient"));
-__export(require("./HttpClient"));
-__export(require("./InfraClient"));
-__export(require("./IOClient"));
-__export(require("./JanusClient"));
-__export(require("./typings"));
-__export(require("./GraphQLClient"));
-__export(require("./AppGraphQLClient"));
-__export(require("./IOGraphQLClient"));
+__exportStar(require("./HttpClient"), exports);
+__exportStar(require("./typings"), exports);
+__exportStar(require("./GraphQLClient"), exports);
+__exportStar(require("./agents"), exports);
 var cache_1 = require("./middlewares/cache");
-exports.CacheType = cache_1.CacheType;
+Object.defineProperty(exports, "CacheType", { enumerable: true, get: function () { return cache_1.CacheType; } });
 var inflight_1 = require("./middlewares/inflight");
-exports.inflightURL = inflight_1.inflightURL;
-exports.inflightUrlWithQuery = inflight_1.inflightUrlWithQuery;
+Object.defineProperty(exports, "inflightURL", { enumerable: true, get: function () { return inflight_1.inflightURL; } });
+Object.defineProperty(exports, "inflightUrlWithQuery", { enumerable: true, get: function () { return inflight_1.inflightUrlWithQuery; } });

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

@@ -2,7 +2,7 @@
 import { AxiosRequestConfig, AxiosResponse } from 'axios';
 import { CacheLayer } from '../../caches/CacheLayer';
 import { MiddlewareContext, RequestConfig } from '../typings';
-export declare const cacheKey: (config: AxiosRequestConfig<any>) => string;
+export declare const cacheKey: (config: AxiosRequestConfig) => string;
 export declare function isLocallyCacheable(arg: RequestConfig, type: CacheType): arg is CacheableRequestConfig;
 export declare enum CacheType {
     None = 0,
@@ -10,11 +10,17 @@ export declare enum CacheType {
     Disk = 2,
     Any = 3
 }
+export declare const enum CacheResult {
+    HIT = "HIT",
+    MISS = "MISS",
+    STALE = "STALE"
+}
 interface CacheOptions {
     type: CacheType;
     storage: CacheLayer<string, Cached>;
+    asyncSet?: boolean;
 }
-export declare const cacheMiddleware: ({ type, storage }: CacheOptions) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const cacheMiddleware: ({ type, storage, asyncSet }: CacheOptions) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
 export interface Cached {
     etag: string;
     expiration: number;

package/lib/HttpClient/middlewares/cache.js

@@ -1,27 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const url_1 = require("url");
+exports.cacheMiddleware = exports.CacheType = exports.isLocallyCacheable = exports.cacheKey = void 0;
 const constants_1 = require("../../constants");
-const constants_2 = require("./../../constants");
+const tracing_1 = require("../../tracing");
 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_2.LOCALE_HEADER];
-    const fullURL = [baseURL, url].filter(str => str).join('/');
-    const urlObject = new url_1.URL(fullURL);
-    if (headers && headers.range) {
-        urlObject.searchParams.append(RANGE_HEADER_QS_KEY, headers.range);
-    }
+    const locale = headers === null || headers === void 0 ? void 0 : headers[constants_1.LOCALE_HEADER];
+    const encodedBaseURL = baseURL.replace(/\//g, '\\');
+    const encodedURL = url.replace(/\//g, '\\');
+    let key = `${locale}--${encodedBaseURL}--${encodedURL}?`;
     if (params) {
-        for (const [key, value] of Object.entries(params)) {
-            urlObject.searchParams.append(key, value);
-        }
+        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}`);
     }
-    // Replace forward slashes with backwards slashes for disk cache legibility
-    const encodedPath = `${locale}/${urlObject.pathname}${urlObject.search}`.replace(/\//g, '\\\\');
-    // Add hostname as top level directory on disk cache
-    return `${urlObject.hostname}/${encodedPath}`;
+    return key;
 };
 const parseCacheHeaders = (headers) => {
     const { 'cache-control': cacheControl = '', etag, age: ageStr } = headers;
@@ -51,36 +47,80 @@ var CacheType;
     CacheType[CacheType["Disk"] = 2] = "Disk";
     CacheType[CacheType["Any"] = 3] = "Any";
 })(CacheType = exports.CacheType || (exports.CacheType = {}));
-exports.cacheMiddleware = ({ type, storage }) => {
+const CacheTypeNames = {
+    [CacheType.None]: 'none',
+    [CacheType.Memory]: 'memory',
+    [CacheType.Disk]: 'disk',
+    [CacheType.Any]: 'any',
+};
+exports.cacheMiddleware = ({ type, storage, asyncSet }) => {
+    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) => {
+        var _a, _b;
         if (!isLocallyCacheable(ctx.config, type)) {
             return await next();
         }
+        const { rootSpan: span, tracer, logger } = (_a = ctx.tracing) !== null && _a !== void 0 ? _a : {};
         const key = exports.cacheKey(ctx.config);
-        const segmentToken = ctx.config.headers[constants_1.SEGMENT_HEADER];
+        const segmentToken = (_b = ctx.config.headers) === null || _b === void 0 ? void 0 : _b[constants_1.SEGMENT_HEADER];
         const keyWithSegment = key + segmentToken;
-        const cacheHasWithSegment = await storage.has(keyWithSegment);
-        const cached = cacheHasWithSegment ? await storage.get(keyWithSegment) : await storage.get(key);
-        if (cached) {
+        span === null || span === void 0 ? void 0 : 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 cacheReadSpan = createCacheSpan(cacheType, 'read', tracer, span);
+        let cached = undefined;
+        try {
+            const cacheHasWithSegment = await storage.has(keyWithSegment);
+            cached = cacheHasWithSegment ? await storage.get(keyWithSegment) : await storage.get(key);
+        }
+        catch (error) {
+            tracing_1.ErrorReport.create({ originalError: error }).injectOnSpan(cacheReadSpan);
+            logger === null || logger === void 0 ? void 0 : logger.warn({ message: 'Error reading from the HttpClient cache', error });
+        }
+        finally {
+            cacheReadSpan === null || cacheReadSpan === void 0 ? void 0 : cacheReadSpan.finish();
+        }
+        if (cached && cached.response) {
             const { etag: cachedEtag, response, expiration, responseType, responseEncoding } = cached;
-            if (expiration > Date.now() && response) {
-                if (type === CacheType.Disk && responseType === 'arraybuffer') {
-                    response.data = Buffer.from(response.data, responseEncoding);
-                }
+            if (type === CacheType.Disk && responseType === 'arraybuffer') {
+                response.data = Buffer.from(response.data, responseEncoding);
+            }
+            const now = Date.now();
+            span === null || span === void 0 ? void 0 : 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 === null || span === void 0 ? void 0 : span.setTag(CACHE_RESULT_TAG, "HIT" /* HIT */);
                 return;
             }
+            span === null || span === void 0 ? void 0 : 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.headers = {
+                    ...ctx.config.headers,
+                    'if-none-match': cachedEtag
+                };
                 ctx.config.validateStatus = validateStatus;
             }
         }
+        else {
+            span === null || span === void 0 ? void 0 : span.setTag(CACHE_RESULT_TAG, "MISS" /* MISS */);
+        }
         await next();
         if (!ctx.response) {
             return;
@@ -98,28 +138,81 @@ exports.cacheMiddleware = ({ type, storage }) => {
         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 === null || span === void 0 ? void 0 : 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 === null || span === void 0 ? void 0 : 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 } = ctx.config;
+            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;
-            await storage.set(setKey, {
-                etag,
-                expiration: Date.now() + (maxAge - currentAge) * 1000,
-                response: { data: cacheableData, headers, status },
-                responseEncoding,
-                responseType,
-            });
+            const now = Date.now();
+            const expiration = now + (maxAge - currentAge) * 1000;
+            const alreadyExpired = expiration <= now;
+            const reusingRevalidatedCache = cached && (ctx.response === cached.response);
+            const shouldSkipCacheUpdate = alreadyExpired && reusingRevalidatedCache;
+            if (shouldSkipCacheUpdate) {
+                return;
+            }
+            const cacheWriteSpan = createCacheSpan(cacheType, 'write', tracer, span);
+            try {
+                const storageSet = () => storage.set(setKey, {
+                    etag,
+                    expiration,
+                    response: { data: cacheableData, headers, status },
+                    responseEncoding: responseEncoding,
+                    responseType,
+                });
+                if (asyncSet) {
+                    storageSet();
+                }
+                else {
+                    await storageSet();
+                    span === null || span === void 0 ? void 0 : 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,
+                    });
+                }
+            }
+            catch (error) {
+                tracing_1.ErrorReport.create({ originalError: error }).injectOnSpan(cacheWriteSpan);
+                logger === null || logger === void 0 ? void 0 : logger.warn({ message: 'Error writing to the HttpClient cache', error });
+            }
+            finally {
+                cacheWriteSpan === null || cacheWriteSpan === void 0 ? void 0 : cacheWriteSpan.finish();
+            }
             return;
         }
+        span === null || span === void 0 ? void 0 : span.log({ event: "no-local-cache-save" /* NO_LOCAL_CACHE_SAVE */, ["cache-type" /* CACHE_TYPE */]: cacheType });
     };
 };
+const createCacheSpan = (cacheType, operation, tracer, parentSpan) => {
+    if (tracer && tracer.isTraceSampled && cacheType === 'disk') {
+        return tracer.startSpan(`${operation}-disk-cache`, { childOf: parentSpan });
+    }
+};

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

@@ -1,3 +1,3 @@
-import { Cancellation } from '../../service/typings';
+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

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancellationToken = void 0;
 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;
@@ -46,7 +48,7 @@ exports.cancellationToken = (cancellation) => async (ctx, next) => {
     if (!cancellation) {
         return await next();
     }
-    if (method && method.toUpperCase() !== 'GET') {
+    if (method && !constants_1.cancellableMethods.has(method.toUpperCase())) {
         cancellation.cancelable = false;
     }
     if (!cancellation.cancelable || !cancellation.source) {