@vtex/api 6.47.0 → 6.48.1-beta

package/lib/clients/Logger.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+const error_1 = require("../utils/error");
+const DEFAULT_SUBJECT = '-';
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["Debug"] = "debug";
+    LogLevel["Info"] = "info";
+    LogLevel["Warn"] = "warn";
+    LogLevel["Error"] = "error";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+class Logger extends HttpClient_1.InfraClient {
+    constructor(context, options) {
+        super('colossus@0.x', Object.assign({}, context, { recorder: undefined }), Object.assign({}, options, { concurrency: 1 }));
+        this.debug = (message, subject = DEFAULT_SUBJECT) => this.sendLog(subject, message, LogLevel.Debug);
+        this.info = (message, subject = DEFAULT_SUBJECT) => this.sendLog(subject, message, LogLevel.Info);
+        this.warn = (warning, subject = DEFAULT_SUBJECT) => this.sendLog(subject, error_1.cleanError(warning), LogLevel.Warn);
+        this.error = (error, subject = DEFAULT_SUBJECT) => this.sendLog(subject, error_1.cleanError(error), LogLevel.Error);
+        this.sendLog = (_, message, level) => {
+            // Use stdout logger
+            if (this.logger) {
+                this.logger.log(message, level);
+            }
+            // Deprecate logging to colossus
+            console.warn('Logger in ctx.clients.logger is deprecated, please use ctx.vtex.logger instead.');
+            return Promise.resolve();
+        };
+        this.logger = context.logger;
+    }
+}
+exports.Logger = Logger;

package/lib/clients/Messages.d.ts

@@ -0,0 +1,18 @@
+import { AppClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+import { IOMessage } from '../utils/message';
+interface Locale {
+    [token: string]: string;
+}
+interface Locales {
+    [lang: string]: Locale;
+}
+interface LocalesByProvider {
+    [provider: string]: Locales;
+}
+export declare class Messages extends AppClient {
+    constructor(vtex: IOContext, options?: InstanceOptions);
+    translate: (to: string, data: IOMessage[]) => Promise<string[]>;
+    saveTranslation: (data: LocalesByProvider) => Promise<void>;
+}
+export {};

package/lib/clients/Messages.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+class Messages extends HttpClient_1.AppClient {
+    constructor(vtex, options) {
+        super('vtex.messages@1.x', vtex, options);
+        this.translate = (to, data) => this.http.get('/_v/translations', {
+            inflightKey: HttpClient_1.inflightUrlWithQuery,
+            metric: 'messages-translate',
+            params: {
+                data: JSON.stringify(data),
+                to,
+            },
+        });
+        this.saveTranslation = (data) => this.http.post('/_v/translations', data, {
+            metric: 'messages-save-translation',
+        });
+    }
+}
+exports.Messages = Messages;

package/lib/clients/MessagesGraphQL.d.ts

@@ -0,0 +1,63 @@
+import { AppGraphQLClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+import { IOMessage } from '../utils/message';
+declare type IOMessageInput = Pick<IOMessage, 'id' | 'content' | 'description' | 'behavior'>;
+export interface IndexedMessageV2 {
+    messages: IOMessageInputV2[];
+    from: string;
+}
+export interface IOMessageInputV2 {
+    content: string;
+    context?: string;
+    behavior?: Behavior;
+    withAppsMetaInfo?: boolean;
+}
+export declare type Behavior = 'FULL' | 'USER_ONLY' | 'USER_AND_APP';
+export interface IOMessageV2 extends IOMessageInputV2 {
+    from: string;
+    to: string;
+}
+interface MessagesInput {
+    provider: string;
+    messages: IOMessageInput[];
+}
+export interface IOMessageSaveInput extends IOMessageInput {
+    content: string;
+}
+export interface MessageSaveInputV2 {
+    srcLang: string;
+    srcMessage: string;
+    context?: string;
+    targetMessage: string;
+    groupContext?: string;
+}
+export interface Translate {
+    messages: MessagesInput[];
+    from?: string;
+    to: string;
+}
+export interface TranslateInputV2 {
+    indexedByFrom: IndexedMessageV2[];
+    to: string;
+    depTree?: string;
+}
+export interface SaveArgs {
+    to: string;
+    messagesByProvider: Array<{
+        messages: IOMessageSaveInput[];
+        provider: string;
+    }>;
+}
+export interface SaveArgsV2 {
+    fireEvent?: boolean;
+    to: string;
+    messages: MessageSaveInputV2[];
+}
+export declare class MessagesGraphQL extends AppGraphQLClient {
+    constructor(vtex: IOContext, options?: InstanceOptions);
+    translate: (args: Translate) => Promise<string[]>;
+    translateV2: (args: TranslateInputV2) => Promise<string[]>;
+    save: (args: SaveArgs) => Promise<boolean>;
+    saveV2: (args: SaveArgsV2) => Promise<boolean>;
+}
+export {};

package/lib/clients/MessagesGraphQL.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const HttpClient_1 = require("../HttpClient");
+class MessagesGraphQL extends HttpClient_1.AppGraphQLClient {
+    constructor(vtex, options) {
+        super('vtex.messages@1.x', vtex, options);
+        this.translate = async (args) => this.graphql.query({
+            query: `
+    query Translate($args: NewTranslateArgs!) {
+      newTranslate(args: $args)
+    }
+    `,
+            variables: { args },
+        }, {
+            metric: 'messages-translate',
+        }).then(ramda_1.path(['data', 'newTranslate']));
+        this.translateV2 = (args) => this.graphql.query({
+            query: `
+      query Translate($args: TranslateArgs!) {
+        translate(args: $args)
+      }
+      `,
+            variables: { args },
+        }, {
+            metric: 'messages-translate-v2',
+        }).then(ramda_1.path(['data', 'translate']));
+        this.save = (args) => this.graphql.mutate({
+            mutate: `
+    mutation Save($args: SaveArgs!) {
+      save(args: $args)
+    }
+    `,
+            variables: { args },
+        }, {
+            metric: 'messages-save-translation',
+        }).then(ramda_1.path(['data', 'save']));
+        this.saveV2 = (args) => this.graphql.mutate({
+            mutate: `
+    mutation SaveV2($args: SaveArgsV2!) {
+      saveV2(args: $args)
+    }
+    `,
+            variables: { args },
+        }, {
+            metric: 'messages-saveV2-translation',
+        }).then(ramda_1.path(['data', 'saveV2']));
+    }
+}
+exports.MessagesGraphQL = MessagesGraphQL;

package/lib/clients/Metadata.d.ts

@@ -0,0 +1,25 @@
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { BucketMetadata } from '../responses';
+import { IOContext } from '../service/typings';
+export interface MetadataEntry {
+    Key: string;
+    Hash: string;
+    Value: any;
+}
+export interface MetadataEntryList {
+    Data: MetadataEntry[];
+    Next: string;
+}
+export declare class Metadata extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    getBuckets: (bucket: string) => Promise<BucketMetadata>;
+    list: (bucket: string, includeValue: boolean, limit?: number | undefined, nextMarker?: string | undefined) => Promise<MetadataEntryList>;
+    listAll: (bucket: string, includeValue: boolean) => Promise<MetadataEntryList>;
+    get: (bucket: string, key: string) => Promise<any>;
+    save: (bucket: string, key: string, data: any) => Promise<void>;
+    saveAll: (bucket: string, data: {
+        [key: string]: any;
+    }) => Promise<void>;
+    delete: (bucket: string, key: string) => Promise<import("../HttpClient").IOResponse<void>>;
+    deleteAll: (bucket: string) => Promise<import("../HttpClient").IOResponse<void>>;
+}

package/lib/clients/Metadata.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+const appId = process.env.VTEX_APP_ID;
+const [runningAppName] = appId ? appId.split('@') : [''];
+const routes = {
+    Bucket: (bucket) => `/buckets/${runningAppName}/${bucket}`,
+    Metadata: (bucket) => `${routes.Bucket(bucket)}/metadata`,
+    MetadataKey: (bucket, key) => `${routes.Metadata(bucket)}/${key}`,
+};
+class Metadata extends HttpClient_1.InfraClient {
+    constructor(context, options) {
+        super('router', context, options);
+        this.getBuckets = (bucket) => {
+            return this.http.get(routes.Bucket(bucket), { metric: 'meta-get-buckets' });
+        };
+        this.list = (bucket, includeValue, limit, nextMarker) => {
+            const query = { value: includeValue, _limit: 10 };
+            if (limit && limit > 0) {
+                query._limit = limit;
+            }
+            if (nextMarker) {
+                query._marker = nextMarker;
+            }
+            const metric = 'meta-list';
+            return this.http.get(routes.Metadata(bucket), { params: query, metric });
+        };
+        this.listAll = (bucket, includeValue) => {
+            const query = { value: includeValue, _limit: 1000 };
+            const metric = 'meta-list-all';
+            return this.http.get(routes.Metadata(bucket), { params: query, metric });
+        };
+        this.get = (bucket, key) => {
+            return this.http.get(routes.MetadataKey(bucket, key), { metric: 'meta-get' });
+        };
+        this.save = (bucket, key, data) => {
+            return this.http.put(routes.MetadataKey(bucket, key), data, { metric: 'meta-save' });
+        };
+        this.saveAll = (bucket, data) => {
+            return this.http.put(routes.Metadata(bucket), data, { metric: 'meta-save-all' });
+        };
+        this.delete = (bucket, key) => {
+            return this.http.delete(routes.MetadataKey(bucket, key), { metric: 'meta-delete' });
+        };
+        this.deleteAll = (bucket) => {
+            return this.http.delete(routes.Metadata(bucket), { metric: 'meta-delete-all' });
+        };
+        if (runningAppName === '') {
+            throw new Error(`Invalid path to access Metadata. Variable VTEX_APP_ID is not available.`);
+        }
+    }
+}
+exports.Metadata = Metadata;

package/lib/clients/Registry.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable, Writable } from 'stream';
+import { ZlibOptions } from 'zlib';
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { AppBundlePublished, AppFilesList, AppManifest } from '../responses';
+import { IOContext } from '../service/typings';
+export interface QueryStringInfo {
+    name: string;
+    value: boolean;
+}
+export declare class Registry extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    publishApp: (files: File[], tag?: string | undefined, { zlib }?: ZipOptions) => Promise<AppBundlePublished>;
+    publishAppRc: (files: File[], tag?: string | undefined, { zlib }?: ZipOptions) => Promise<AppBundlePublished>;
+    listApps: () => Promise<RegistryAppsList>;
+    listVersionsByApp: (app: string) => Promise<RegistryAppVersionsList>;
+    deprecateApp: (app: string, version: string) => Promise<void>;
+    undeprecateApp: (app: string, version: string) => Promise<void>;
+    validateApp: (app: string, version: string, appQueryString?: QueryStringInfo | undefined) => Promise<void>;
+    getAppManifest: (app: string, version: string, opts?: AppsManifestOptions | undefined) => Promise<AppManifest>;
+    listAppFiles: (app: string, version: string, opts?: ListAppFilesOptions | undefined) => Promise<AppFilesList>;
+    getAppFile: (app: string, version: string, path: string) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getAppJSON: <T extends object | null>(app: string, version: string, path: string, nullIfNotFound?: boolean | undefined) => Promise<T>;
+    getAppFileStream: (app: string, version: string, path: string) => Promise<IncomingMessage>;
+    getAppBundle: (app: string, version: string, bundlePath: string, generatePackageJson: boolean) => Promise<Readable>;
+    unpackAppBundle: (app: string, version: string, bundlePath: string, unpackPath: string, generatePackageJson: boolean) => Promise<Writable>;
+    resolveDependenciesWithManifest: (manifest: AppManifest, filter?: string) => 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 → Registry.js}

@@ -6,9 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 constants_1 = require("../constants");
+const HttpClient_1 = require("../HttpClient");
 const EMPTY_OBJECT = {};
 const routes = {
     App: (app) => `${routes.Registry}/${app}`,
@@ -17,103 +16,66 @@ const routes = {
     },
     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`,
+    AppQueryString: (basePath, appQueryString) => appQueryString ? `${basePath}?${appQueryString.name}=${appQueryString.value}` : basePath,
     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 {
+class Registry extends HttpClient_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);
+        super('apps@0.x', Object.assign({}, context, { workspace: constants_1.DEFAULT_WORKSPACE }), options);
+        this.publishApp = (files, tag, { zlib } = {}) => {
+            return this.publish(routes.Publish, files, tag, { zlib });
         };
-        this.publishAppRc = (files, tag, { zlib } = {}, tracingConfig) => {
-            return this.publish(routes.PublishRc, files, tag, { zlib }, tracingConfig);
+        this.publishAppRc = (files, tag, { zlib } = {}) => {
+            return this.publish(routes.PublishRc, files, tag, { zlib });
         };
-        this.listApps = (tracingConfig) => {
+        this.listApps = () => {
             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,
-                } });
+            return this.http.get(routes.Registry, { metric, inflightKey });
         };
-        this.listVersionsByApp = (app, tracingConfig) => {
+        this.listVersionsByApp = (app) => {
             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,
-                } });
+            return this.http.get(routes.App(app), { metric, inflightKey });
         };
-        this.deprecateApp = (app, version, tracingConfig) => {
+        this.deprecateApp = (app, version) => {
             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,
-                } });
+            return this.http.patch(routes.AppVersion(app, version), { patchState: 'deprecate' }, { metric });
         };
-        this.undeprecateApp = (app, version, tracingConfig) => {
+        this.undeprecateApp = (app, version) => {
             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,
-                } });
+            return this.http.patch(routes.AppVersion(app, version), { patchState: 'undeprecate' }, { metric });
         };
-        this.validateApp = (app, version, tracingConfig) => {
+        this.validateApp = (app, version, appQueryString) => {
             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,
-                } });
+            return this.http.patch(routes.AppQueryString(routes.AppVersion(app, version), appQueryString), { patchState: 'validate' }, { metric });
         };
-        this.getAppManifest = (app, version, opts, tracingConfig) => {
+        this.getAppManifest = (app, version, opts) => {
             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,
-                } });
+            return this.http.get(routes.AppVersion(app, version), { params, metric, inflightKey });
         };
-        this.listAppFiles = (app, version, opts, tracingConfig) => {
+        this.listAppFiles = (app, version, opts) => {
             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,
-                } });
+            return this.http.get(routes.AppFiles(app, version), { params, metric, inflightKey });
         };
-        this.getAppFile = (app, version, path, tracingConfig) => {
+        this.getAppFile = (app, version, path) => {
             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) => {
+        this.getAppJSON = (app, version, path, nullIfNotFound) => {
             const inflightKey = HttpClient_1.inflightURL;
             const metric = 'registry-get-json';
             return this.http.get(routes.AppFile(app, version, path), {
@@ -121,23 +83,12 @@ class Registry extends InfraClient_1.InfraClient {
                 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.getAppFileStream = (app, version, path) => {
+            return this.http.getStream(routes.AppFile(app, version, path), { metric: 'registry-get-file-s' });
         };
-        this.getAppBundle = (app, version, bundlePath, generatePackageJson, tracingConfig) => {
+        this.getAppBundle = (app, version, bundlePath, generatePackageJson) => {
             const params = generatePackageJson && { _packageJSONEngine: 'npm', _packageJSONFilter: 'vtex.render-builder@x' };
             const metric = 'registry-get-bundle';
             return this.http.getStream(routes.AppBundle(app, version, bundlePath), {
@@ -147,27 +98,20 @@ class Registry extends InfraClient_1.InfraClient {
                 },
                 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)
+        this.unpackAppBundle = (app, version, bundlePath, unpackPath, generatePackageJson) => {
+            return this.getAppBundle(app, version, bundlePath, generatePackageJson)
                 .then(stream => stream
                 .pipe(zlib_1.createGunzip())
                 .pipe(tar_fs_1.extract(unpackPath)));
         };
-        this.resolveDependenciesWithManifest = (manifest, filter = '', tracingConfig) => {
+        this.resolveDependenciesWithManifest = (manifest, filter = '') => {
             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,
-                } });
+            return this.http.post(routes.ResolveDependenciesWithManifest, manifest, { params, metric });
         };
-        this.publish = async (route, files, tag, { zlib } = {}, tracingConfig) => {
+        this.publish = async (route, files, tag, { zlib } = {}) => {
             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.');
             }
@@ -185,10 +129,6 @@ class Registry extends InfraClient_1.InfraClient {
                 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();

package/lib/clients/Router.d.ts

@@ -0,0 +1,33 @@
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+export declare class Router extends InfraClient {
+    constructor(ioContext: IOContext, opts?: InstanceOptions);
+    listAvailableIoVersions: () => Promise<AvaiableIO[]>;
+    getInstalledIoVersion: () => Promise<AvaiableIO>;
+    installIo: (version: string) => Promise<void>;
+    listAvailableServices: () => Promise<AvailableServices>;
+    getAvailableVersions: (name: string) => Promise<AvailableServiceVersions>;
+    listInstalledServices: () => Promise<InstalledService[]>;
+    installService: (name: string, version: string) => Promise<void>;
+}
+export interface AvaiableIO {
+    version: string;
+    tested: boolean;
+    services: {
+        [service: string]: string;
+    };
+}
+export declare 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;
+}

package/lib/clients/Router.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+const routes = {
+    AvailableIoVersions: '/_io',
+    AvailableServiceVersions: (service) => `${routes.AvailableServices}/${service}`,
+    AvailableServices: '/_services',
+    InstalledIoVersion: (account, workspace) => `/${account}/${workspace}/io`,
+    InstalledService: (account, workspace, name) => `/${routes.InstalledServices(account, workspace)}/services/${name}`,
+    InstalledServices: (account, workspace) => `/${account}/${workspace}/services`,
+};
+class Router extends HttpClient_1.InfraClient {
+    constructor(ioContext, opts) {
+        super('router', ioContext, opts, true);
+        this.listAvailableIoVersions = () => {
+            return this.http.get(routes.AvailableIoVersions);
+        };
+        this.getInstalledIoVersion = () => {
+            if (!this.context.account || !this.context.workspace) {
+                throw new Error('Missing client parameters: {account, workspace}');
+            }
+            return this.http.get(routes.InstalledIoVersion(this.context.account, this.context.workspace));
+        };
+        this.installIo = (version) => {
+            if (!this.context.account || !this.context.workspace) {
+                throw new Error('Missing client parameters: {account, workspace}');
+            }
+            return this.http.put(routes.InstalledIoVersion(this.context.account, this.context.workspace), { version });
+        };
+        this.listAvailableServices = () => {
+            return this.http.get(routes.AvailableServices);
+        };
+        this.getAvailableVersions = (name) => {
+            return this.http.get(routes.AvailableServiceVersions(name));
+        };
+        this.listInstalledServices = () => {
+            if (!this.context.account || !this.context.workspace) {
+                throw new Error('Missing client parameters: {account, workspace}');
+            }
+            return this.http.get(routes.InstalledServices(this.context.account, this.context.workspace));
+        };
+        this.installService = (name, version) => {
+            if (!this.context.account || !this.context.workspace) {
+                throw new Error('Missing client parameters: {account, workspace}');
+            }
+            return this.http.post(routes.InstalledServices(this.context.account, this.context.workspace), { name, version });
+        };
+    }
+}
+exports.Router = Router;