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

package/lib/clients/infra/Assets.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assets = void 0;
+const ramda_1 = require("ramda");
+const HttpClient_1 = require("../../HttpClient");
+const utils_1 = require("../../utils");
+const InfraClient_1 = require("./InfraClient");
+const dependsOnApp = (appsAtMajor) => (a) => {
+    let dependsOn = false;
+    appsAtMajor.forEach(appAtMajor => {
+        const [name, major] = appAtMajor.split('@');
+        const sanitizedMajor = major.includes('.') ? major.split('.')[0] : major;
+        const version = a._resolvedDependencies[name];
+        if (version) {
+            const [depMajor] = version.split('.');
+            if (sanitizedMajor === depMajor) {
+                dependsOn = true;
+            }
+        }
+    });
+    return dependsOn;
+};
+const useBuildJson = (app, appVendorName) => {
+    const buildFeatures = app._buildFeatures;
+    return buildFeatures && buildFeatures[appVendorName] && (0, ramda_1.contains)('build.json', buildFeatures[appVendorName]);
+};
+const appOrRegistry = (workspace, { name, version, build }) => build
+    ? `${workspace}/apps/${name}@${version}+${build}`
+    : `master/registry/${name}/${version}`;
+const createRoutes = (workspace) => ({
+    Bundle: (scope, locator, path) => `/${scope}/${appOrRegistry(workspace, locator)}/bundle/${path}`,
+    Files: (scope, locator, path) => `/${scope}/${appOrRegistry(workspace, locator)}/files/${path}`,
+});
+class Assets extends InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('apps@0.x', context, options, true);
+        this.getAppBundleByVendor = (app, bundlePath, generatePackageJson, tracingConfig) => {
+            const locator = (0, utils_1.parseAppId)(app);
+            const params = generatePackageJson && { _packageJSONEngine: 'npm', _packageJSONFilter: 'vtex.render-builder@x' };
+            const metric = locator.build ? 'apps-get-bundle' : 'registry-get-bundle';
+            return this.http.getStream(this.routes.Bundle(this.context.account, locator, bundlePath), {
+                headers: {
+                    Accept: 'application/x-gzip',
+                    'Accept-Encoding': 'gzip',
+                },
+                metric,
+                params,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppJSONByAccount = (app, path, nullIfNotFound, tracingConfig) => {
+            const locator = (0, utils_1.parseAppId)(app);
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'assets-get-json-by-account';
+            return this.http.get(this.routes.Files(this.context.account, locator, path), {
+                cacheable: HttpClient_1.CacheType.Memory,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppJSONByVendor = (app, path, nullIfNotFound, tracingConfig) => {
+            const locator = (0, utils_1.parseAppId)(app);
+            const vendor = locator.name.split('.')[0];
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'assets-get-json-by-vendor';
+            return this.http.get(this.routes.Files(vendor, locator, path), {
+                cacheable: HttpClient_1.CacheType.Any,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppFileByAccount = (app, path, nullIfNotFound, tracingConfig) => {
+            const locator = (0, utils_1.parseAppId)(app);
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'assets-get-file-by-account';
+            return this.http.getBuffer(this.routes.Files(this.context.account, locator, path), {
+                cacheable: HttpClient_1.CacheType.Any,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppFileByVendor = (app, path, nullIfNotFound, tracingConfig) => {
+            const locator = (0, utils_1.parseAppId)(app);
+            const vendor = locator.name.split('.')[0];
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'assets-get-file-by-vendor';
+            return this.http.getBuffer(this.routes.Files(vendor, locator, path), {
+                cacheable: HttpClient_1.CacheType.Any,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.routes = createRoutes(this.context.workspace);
+    }
+    getSettings(dependencies, appAtMajor, params = {}, tracingConfig) {
+        const { pick, files } = params;
+        const filtered = this.getFilteredDependencies(appAtMajor, dependencies);
+        return Promise.all(filtered.map(dependency => {
+            const [appVendorName] = appAtMajor.split('@');
+            const buildJson = useBuildJson(dependency, appVendorName);
+            return buildJson
+                ? this.getBuildJSONForApp(dependency, appVendorName, pick, tracingConfig)
+                : this.getSettingsFromFilesForApp(dependency, files, tracingConfig);
+        }));
+    }
+    async getBuildJSONForApp(app, appVendorName, pick = [], tracingConfig) {
+        const pickArray = Array.isArray(pick) ? pick : [pick];
+        const buildJson = await this.getJSON(app.id, `dist/${appVendorName}/build.json`, undefined, tracingConfig);
+        const result = !(0, ramda_1.isEmpty)(pickArray) ? (0, ramda_1.pick)(pickArray, buildJson) : buildJson;
+        result.declarer = app.id;
+        return result;
+    }
+    async getSettingsFromFilesForApp(app, files = [], tracingConfig) {
+        // If there's no support for build.json, then fetch individual files and zip them into an {[file]: content} object.
+        const filesArray = Array.isArray(files) ? files : [files];
+        const fetched = await Promise.all(filesArray.map(file => this.getJSON(app.id, file, true, tracingConfig)));
+        const result = (0, ramda_1.zipObj)(filesArray, fetched);
+        result.declarer = app.id;
+        return result;
+    }
+    async getJSON(appId, file, nullIfNotFound, tracingConfig) {
+        const locator = (0, utils_1.parseAppId)(appId);
+        const linked = !!locator.build;
+        if (linked) {
+            return this.getAppJSONByAccount(appId, file, nullIfNotFound, tracingConfig);
+        }
+        return this.getAppJSONByVendor(appId, file, nullIfNotFound, tracingConfig);
+    }
+    async getFile(appId, file, nullIfNotFound, tracingConfig) {
+        const locator = (0, utils_1.parseAppId)(appId);
+        const linked = !!locator.build;
+        if (linked) {
+            return this.getAppFileByAccount(appId, file, nullIfNotFound, tracingConfig);
+        }
+        return this.getAppFileByVendor(appId, file, nullIfNotFound, tracingConfig);
+    }
+    getFilteredDependencies(apps, dependencies) {
+        const appsAtMajor = typeof (apps) === 'string' ? [apps] : apps;
+        const depends = dependsOnApp(appsAtMajor);
+        return (0, ramda_1.filter)(depends, dependencies);
+    }
+}
+exports.Assets = Assets;

package/lib/clients/infra/BillingMetrics.d.ts

@@ -0,0 +1,13 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class BillingMetrics extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    sendMetric: (metric: BillingMetric, tracingConfig?: RequestTracingConfig) => Promise<BillingMetric>;
+}
+export interface BillingMetric {
+    value: number;
+    unit: string;
+    metricId: string;
+    timestamp?: number;
+}

package/lib/clients/infra/BillingMetrics.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BillingMetrics = void 0;
+const InfraClient_1 = require("./InfraClient");
+class BillingMetrics extends InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('colossus@0.x', context, options);
+        this.sendMetric = (metric, tracingConfig) => {
+            return this.http.post('/metrics', metric, { tracing: {
+                    requestSpanNameSuffix: 'send-metric',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+    }
+}
+exports.BillingMetrics = BillingMetrics;

package/lib/clients/infra/Events.d.ts

@@ -0,0 +1,12 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class Events extends InfraClient {
+    constructor({ recorder, ...context }: IOContext, options?: InstanceOptions);
+    sendEvent: (appIdOrResource: string | ResourceVRN, route: string, message?: any, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    private resourceFor;
+}
+export interface ResourceVRN {
+    service: string;
+    path: string;
+}

package/lib/clients/infra/Events.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Events = void 0;
+const util_1 = require("util");
+const InfraClient_1 = require("./InfraClient");
+const ANY_APP = '';
+const eventRoute = (route) => `/events/${route}`;
+const isResourceVRN = (appIdOrResource) => (0, util_1.isObject)(appIdOrResource) && !(0, util_1.isNullOrUndefined)(appIdOrResource.service);
+class Events extends InfraClient_1.InfraClient {
+    constructor({ recorder, ...context }, options) {
+        super('courier@0.x', context, options);
+        this.sendEvent = (appIdOrResource, route, message, tracingConfig) => {
+            const resource = this.resourceFor(appIdOrResource);
+            return this.http.put(eventRoute(route), message, {
+                metric: 'events-send',
+                params: { resource },
+                tracing: {
+                    requestSpanNameSuffix: 'events-send',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.resourceFor = (appIdOrResource) => {
+            if (appIdOrResource === ANY_APP) {
+                return ANY_APP;
+            }
+            const { service, path } = isResourceVRN(appIdOrResource)
+                ? appIdOrResource
+                : { service: 'apps', path: `/apps/${appIdOrResource}` };
+            return `vrn:${service}:${this.context.region}:${this.context.account}:${this.context.workspace}:${path}`;
+        };
+    }
+}
+exports.Events = Events;

package/lib/clients/infra/Housekeeper.d.ts

@@ -0,0 +1,10 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { HousekeeperStatesAndUpdates } from '../../responses';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class Housekeeper extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    apply: (data: HousekeeperStatesAndUpdates, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    perform: (tracingConfig?: RequestTracingConfig) => Promise<void>;
+    resolve: (tracingConfig?: RequestTracingConfig) => Promise<HousekeeperStatesAndUpdates>;
+}

package/lib/clients/infra/Housekeeper.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Housekeeper = void 0;
+const InfraClient_1 = require("./InfraClient");
+class Housekeeper extends InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('housekeeper@0.x', context, options);
+        this.apply = async (data, tracingConfig) => {
+            const metric = 'housekeeper-apply';
+            return this.http.post('v2/housekeeping/apply', data, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.perform = async (tracingConfig) => {
+            const metric = 'housekeeper-perform';
+            return this.http.post('v2/_housekeeping/perform', {}, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.resolve = async (tracingConfig) => {
+            const metric = 'housekeeper-resolve';
+            return this.http.get('v2/housekeeping/resolve', { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+    }
+}
+exports.Housekeeper = Housekeeper;

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

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

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

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const IOClient_1 = require("./IOClient");
-const typings_1 = require("./typings");
-const useHttps = !process.env.VTEX_IO;
+exports.InfraClient = void 0;
+const constants_1 = require("../../constants");
+const typings_1 = require("../../HttpClient/typings");
+const IOClient_1 = require("../IOClient");
+const useHttps = !constants_1.IS_IO;
 /**
  * Used to perform calls on infra apps (e.g. sphinx, apps, vbase).
  */
@@ -23,7 +25,11 @@ 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, Object.assign({}, options, { authType: typings_1.AuthType.bearer, baseURL }));
+        super(context, {
+            ...options,
+            authType: typings_1.AuthType.bearer,
+            baseURL,
+        });
     }
 }
 exports.InfraClient = InfraClient;

package/lib/clients/infra/Registry.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable, Writable } from 'stream';
+import { ZlibOptions } from 'zlib';
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { AppFilesList, AppManifest, AppState } from '../../responses';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class Registry extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    getAppState: (app: string, version: string, tracingConfig?: RequestTracingConfig) => Promise<AppState>;
+    publishApp: (files: File[], tag?: string, { zlib }?: ZipOptions, tracingConfig?: RequestTracingConfig) => Promise<import("../../responses").AppBundleResponse & {
+        bundleSize?: number | undefined;
+    }>;
+    publishAppRc: (files: File[], tag?: string, { zlib }?: ZipOptions, tracingConfig?: RequestTracingConfig) => Promise<import("../../responses").AppBundleResponse & {
+        bundleSize?: number | undefined;
+    }>;
+    listApps: (tracingConfig?: RequestTracingConfig) => Promise<RegistryAppsList>;
+    listVersionsByApp: (app: string, tracingConfig?: RequestTracingConfig) => Promise<RegistryAppVersionsList>;
+    deprecateApp: (app: string, version: string, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    undeprecateApp: (app: string, version: string, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    validateApp: (app: string, version: string, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    getAppManifest: (app: string, version: string, opts?: AppsManifestOptions, tracingConfig?: RequestTracingConfig) => Promise<AppManifest>;
+    listAppFiles: (app: string, version: string, opts?: ListAppFilesOptions, tracingConfig?: RequestTracingConfig) => Promise<AppFilesList>;
+    getAppFile: (app: string, version: string, path: string, tracingConfig?: RequestTracingConfig) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getAppJSON: <T extends object | null>(app: string, version: string, path: string, nullIfNotFound?: boolean, tracingConfig?: RequestTracingConfig) => Promise<T>;
+    getAppFileStream: (app: string, version: string, path: string, tracingConfig?: RequestTracingConfig) => Promise<IncomingMessage>;
+    getAppBundle: (app: string, version: string, bundlePath: string, generatePackageJson: boolean, tracingConfig?: RequestTracingConfig) => Promise<Readable>;
+    unpackAppBundle: (app: string, version: string, bundlePath: string, unpackPath: string, generatePackageJson: boolean, tracingConfig?: RequestTracingConfig) => Promise<Writable>;
+    resolveDependenciesWithManifest: (manifest: AppManifest, filter?: string, tracingConfig?: RequestTracingConfig) => Promise<Record<string, string[]>>;
+    private publish;
+}
+interface ZipOptions {
+    zlib?: ZlibOptions;
+}
+export interface AppsManifestOptions {
+    resolveDeps: boolean;
+}
+export interface ListAppFilesOptions {
+    prefix: string;
+}
+export interface RegistryAppsListItem {
+    partialIdentifier: string;
+    location: string;
+}
+export interface RegistryAppsList {
+    data: RegistryAppsListItem[];
+}
+export interface RegistryAppVersionsListItem {
+    versionIdentifier: string;
+    location: string;
+}
+export interface RegistryAppVersionsList {
+    data: RegistryAppVersionsListItem[];
+}
+export interface File {
+    path: string;
+    content: any;
+}
+export {};

package/lib/clients/infra/Registry.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Registry = void 0;
+const archiver_1 = __importDefault(require("archiver"));
+const tar_fs_1 = require("tar-fs");
+const zlib_1 = require("zlib");
+const constants_1 = require("../../constants");
+const HttpClient_1 = require("../../HttpClient");
+const InfraClient_1 = require("./InfraClient");
+const EMPTY_OBJECT = {};
+const routes = {
+    App: (app) => `${routes.Registry}/${app}`,
+    AppBundle: (app, version, path) => {
+        return path ? `${routes.AppVersion(app, version)}/bundle/${path}` : `${routes.AppVersion(app, version)}/bundle`;
+    },
+    AppFile: (app, version, path) => `${routes.AppFiles(app, version)}/${path}`,
+    AppFiles: (app, version) => `${routes.AppVersion(app, version)}/files`,
+    AppState: (app, version) => `${routes.AppVersion(app, version)}/state`,
+    AppVersion: (app, version) => `${routes.App(app)}/${version}`,
+    Publish: '/v2/registry',
+    PublishRc: '/v2/registry/rc',
+    Registry: '/registry',
+    ResolveDependenciesWithManifest: '/v2/registry/_resolve',
+};
+class Registry extends InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('apps@0.x', { ...context, workspace: constants_1.DEFAULT_WORKSPACE }, options);
+        this.getAppState = (app, version, tracingConfig) => {
+            const metric = 'registry-app-state';
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            return this.http.get(routes.AppState(app, version), {
+                inflightKey,
+                metric,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.publishApp = (files, tag, { zlib } = {}, tracingConfig) => {
+            return this.publish(routes.Publish, files, tag, { zlib }, tracingConfig);
+        };
+        this.publishAppRc = (files, tag, { zlib } = {}, tracingConfig) => {
+            return this.publish(routes.PublishRc, files, tag, { zlib }, tracingConfig);
+        };
+        this.listApps = (tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'registry-list';
+            return this.http.get(routes.Registry, { inflightKey, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.listVersionsByApp = (app, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'registry-list-versions';
+            return this.http.get(routes.App(app), { inflightKey, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.deprecateApp = (app, version, tracingConfig) => {
+            const metric = 'registry-deprecate';
+            return this.http.patch(routes.AppVersion(app, version), { patchState: 'deprecate' }, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.undeprecateApp = (app, version, tracingConfig) => {
+            const metric = 'registry-undeprecate';
+            return this.http.patch(routes.AppVersion(app, version), { patchState: 'undeprecate' }, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.validateApp = (app, version, tracingConfig) => {
+            const metric = 'registry-validate';
+            return this.http.patch(routes.AppVersion(app, version), { patchState: 'validate' }, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getAppManifest = (app, version, opts, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            const params = opts;
+            const metric = 'registry-manifest';
+            return this.http.get(routes.AppVersion(app, version), { inflightKey, metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.listAppFiles = (app, version, opts, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            const params = opts;
+            const metric = 'registry-list-files';
+            return this.http.get(routes.AppFiles(app, version), { inflightKey, metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getAppFile = (app, version, path, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'registry-get-file';
+            return this.http.getBuffer(routes.AppFile(app, version, path), {
+                cacheable: HttpClient_1.CacheType.Disk,
+                inflightKey,
+                metric,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppJSON = (app, version, path, nullIfNotFound, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'registry-get-json';
+            return this.http.get(routes.AppFile(app, version, path), {
+                cacheable: HttpClient_1.CacheType.Any,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppFileStream = (app, version, path, tracingConfig) => {
+            const metric = 'registry-get-file-s';
+            return this.http.getStream(routes.AppFile(app, version, path), {
+                metric,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppBundle = (app, version, bundlePath, generatePackageJson, tracingConfig) => {
+            const params = generatePackageJson && { _packageJSONEngine: 'npm', _packageJSONFilter: 'vtex.render-builder@x' };
+            const metric = 'registry-get-bundle';
+            return this.http.getStream(routes.AppBundle(app, version, bundlePath), {
+                headers: {
+                    Accept: 'application/x-gzip',
+                    'Accept-Encoding': 'gzip',
+                },
+                metric,
+                params,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.unpackAppBundle = (app, version, bundlePath, unpackPath, generatePackageJson, tracingConfig) => {
+            return this.getAppBundle(app, version, bundlePath, generatePackageJson, tracingConfig)
+                .then(stream => stream
+                .pipe((0, zlib_1.createGunzip)())
+                .pipe((0, tar_fs_1.extract)(unpackPath)));
+        };
+        this.resolveDependenciesWithManifest = (manifest, filter = '', tracingConfig) => {
+            const params = { filter };
+            const metric = 'registry-resolve-deps';
+            return this.http.post(routes.ResolveDependenciesWithManifest, manifest, { metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.publish = async (route, files, tag, { zlib } = {}, tracingConfig) => {
+            if (!(files[0] && files[0].path && files[0].content)) {
+                throw new Error('Argument files must be an array of {path, content}, where content can be a String, a Buffer or a ReadableStream.');
+            }
+            const indexOfManifest = files.findIndex(({ path }) => path === 'manifest.json');
+            if (indexOfManifest === -1) {
+                throw new Error('No manifest.json file found in files.');
+            }
+            const zip = (0, archiver_1.default)('zip', { zlib });
+            // Throw stream errors so they reject the promise chain.
+            zip.on('error', (e) => {
+                throw e;
+            });
+            const metric = 'registry-publish';
+            const request = this.http.post(route, zip, {
+                headers: { 'Content-Type': 'application/zip' },
+                metric,
+                params: tag ? { tag } : EMPTY_OBJECT,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+            files.forEach(({ content, path }) => zip.append(content, { name: path }));
+            const finalize = zip.finalize();
+            try {
+                const [response] = await Promise.all([request, finalize]);
+                response.bundleSize = zip.pointer();
+                return response;
+            }
+            catch (e) {
+                // See Apps.ts `link` method for more information on this cast
+                e.bundleSize = zip.pointer();
+                throw e;
+            }
+        };
+    }
+}
+exports.Registry = Registry;

package/lib/clients/infra/Router.d.ts

@@ -0,0 +1,34 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class Router extends InfraClient {
+    constructor(ioContext: IOContext, opts?: InstanceOptions);
+    listAvailableIoVersions: (tracingConfig?: RequestTracingConfig) => Promise<AvaiableIO[]>;
+    getInstalledIoVersion: (tracingConfig?: RequestTracingConfig) => Promise<AvaiableIO>;
+    installIo: (version: string, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    listAvailableServices: (tracingConfig?: RequestTracingConfig) => Promise<AvailableServices>;
+    getAvailableVersions: (name: string, tracingConfig?: RequestTracingConfig) => Promise<AvailableServiceVersions>;
+    listInstalledServices: (tracingConfig?: RequestTracingConfig) => Promise<InstalledService[]>;
+    installService: (name: string, version: string, tracingConfig?: RequestTracingConfig) => Promise<void>;
+}
+export interface AvaiableIO {
+    version: string;
+    tested: boolean;
+    services: {
+        [service: string]: string;
+    };
+}
+export type InstalledIO = AvaiableIO;
+export interface AvailableServiceVersions {
+    versions: {
+        [region: string]: string[];
+    };
+}
+export interface AvailableServices {
+    [service: string]: AvailableServiceVersions;
+}
+export interface InstalledService {
+    name: string;
+    version: string;
+    serviceIsolation: number;
+}