@vtex/api 6.48.0 → 6.48.1-beta

package/gen/manifest.schema

@@ -110,9 +110,6 @@
                 "email": {
                     "type": "string"
                 },
-                "phone": {
-                    "type": "string"
-                },
                 "url": {
                     "type": "string"
                 }

package/lib/{clients/apps → HttpClient}/AppClient.d.ts

@@ -1,6 +1,6 @@
-import { InstanceOptions } from '../../HttpClient/typings';
-import { IOContext } from '../../service/worker/runtime/typings';
-import { IOClient } from '../IOClient';
+import { IOContext } from '../service/typings';
+import { IOClient } from './IOClient';
+import { InstanceOptions } from './typings';
 /**
  * Used to perform calls on apps you declared a dependency for in your manifest.
  */

package/lib/{clients/apps → HttpClient}/AppClient.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typings_1 = require("../../HttpClient/typings");
-const routes_1 = require("../../service/worker/runtime/http/routes");
-const IOClient_1 = require("../IOClient");
+const IOClient_1 = require("./IOClient");
+const typings_1 = require("./typings");
 const useHttps = !process.env.VTEX_IO;
 /**
  * Used to perform calls on apps you declared a dependency for in your manifest.
@@ -16,19 +15,15 @@ class AppClient extends IOClient_1.IOClient {
         let baseURL;
         if (appVersion) {
             const [major] = appVersion.split('.');
-            baseURL = routes_1.formatPrivateRoute({ account, workspace, vendor, name, major, protocol });
+            baseURL = `${protocol}://app.io.vtex.com/${vendor}.${name}/v${major}/${account}/${workspace}`;
         }
         else {
             console.warn(`${account} in ${workspace} is using old routing for ${app}. Please change vendor.app to vendor.app@major in client ${(options && options.name) || ''}`);
             const service = [name, vendor].join('.'); // messages.vtex
             baseURL = `http://${service}.${region}.vtex.io/${account}/${workspace}`;
         }
-        super(context, {
-            ...options,
-            authType: typings_1.AuthType.bearer,
-            baseURL,
-            name,
-        });
+        super(context, Object.assign({}, options, { authType: typings_1.AuthType.bearer, baseURL,
+            name }));
     }
 }
 exports.AppClient = AppClient;

package/lib/{clients/apps → HttpClient}/AppGraphQLClient.d.ts

@@ -1,6 +1,6 @@
-import { InstanceOptions } from '../../HttpClient/typings';
-import { IOContext } from '../../service/worker/runtime/typings';
-import { IOGraphQLClient } from '../IOGraphQLClient';
+import { IOContext } from '../service/typings';
+import { IOGraphQLClient } from './IOGraphQLClient';
+import { InstanceOptions } from './typings';
 /**
  * Used to perform calls on apps you declared a dependency for in your manifest.
  */

package/lib/{clients/apps → HttpClient}/AppGraphQLClient.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typings_1 = require("../../HttpClient/typings");
-const routes_1 = require("../../service/worker/runtime/http/routes");
-const IOGraphQLClient_1 = require("../IOGraphQLClient");
+const IOGraphQLClient_1 = require("./IOGraphQLClient");
+const typings_1 = require("./typings");
 const useHttps = !process.env.VTEX_IO;
 /**
  * Used to perform calls on apps you declared a dependency for in your manifest.
@@ -16,19 +15,15 @@ class AppGraphQLClient extends IOGraphQLClient_1.IOGraphQLClient {
         let baseURL;
         if (appVersion) {
             const [major] = appVersion.split('.');
-            baseURL = routes_1.formatPrivateRoute({ account, workspace, major, name, vendor, protocol, path: '/_v/graphql' });
+            baseURL = `${protocol}://app.io.vtex.com/${vendor}.${name}/v${major}/${account}/${workspace}/_v/graphql`;
         }
         else {
             console.warn(`${account} in ${workspace} is using old routing for ${app}. Please change vendor.app to vendor.app@major in client ${(options && options.name) || ''}`);
             const service = [name, vendor].join('.'); // messages.vtex
             baseURL = `http://${service}.${region}.vtex.io/${account}/${workspace}/_v/graphql`;
         }
-        super(context, {
-            ...options,
-            authType: typings_1.AuthType.bearer,
-            baseURL,
-            name,
-        });
+        super(context, Object.assign({}, options, { authType: typings_1.AuthType.bearer, baseURL,
+            name }));
     }
 }
 exports.AppGraphQLClient = AppGraphQLClient;

package/lib/{clients/external → HttpClient}/ExternalClient.d.ts

@@ -1,6 +1,6 @@
-import { InstanceOptions } from '../../HttpClient/typings';
-import { IOContext } from '../../service/worker/runtime/typings';
-import { IOClient } from '../IOClient';
+import { IOContext } from '../service/typings';
+import { IOClient } from './IOClient';
+import { InstanceOptions } from './typings';
 /**
  * Used to perform calls to external endpoints for which you have declared outbound access policies in your manifest.
  */

package/lib/{clients/external → HttpClient}/ExternalClient.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const IOClient_1 = require("../IOClient");
+const IOClient_1 = require("./IOClient");
 /**
  * Used to perform calls to external endpoints for which you have declared outbound access policies in your manifest.
  */
@@ -8,14 +8,7 @@ class ExternalClient extends IOClient_1.IOClient {
     constructor(baseURL, context, options) {
         const { authToken } = context;
         const headers = options && options.headers || {};
-        super(context, {
-            ...options,
-            baseURL,
-            headers: {
-                ...headers,
-                'Proxy-Authorization': authToken,
-            },
-        });
+        super(context, Object.assign({}, options, { baseURL, headers: Object.assign({}, headers, { 'Proxy-Authorization': authToken }) }));
     }
 }
 exports.ExternalClient = ExternalClient;

package/lib/HttpClient/GraphQLClient.d.ts

@@ -6,7 +6,6 @@ interface QueryOptions<Variables extends object> {
     variables: Variables;
     inflight?: boolean;
     throwOnError?: boolean;
-    extensions?: Record<string, any>;
 }
 interface MutateOptions<Variables extends object> {
     mutate: string;
@@ -22,7 +21,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, extensions, throwOnError }: QueryOptions<Variables>, config?: RequestConfig) => Promise<GraphQLResponse<Data>>;
+    query: <Data extends Serializable, Variables extends object>({ query, variables, inflight, 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

@@ -14,10 +14,7 @@ const throwOnGraphQLErrors = (message, response) => {
 class GraphQLClient {
     constructor(http) {
         this.http = http;
-        this.query = ({ query, variables, inflight, extensions, throwOnError }, config = {}) => this.http.getWithBody(config.url || '', { query, variables, extensions }, {
-            inflightKey: inflight !== false ? inflight_1.inflightUrlWithQuery : undefined,
-            ...config,
-        })
+        this.query = ({ query, variables, inflight, throwOnError }, config = {}) => this.http.getWithBody(config.url || '', { query, variables }, Object.assign({ 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/worker/runtime/typings';
+import { IOContext } from '../service/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,13 +20,12 @@ 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>>;
+    protected request: (config: RequestConfig) => Promise<AxiosResponse<any, any>>;
     private getConfig;
 }
 export {};

package/lib/HttpClient/HttpClient.js

@@ -9,6 +9,7 @@ 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");
@@ -17,7 +18,6 @@ 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,63 +31,40 @@ class HttpClient {
             return this.request(cacheableConfig);
         };
         this.getWithBody = (url, data, config = {}) => {
-            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,
-                },
-            });
+            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 }) }));
             return this.request(cacheableConfig).then(response => response.data);
         };
         this.getBuffer = (url, config = {}) => {
-            const bufferConfig = { cacheable: cache_1.CacheType.Disk, ...config, url, responseType: 'arraybuffer', transformResponse: noTransforms };
+            const bufferConfig = Object.assign({ cacheable: cache_1.CacheType.Disk }, config, { url, responseType: 'arraybuffer', transformResponse: noTransforms });
             return this.request(bufferConfig);
         };
         this.getStream = (url, config = {}) => {
-            const streamConfig = { ...config, url, responseType: 'stream', transformResponse: noTransforms };
+            const streamConfig = Object.assign({}, config, { url, responseType: 'stream', transformResponse: noTransforms });
             return this.request(streamConfig).then(response => response.data);
         };
         this.put = (url, data, config = {}) => {
-            const putConfig = { ...config, url, data, method: 'put' };
+            const putConfig = Object.assign({}, 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 = { ...config, url, data, method: 'post' };
+            const postConfig = Object.assign({}, config, { url, data, method: 'post' });
             return this.request(postConfig).then(response => response.data);
         };
         this.postRaw = (url, data, config = {}) => {
-            const postConfig = { ...config, url, data, method: 'post' };
+            const postConfig = Object.assign({}, config, { url, data, method: 'post' });
             return this.request(postConfig);
         };
         this.patch = (url, data, config = {}) => {
-            const patchConfig = { ...config, url, data, method: 'patch' };
+            const patchConfig = Object.assign({}, config, { url, data, method: 'patch' });
             return this.request(patchConfig).then(response => response.data);
         };
         this.head = (url, config = {}) => {
-            const headConfig = { ...config, url, method: 'head' };
+            const headConfig = Object.assign({}, config, { url, method: 'head' });
             return this.request(headConfig);
         };
         this.delete = (url, config) => {
-            const deleteConfig = { ...config, url, method: 'delete' };
+            const deleteConfig = Object.assign({}, config, { url, method: 'delete' });
             return this.request(deleteConfig);
         };
         this.request = async (config) => {
@@ -95,51 +72,32 @@ class HttpClient {
             await this.runMiddlewares(context);
             return context.response;
         };
-        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.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.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 = {
-            ...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 = 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);
         if (authType && authToken) {
             headers['Authorization'] = `${authType} ${authToken}`; // tslint:disable-line
         }
         const memoizedCache = new Map();
-        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 }),
+        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),
             inflight_1.singleFlightMiddleware,
             notFound_1.acceptNotFoundMiddleware,
-            ...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 })] : [],
+            ...memoryCache ? [cache_1.cacheMiddleware({ type: cache_1.CacheType.Memory, storage: memoryCache })] : [],
+            ...diskCache ? [cache_1.cacheMiddleware({ type: cache_1.CacheType.Disk, storage: diskCache })] : [],
             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/{clients → HttpClient}/IOClient.d.ts

@@ -1,9 +1,9 @@
-import { IOContext } from '../service/worker/runtime/typings';
-import { HttpClient } from '../HttpClient/HttpClient';
-import { InstanceOptions } from '../HttpClient/typings';
+import { IOContext } from '../service/typings';
+import { HttpClient } from './HttpClient';
+import { InstanceOptions } from './typings';
 export declare type IOClientConstructor = new (context: IOContext, options?: InstanceOptions) => IOClient;
 /**
- * A client that can be instantiated by the Serviceruntime layer.
+ * A client that can be instantiated by the Service runtime layer.
  */
 export declare class IOClient {
     protected context: IOContext;

package/lib/HttpClient/IOClient.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("./HttpClient");
+/**
+ * A client that can be instantiated by the Service runtime layer.
+ */
+class IOClient {
+    constructor(context, options) {
+        this.context = context;
+        this.options = options;
+        this.http = new HttpClient_1.HttpClient(Object.assign({ name: this.constructor.name }, context, options, { metrics: options && options.metrics }));
+    }
+}
+exports.IOClient = IOClient;

package/lib/{clients → HttpClient}/IOGraphQLClient.d.ts

@@ -1,9 +1,9 @@
-import { GraphQLClient } from '../HttpClient/GraphQLClient';
-import { InstanceOptions } from '../HttpClient/typings';
-import { IOContext } from '../service/worker/runtime/typings';
+import { IOContext } from '../service/typings';
+import { GraphQLClient } from './GraphQLClient';
 import { IOClient } from './IOClient';
+import { InstanceOptions } from './typings';
 /**
- * A GraphQL client that can be instantiated by the Serviceruntime layer.
+ * A GraphQL client that can be instantiated by the Service runtime layer.
  */
 export declare class IOGraphQLClient extends IOClient {
     protected context: IOContext;

package/lib/{clients → HttpClient}/IOGraphQLClient.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const GraphQLClient_1 = require("../HttpClient/GraphQLClient");
+const GraphQLClient_1 = require("./GraphQLClient");
 const IOClient_1 = require("./IOClient");
 /**
- * A GraphQL client that can be instantiated by the Serviceruntime layer.
+ * A GraphQL client that can be instantiated by the Service runtime layer.
  */
 class IOGraphQLClient extends IOClient_1.IOClient {
     constructor(context, options) {

package/lib/{clients/infra → HttpClient}/InfraClient.d.ts

@@ -1,6 +1,6 @@
-import { InstanceOptions } from '../../HttpClient/typings';
-import { IOContext } from '../../service/worker/runtime/typings';
-import { IOClient } from '../IOClient';
+import { IOContext } from '../service/typings';
+import { IOClient } from './IOClient';
+import { InstanceOptions } from './typings';
 /**
  * Used to perform calls on infra apps (e.g. sphinx, apps, vbase).
  */

package/lib/{clients/infra → HttpClient}/InfraClient.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../../constants");
-const typings_1 = require("../../HttpClient/typings");
-const IOClient_1 = require("../IOClient");
-const useHttps = !constants_1.IS_IO;
+const IOClient_1 = require("./IOClient");
+const typings_1 = require("./typings");
+const useHttps = !process.env.VTEX_IO;
 /**
  * Used to perform calls on infra apps (e.g. sphinx, apps, vbase).
  */
@@ -24,11 +23,7 @@ class InfraClient extends IOClient_1.IOClient {
             console.warn(`${account} in ${workspace} is using old routing for ${app}. This will stop working soon`);
             baseURL = `http://${app}.${region}.vtex.io${isRoot ? '' : `/${account}/${workspace}`}`;
         }
-        super(context, {
-            ...options,
-            authType: typings_1.AuthType.bearer,
-            baseURL,
-        });
+        super(context, Object.assign({}, options, { authType: typings_1.AuthType.bearer, baseURL }));
     }
 }
 exports.InfraClient = InfraClient;

package/lib/{clients/janus → HttpClient}/JanusClient.d.ts

@@ -1,6 +1,6 @@
-import { InstanceOptions } from '../../HttpClient/typings';
-import { IOContext } from '../../service/worker/runtime/typings';
-import { ExternalClient } from '../external/ExternalClient';
+import { IOContext } from '../service/typings';
+import { ExternalClient } from './ExternalClient';
+import { InstanceOptions } from './typings';
 declare type Environment = 'stable' | 'beta';
 /**
  * Used to perform calls on APIs in the VTEX Janus infrastructure, to which you must declare an outbound policy.

package/lib/{clients/janus → HttpClient}/JanusClient.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ExternalClient_1 = require("../external/ExternalClient");
+const ExternalClient_1 = require("./ExternalClient");
 /**
  * Used to perform calls on APIs in the VTEX Janus infrastructure, to which you must declare an outbound policy.
  *
@@ -18,13 +18,9 @@ class JanusClient extends ExternalClient_1.ExternalClient {
     constructor(context, options, environment) {
         const { account } = context;
         const env = context.janusEnv === 'beta' || environment === 'beta' ? 'beta' : 'stable';
-        super(`http://portal.vtexcommerce${env}.com.br`, context, {
-            ...options,
-            params: {
+        super(`http://portal.vtexcommerce${env}.com.br`, context, Object.assign({}, options, { params: {
                 an: account,
-                ...options === null || options === void 0 ? void 0 : options.params,
-            },
-        });
+            } }));
     }
 }
 exports.JanusClient = JanusClient;

package/lib/HttpClient/factories/index.d.ts

@@ -0,0 +1,8 @@
+import { IOContext } from '../../service/typings';
+import { HttpClient } from '../HttpClient';
+import { InstanceOptions } from '../typings';
+export declare const rootURL: (service: string, { region }: IOContext, { baseURL }: InstanceOptions) => string;
+export declare const workspaceURL: (service: string, context: IOContext, opts: InstanceOptions) => string;
+export declare const forWorkspace: (service: string, context: IOContext, opts: InstanceOptions) => HttpClient;
+export declare const forRoot: (service: string, context: IOContext, opts: InstanceOptions) => HttpClient;
+export declare const forExternal: (baseURL: string, context: IOContext, opts: InstanceOptions) => HttpClient;

package/lib/HttpClient/factories/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+const typings_1 = require("../typings");
+exports.rootURL = (service, { region }, { baseURL }) => {
+    if (baseURL) {
+        return 'http://' + baseURL;
+    }
+    if (region) {
+        return `http://${service}.${region}.vtex.io`;
+    }
+    throw new Error('Missing required: should specify either {region} or {baseURL}');
+};
+exports.workspaceURL = (service, context, opts) => {
+    const { account, workspace } = context;
+    if (!account || !workspace) {
+        throw new Error('Missing required arguments: {account, workspace}');
+    }
+    return exports.rootURL(service, context, opts) + `/${account}/${workspace}`;
+};
+exports.forWorkspace = (service, context, opts) => {
+    const baseURL = exports.workspaceURL(service, context, opts);
+    return new HttpClient_1.HttpClient(Object.assign({}, context, opts, { authType: typings_1.AuthType.bearer, baseURL }));
+};
+exports.forRoot = (service, context, opts) => {
+    const baseURL = exports.rootURL(service, context, opts);
+    return new HttpClient_1.HttpClient(Object.assign({}, context, opts, { authType: typings_1.AuthType.bearer, baseURL }));
+};
+exports.forExternal = (baseURL, context, opts) => {
+    return new HttpClient_1.HttpClient(Object.assign({}, context, opts, { baseURL }));
+};

package/lib/HttpClient/index.d.ts

@@ -1,6 +1,12 @@
+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 './agents';
+export * from './AppGraphQLClient';
+export * from './IOGraphQLClient';
 export { Cached, CacheType } from './middlewares/cache';
 export { inflightURL, inflightUrlWithQuery } from './middlewares/inflight';

package/lib/HttpClient/index.js

@@ -3,10 +3,16 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = 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("./agents"));
+__export(require("./AppGraphQLClient"));
+__export(require("./IOGraphQLClient"));
 var cache_1 = require("./middlewares/cache");
 exports.CacheType = cache_1.CacheType;
 var inflight_1 = require("./middlewares/inflight");

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) => string;
+export declare const cacheKey: (config: AxiosRequestConfig<any>) => string;
 export declare function isLocallyCacheable(arg: RequestConfig, type: CacheType): arg is CacheableRequestConfig;
 export declare enum CacheType {
     None = 0,
@@ -10,17 +10,11 @@ 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, asyncSet }: CacheOptions) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
+export declare const cacheMiddleware: ({ type, storage }: CacheOptions) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
 export interface Cached {
     etag: string;
     expiration: number;