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

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,13 +6,14 @@ interface QueryOptions<Variables extends object> {
     variables: Variables;
     inflight?: boolean;
     throwOnError?: boolean;
+    extensions?: Record<string, any>;
 }
 interface MutateOptions<Variables extends object> {
     mutate: string;
     variables: Variables;
     throwOnError?: boolean;
 }
-export declare type Serializable = object | boolean | string | number;
+export type Serializable = object | boolean | string | number;
 export interface GraphQLResponse<T extends Serializable> {
     data?: T;
     errors?: GraphQLError[];
@@ -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,15 @@
 /// <reference types="node" />
+/// <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>;
+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 +21,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>>;
+    delete: <T = void>(url: string, config?: RequestConfig) => Promise<IOResponse<T>>;
+    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 = (0, 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';
-        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);
+        this.logger = logger;
+        this.cacheableType = cacheableType;
+        this.memoizable = memoizable;
+        const limit = concurrency && concurrency > 0 && (0, p_limit_1.default)(concurrency) || undefined;
+        const headers = {
+            ...defaultHeaders,
+            'Accept-Encoding': 'gzip',
+            'User-Agent': userAgent,
+            ...host ? { [constants_1.FORWARDED_HOST_HEADER]: host } : null,
+            ...tenant ? { [constants_1.TENANT_HEADER]: (0, tenant_1.formatTenantHeaderValue)(tenant) } : null,
+            ...binding ? { [constants_1.BINDING_HEADER]: (0, 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),
-            metrics_1.metricsMiddleware({ metrics, serverTiming, name }),
-            memoization_1.memoizationMiddleware({ memoizedCache }),
-            ...recorder ? [recorder_1.recorderMiddleware(recorder)] : [],
-            cancellationToken_1.cancellationToken(cancellation),
+        this.runMiddlewares = (0, koa_compose_1.default)([
+            (0, tracing_1.createHttpClientTracingMiddleware)({ tracer, logger, clientName: this.name, hasDiskCacheMiddleware: !!diskCache, hasMemoryCacheMiddleware: !!memoryCache }),
+            ...(opts.middlewares || []),
+            (0, request_1.defaultsMiddleware)({ baseURL, rawHeaders: headers, params, timeout, retries, verbose, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent }),
+            (0, metrics_1.metricsMiddleware)({ metrics, serverTiming, name }),
+            (0, memoization_1.memoizationMiddleware)({ memoizedCache }),
+            ...recorder ? [(0, recorder_1.recorderMiddleware)(recorder)] : [],
+            (0, 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 ? [(0, cache_1.cacheMiddleware)({ type: cache_1.CacheType.Memory, storage: memoryCache, asyncSet: asyncSetCache })] : [],
+            ...diskCache ? [(0, cache_1.cacheMiddleware)({ type: cache_1.CacheType.Disk, storage: diskCache, asyncSet: asyncSetCache })] : [],
             notFound_1.notFoundFallbackMiddleware,
             request_1.routerCacheMiddleware,
-            request_1.requestMiddleware(limit),
+            (0, 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,6 @@
+import HttpAgent, { HttpOptions as AgentHttpOptions, HttpsAgent, HttpsOptions as AgentHttpsOptions } from 'agentkeepalive';
+type HttpOptions = Omit<AgentHttpOptions, 'freeSocketTimeout' | 'keepAlive' | 'maxFreeSockets'>;
+export declare const createHttpAgent: (opts?: HttpOptions) => HttpAgent;
+type HttpsOptions = Omit<AgentHttpsOptions, 'freeSocketTimeout' | 'keepAlive' | 'maxFreeSockets'>;
+export declare const createHttpsAgent: (opts?: HttpsOptions) => HttpsAgent;
+export {};

package/lib/HttpClient/agents.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.prototype.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"));
+const createHttpAgent = (opts) => new agentkeepalive_1.default({
+    ...opts,
+    freeSocketTimeout: 30 * 1000,
+    keepAlive: true,
+    maxFreeSockets: 256,
+    socketActiveTTL: 120 * 1000,
+});
+exports.createHttpAgent = createHttpAgent;
+const createHttpsAgent = (opts) => new agentkeepalive_1.HttpsAgent({
+    ...opts,
+    freeSocketTimeout: 30 * 1000,
+    keepAlive: true,
+    maxFreeSockets: 256,
+    socketActiveTTL: 120 * 1000,
+});
+exports.createHttpsAgent = createHttpsAgent;

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,26 @@
 "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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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" && !Object.prototype.hasOwnProperty.call(exports, 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"));
+exports.inflightUrlWithQuery = exports.inflightURL = exports.CacheType = void 0;
+__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;
@@ -22,7 +28,7 @@ export interface Cached {
     responseType?: string;
     responseEncoding?: BufferEncoding;
 }
-export declare type CacheableRequestConfig = RequestConfig & {
+export type CacheableRequestConfig = RequestConfig & {
     url: string;
     cacheable: CacheType;
     memoizable: boolean;