@vtex/api 6.47.0 → 6.48.1-beta

package/lib/clients/{janus/Segment.d.ts → Segment.d.ts}

@@ -1,9 +1,7 @@
-import { RequestTracingConfig } from '../../HttpClient';
-import { JanusClient } from './JanusClient';
+import { JanusClient } from '../HttpClient';
 export interface SegmentData {
     campaigns?: any;
     channel: number;
-    channelPrivacy?: 'public' | 'private';
     priceTables?: any;
     utm_campaign: string;
     regionId?: string;
@@ -16,21 +14,27 @@ export interface SegmentData {
     [key: string]: any;
 }
 export declare class Segment extends JanusClient {
+    /**
+     * @deprecated Please use `getSegment` or `getSegmentByToken` instead.
+     *
+     * @memberof Segment
+     */
+    segment: (query?: Record<string, string> | undefined, token?: string | undefined) => Promise<SegmentData>;
     /**
      * Get the segment data using the current `ctx.vtex.segmentToken`
      *
      * @memberof Segment
      */
-    getSegment: (tracingConfig?: RequestTracingConfig | undefined) => Promise<SegmentData>;
+    getSegment: () => Promise<SegmentData>;
     /**
      * Get the segment data from this specific segment token
      *
      * @memberof Segment
      */
-    getSegmentByToken: (token: string | null, tracingConfig?: RequestTracingConfig | undefined) => Promise<SegmentData>;
-    getOrCreateSegment: (query?: Record<string, string> | undefined, token?: string | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+    getSegmentByToken: (token: string | null) => Promise<SegmentData>;
+    getOrCreateSegment: (query?: Record<string, string> | undefined, token?: string | undefined) => Promise<{
         segmentData: SegmentData;
-        segmentToken: string | null;
+        segmentToken: string | undefined;
     }>;
     private rawSegment;
 }

package/lib/clients/Segment.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const constants_1 = require("../constants");
+const HttpClient_1 = require("../HttpClient");
+const Session_1 = require("./Session");
+const SEGMENT_MAX_AGE_S = 60 * 60; // 60 minutes - segment is actually immutable
+const ALLOWED_QUERY_PREFIXES = ['utm', 'cultureInfo', 'supportedLocales'];
+const filterAndSortQuery = (query) => {
+    if (!query) {
+        return null;
+    }
+    const filteredKeys = Object.keys(query)
+        .filter((k) => !!k && ALLOWED_QUERY_PREFIXES.some((prefix) => k.startsWith(prefix)))
+        .sort();
+    return filteredKeys.reduce((acc, val) => {
+        acc[val] = query[val];
+        return acc;
+    }, {});
+};
+const routes = {
+    base: '/api/segments',
+    segments: (token) => token ? `${routes.base}/${token}` : routes.base,
+};
+class Segment extends HttpClient_1.JanusClient {
+    constructor() {
+        super(...arguments);
+        /**
+         * @deprecated Please use `getSegment` or `getSegmentByToken` instead.
+         *
+         * @memberof Segment
+         */
+        this.segment = (query, token) => this.rawSegment(token || this.context.segmentToken, query).then(ramda_1.prop('data'));
+        /**
+         * Get the segment data using the current `ctx.vtex.segmentToken`
+         *
+         * @memberof Segment
+         */
+        this.getSegment = () => this.rawSegment(this.context.segmentToken).then(ramda_1.prop('data'));
+        /**
+         * Get the segment data from this specific segment token
+         *
+         * @memberof Segment
+         */
+        this.getSegmentByToken = (token) => this.rawSegment(token).then(ramda_1.prop('data'));
+        this.getOrCreateSegment = async (query, token) => {
+            const { data: segmentData, headers, } = await this.rawSegment(token, query);
+            return {
+                segmentData,
+                segmentToken: Session_1.extractSessionCookie(headers) || token,
+            };
+        };
+        this.rawSegment = (token, query) => {
+            const { product } = this.context;
+            const filteredQuery = filterAndSortQuery(query);
+            return this.http.getRaw(routes.segments(token), ({
+                forceMaxAge: SEGMENT_MAX_AGE_S,
+                headers: {
+                    'Content-Type': 'application/json',
+                    [constants_1.PRODUCT_HEADER]: product || '',
+                },
+                inflightKey: HttpClient_1.inflightUrlWithQuery,
+                metric: token ? 'segment-get-token' : 'segment-get-new',
+                params: Object.assign({}, filteredQuery, { session_path: product || '' }),
+            }));
+        };
+    }
+}
+exports.Segment = Segment;

package/lib/clients/{janus/Session.d.ts → Session.d.ts}

@@ -1,15 +1,15 @@
-import { RequestTracingConfig } from '../../HttpClient';
-import { JanusClient } from './JanusClient';
+import { JanusClient } from './../HttpClient';
 export declare class Session extends JanusClient {
     /**
      * Get the session data using the given token
      */
-    getSession: (token: string, items: string[], tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+    getSession: (token: string, items: string[]) => Promise<{
         sessionData: any;
         sessionToken: string;
     }>;
     /**
      * Update the public portion of this session
      */
-    updateSession: (key: string, value: any, items: string[], token: any, tracingConfig?: RequestTracingConfig | undefined) => Promise<void>;
+    updateSession: (key: string, value: any, items: string[], token: any) => Promise<void>;
 }
+export declare function extractSessionCookie(headers: Record<string, string>): string | null;

package/lib/clients/{janus/Session.js → Session.js}

@@ -4,58 +4,47 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const cookie_1 = __importDefault(require("cookie"));
-const JanusClient_1 = require("./JanusClient");
+const HttpClient_1 = require("./../HttpClient");
 const SESSION_COOKIE = 'vtex_session';
 const routes = {
     base: '/api/sessions',
 };
-class Session extends JanusClient_1.JanusClient {
+class Session extends HttpClient_1.JanusClient {
     constructor() {
         super(...arguments);
         /**
          * Get the session data using the given token
          */
-        this.getSession = async (token, items, tracingConfig) => {
-            var _a;
-            const metric = 'session-get';
-            const { data: sessionData, headers } = await this.http.getRaw(routes.base, {
+        this.getSession = async (token, items) => {
+            const { data: sessionData, headers } = await this.http.getRaw(routes.base, ({
                 headers: {
                     'Content-Type': 'application/json',
-                    Cookie: `vtex_session=${token};`,
+                    'Cookie': `vtex_session=${token};`,
                 },
-                metric,
+                metric: 'session-get',
                 params: {
                     items: items.join(','),
                 },
-                tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                },
-            });
+            }));
             return {
                 sessionData,
-                sessionToken: (_a = extractSessionCookie(headers)) !== null && _a !== void 0 ? _a : token,
+                sessionToken: extractSessionCookie(headers) || token,
             };
         };
         /**
          * Update the public portion of this session
          */
-        this.updateSession = (key, value, items, token, tracingConfig) => {
+        this.updateSession = (key, value, items, token) => {
             const data = { public: { [key]: { value } } };
-            const metric = 'session-update';
             const config = {
                 headers: {
                     'Content-Type': 'application/json',
-                    Cookie: `vtex_session=${token};`,
+                    'Cookie': `vtex_session=${token};`,
                 },
-                metric,
+                metric: 'session-update',
                 params: {
                     items: items.join(','),
                 },
-                tracing: {
-                    requestSpanNameSuffix: metric,
-                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                },
             };
             return this.http.post(routes.base, data, config);
         };
@@ -63,8 +52,7 @@ class Session extends JanusClient_1.JanusClient {
 }
 exports.Session = Session;
 function extractSessionCookie(headers) {
-    var _a;
-    for (const setCookie of (_a = headers['set-cookie']) !== null && _a !== void 0 ? _a : []) {
+    for (const setCookie of headers['set-cookie'] || []) {
         const parsedCookie = cookie_1.default.parse(setCookie);
         const sessionCookie = parsedCookie[SESSION_COOKIE];
         if (sessionCookie != null) {
@@ -73,3 +61,4 @@ function extractSessionCookie(headers) {
     }
     return null;
 }
+exports.extractSessionCookie = extractSessionCookie;

package/lib/clients/{apps/Settings.d.ts → Settings.d.ts}

@@ -1,7 +1,6 @@
-import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
-import { IOContext } from '../../service/worker/runtime/typings';
-import { AppMetaInfo } from '../infra/Apps';
-import { AppClient } from './AppClient';
+import { AppClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+import { AppMetaInfo } from './Apps';
 export interface SettingsParams {
     merge?: boolean;
     files?: string[];
@@ -10,5 +9,5 @@ export declare class Settings extends AppClient {
     constructor(context: IOContext, options?: InstanceOptions);
     getFilteredDependencies(appAtMajor: string, dependencies: AppMetaInfo[]): AppMetaInfo[];
     getDependenciesHash(dependencies: AppMetaInfo[]): string;
-    getSettings(dependencies: AppMetaInfo[], appAtMajor: string, params?: SettingsParams, tracingConfig?: RequestTracingConfig): Promise<any>;
+    getSettings(dependencies: AppMetaInfo[], appAtMajor: string, params?: SettingsParams): Promise<any>;
 }

package/lib/clients/{apps/Settings.js → Settings.js}

@@ -1,37 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
 const ramda_1 = require("ramda");
-const HttpClient_1 = require("../../HttpClient");
-const settings_1 = require("../../service/worker/runtime/http/middlewares/settings");
-const app_1 = require("../../utils/app");
-const AppClient_1 = require("./AppClient");
+const HttpClient_1 = require("../HttpClient");
+const app_1 = require("../utils/app");
 const LINKED_ROUTE = 'linked';
+const dependsOnApp = (appAtMajor) => (a) => {
+    const [name, major] = appAtMajor.split('@');
+    const version = a._resolvedDependencies[name];
+    if (!version) {
+        return false;
+    }
+    const [depMajor] = version.split('.');
+    return major === depMajor;
+};
+const joinIds = ramda_1.join('');
 const containsLinks = ramda_1.any(app_1.isLinkedApp);
-class Settings extends AppClient_1.AppClient {
+class Settings extends HttpClient_1.AppClient {
     constructor(context, options) {
         super('vtex.settings-server@0.x', context, options);
     }
     getFilteredDependencies(appAtMajor, dependencies) {
-        return settings_1.getFilteredDependencies(appAtMajor, dependencies);
+        const depends = dependsOnApp(appAtMajor);
+        return ramda_1.filter(depends, dependencies);
     }
     getDependenciesHash(dependencies) {
-        return settings_1.getDependenciesHash(dependencies);
+        const dependingApps = ramda_1.pluck('id', dependencies);
+        return crypto_1.createHash('md5').update(joinIds(dependingApps)).digest('hex');
     }
-    async getSettings(dependencies, appAtMajor, params, tracingConfig) {
+    async getSettings(dependencies, appAtMajor, params) {
         const filtered = this.getFilteredDependencies(appAtMajor, dependencies);
         // Settings server exposes a smartCache-enabled route for when the workspace contains links.
         const lastSegment = containsLinks(filtered)
             ? LINKED_ROUTE
             : this.getDependenciesHash(filtered);
-        const metric = 'settings-get';
         return this.http.get(`/settings/${appAtMajor}/${lastSegment}`, {
             inflightKey: HttpClient_1.inflightUrlWithQuery,
-            metric,
+            metric: 'settings-get',
             params,
-            tracing: {
-                requestSpanNameSuffix: metric,
-                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-            },
         });
     }
 }

package/lib/clients/Sphinx.d.ts

@@ -0,0 +1,12 @@
+import { IOContext } from '../service/typings';
+import { InfraClient, InstanceOptions } from './../HttpClient';
+export declare class Sphinx extends InfraClient {
+    constructor(ioContext: IOContext, opts?: InstanceOptions);
+    validatePolicies: (policies: PolicyRequest[]) => Promise<void>;
+    isAdmin: (email: string) => Promise<boolean>;
+}
+export interface PolicyRequest {
+    name: string;
+    reason: string;
+    attrs: Record<string, string>;
+}

package/lib/clients/Sphinx.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("./../HttpClient");
+class Sphinx extends HttpClient_1.InfraClient {
+    constructor(ioContext, opts) {
+        super('sphinx@0.x', ioContext, opts, false);
+        this.validatePolicies = (policies) => {
+            return this.http.post('/policies/validate', { policies }, {
+                metric: 'sphinx-validate-policy',
+            });
+        };
+        this.isAdmin = (email) => {
+            return this.http.get(`/user/${email}/isAdmin`, {
+                metric: 'sphinx-is-admin',
+            });
+        };
+    }
+}
+exports.Sphinx = Sphinx;

package/lib/clients/{janus/Tenant.d.ts → Tenant.d.ts}

@@ -1,7 +1,7 @@
-import { InstanceOptions, RequestConfig } from '../../HttpClient/typings';
-import { IOContext } from '../../service/worker/runtime/typings';
-import { JanusClient } from './JanusClient';
-export interface Binding {
+import { ExternalClient } from '../HttpClient/ExternalClient';
+import { InstanceOptions, RequestConfig } from '../HttpClient/typings';
+import { IOContext } from '../service/typings';
+interface Binding {
     id: string;
     canonicalBaseAddress: string;
     alternateBaseAddresses: string[];
@@ -12,7 +12,7 @@ export interface Binding {
     extraContext: Record<string, any>;
     targetProduct: string;
 }
-export interface Tenant {
+interface Tenant {
     id: string;
     slug: string;
     title: string;
@@ -23,7 +23,8 @@ export interface Tenant {
     defaultLocale: string;
     metadata: Record<string, string>;
 }
-export declare class TenantClient extends JanusClient {
+export declare class TenantClient extends ExternalClient {
     constructor(ctx: IOContext, opts?: InstanceOptions);
     info: (config?: RequestConfig | undefined) => Promise<Tenant>;
 }
+export {};

package/lib/clients/Tenant.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("../HttpClient");
+const ExternalClient_1 = require("../HttpClient/ExternalClient");
+class TenantClient extends ExternalClient_1.ExternalClient {
+    constructor(ctx, opts) {
+        super('http://portal.vtexcommercestable.com.br/api/tenant', ctx, Object.assign({}, opts, { params: {
+                q: ctx.account,
+            } }));
+        this.info = (config) => this.http.get('/tenants', Object.assign({ inflightKey: HttpClient_1.inflightUrlWithQuery, memoizeable: true, metric: 'get-tenant-info' }, config));
+    }
+}
+exports.TenantClient = TenantClient;

package/lib/clients/VBase.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable } from 'stream';
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { BucketMetadata, FileListItem } from '../responses';
+import { IOContext } from '../service/typings';
+export declare class VBase extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    getBucket: (bucket: string) => Promise<BucketMetadata>;
+    resetBucket: (bucket: string) => Promise<import("../HttpClient").IOResponse<void>>;
+    listFiles: (bucket: string, opts?: string | VBaseOptions | undefined) => Promise<BucketFileList>;
+    getFile: (bucket: string, path: string) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getJSON: <T>(bucket: string, path: string, nullIfNotFound?: boolean | undefined, conflictsResolver?: ConflictsResolver | undefined) => Promise<{} | T>;
+    getFileStream: (bucket: string, path: string) => Promise<IncomingMessage>;
+    saveFile: (bucket: string, path: string, stream: Readable, gzip?: boolean, ttl?: number | undefined) => Promise<void>;
+    getFileMetadata: (bucket: string, path: string) => Promise<import("../HttpClient").IOResponse<void>>;
+    saveJSON: <T>(bucket: string, path: string, data: T) => Promise<void>;
+    saveZippedContent: (bucket: string, path: string, stream: Readable) => Promise<void>;
+    deleteFile: (bucket: string, path: string) => Promise<import("../HttpClient").IOResponse<void>>;
+    getConflicts: <T>(bucket: string) => Promise<T>;
+    resolveConflict: <T>(bucket: string, path: string, content: any) => Promise<T>;
+    private saveContent;
+}
+export interface BucketFileList {
+    data: FileListItem[];
+    next: string;
+    smartCacheHeaders: any;
+}
+export interface VBaseOptions {
+    prefix?: string;
+    _next?: string;
+    _limit?: number;
+}
+export interface VBaseSaveOptions {
+    gzip?: boolean;
+    unzip?: boolean;
+    ttl?: number;
+}
+export interface VBaseConflictData {
+    path: string;
+    base: VBaseConflict;
+    master: VBaseConflict;
+    mine: VBaseConflict;
+}
+export interface VBaseConflict {
+    contentOmitted: boolean;
+    deleted: boolean;
+    mimeType: string;
+    parsedContent?: any;
+    content: string;
+}
+export interface ConflictsResolver {
+    resolve: () => {};
+}

package/lib/clients/VBase.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mime_types_1 = __importDefault(require("mime-types"));
+const path_1 = require("path");
+const zlib_1 = require("zlib");
+const HttpClient_1 = require("../HttpClient");
+const appId = process.env.VTEX_APP_ID;
+const [runningAppName] = appId ? appId.split('@') : [''];
+const routes = {
+    Bucket: (bucket) => `/buckets/${runningAppName}/${bucket}`,
+    Conflicts: (bucket) => `/buckets/${runningAppName}/${bucket}/conflicts`,
+    File: (bucket, path) => `${routes.Bucket(bucket)}/files/${path}`,
+    Files: (bucket) => `${routes.Bucket(bucket)}/files`,
+};
+const isVBaseOptions = (opts) => {
+    return typeof opts !== 'string' && !(opts instanceof String);
+};
+class VBase extends HttpClient_1.InfraClient {
+    constructor(context, options) {
+        super('vbase@2.x', context, options);
+        this.getBucket = (bucket) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'vbase-get-bucket';
+            return this.http.get(routes.Bucket(bucket), { metric, inflightKey });
+        };
+        this.resetBucket = (bucket) => {
+            return this.http.delete(routes.Files(bucket), { metric: 'vbase-reset-bucket' });
+        };
+        this.listFiles = (bucket, opts) => {
+            let params = {};
+            if (isVBaseOptions(opts)) {
+                params = opts;
+            }
+            else if (opts) {
+                params = { prefix: opts };
+            }
+            const metric = 'vbase-list';
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            return this.http.get(routes.Files(bucket), { params, metric, inflightKey });
+        };
+        this.getFile = (bucket, path) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'vbase-get-file';
+            return this.http.getBuffer(routes.File(bucket, path), { metric, inflightKey });
+        };
+        this.getJSON = (bucket, path, nullIfNotFound, conflictsResolver) => {
+            const headers = conflictsResolver ? { 'X-Vtex-Detect-Conflicts': true } : {};
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'vbase-get-json';
+            return this.http.get(routes.File(bucket, path), { nullIfNotFound, metric, inflightKey, headers })
+                .catch((error) => {
+                const { response } = error;
+                if (response && response.status === 409 && conflictsResolver) {
+                    return conflictsResolver.resolve();
+                }
+                throw error;
+            });
+        };
+        this.getFileStream = (bucket, path) => {
+            return this.http.getStream(routes.File(bucket, path), { metric: 'vbase-get-file-s' });
+        };
+        this.saveFile = (bucket, path, stream, gzip = true, ttl) => {
+            return this.saveContent(bucket, path, stream, { gzip, ttl });
+        };
+        this.getFileMetadata = (bucket, path) => {
+            return this.http.head(routes.File(bucket, path), { metric: 'vbase-get-file-metadata' });
+        };
+        this.saveJSON = (bucket, path, data) => {
+            const headers = { 'Content-Type': 'application/json' };
+            const metric = 'vbase-save-json';
+            return this.http.put(routes.File(bucket, path), data, { headers, metric });
+        };
+        this.saveZippedContent = (bucket, path, stream) => {
+            return this.saveContent(bucket, path, stream, { unzip: true });
+        };
+        this.deleteFile = (bucket, path) => {
+            return this.http.delete(routes.File(bucket, path), { metric: 'vbase-delete-file' });
+        };
+        this.getConflicts = (bucket) => {
+            return this.http.get(routes.Conflicts(bucket), { metric: 'vbase-get-conflicts' });
+        };
+        this.resolveConflict = (bucket, path, content) => {
+            const data = [{
+                    op: 'replace',
+                    path,
+                    value: content,
+                }];
+            return this.http.patch(routes.Conflicts(bucket), data, { metric: 'vbase-resolve-conflicts' });
+        };
+        this.saveContent = (bucket, path, stream, opts = {}) => {
+            if (!stream.pipe || !stream.on) {
+                throw new Error(`Argument stream must be a readable stream`);
+            }
+            const params = opts.unzip ? { unzip: opts.unzip } : {};
+            const headers = {};
+            let finalStream = stream;
+            headers['Content-Type'] = mime_types_1.default.contentType(path_1.basename(path)) || 'application/octet-stream';
+            if (opts.gzip) {
+                headers['Content-Encoding'] = 'gzip';
+                finalStream = stream.pipe(zlib_1.createGzip());
+            }
+            if (opts.ttl && Number.isInteger(opts.ttl)) {
+                headers['X-VTEX-TTL'] = opts.ttl;
+            }
+            const metric = 'vbase-save-blob';
+            return this.http.put(routes.File(bucket, path), finalStream, { headers, params, metric });
+        };
+        if (runningAppName === '') {
+            throw new Error(`Invalid path to access VBase. Variable VTEX_APP_ID is not available.`);
+        }
+    }
+}
+exports.VBase = VBase;

package/lib/clients/Workspaces.d.ts

@@ -0,0 +1,17 @@
+import { InfraClient, InstanceOptions } from '../HttpClient';
+import { IOContext } from '../service/typings';
+export declare class Workspaces extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    list: (account: string) => Promise<WorkspaceMetadata[]>;
+    get: (account: string, workspace: string) => Promise<WorkspaceMetadata>;
+    set: (account: string, workspace: string, metadata: Partial<WorkspaceMetadata>) => Promise<void>;
+    create: (account: string, workspace: string, production: boolean) => Promise<void>;
+    delete: (account: string, workspace: string) => Promise<import("../HttpClient").IOResponse<void>>;
+    reset: (account: string, workspace: string, metadata?: Partial<WorkspaceMetadata>) => Promise<void>;
+    promote: (account: string, workspace: string, conflictResolutionStrategy?: string | undefined) => Promise<void>;
+}
+export interface WorkspaceMetadata {
+    name: string;
+    weight: number;
+    production: boolean;
+}

package/lib/clients/Workspaces.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../constants");
+const HttpClient_1 = require("../HttpClient");
+const routes = {
+    Account: (account) => `/${account}`,
+    Promote: (account) => `${routes.Workspace(account, constants_1.DEFAULT_WORKSPACE)}/_promote`,
+    Workspace: (account, workspace) => `${routes.Account(account)}/${workspace}`,
+};
+class Workspaces extends HttpClient_1.InfraClient {
+    constructor(context, options) {
+        super('router', context, options, true);
+        this.list = (account) => {
+            return this.http.get(routes.Account(account), { metric: 'workspaces-list' });
+        };
+        this.get = (account, workspace) => {
+            return this.http.get(routes.Workspace(account, workspace), { metric: 'workspaces-get' });
+        };
+        this.set = (account, workspace, metadata) => {
+            return this.http.put(routes.Workspace(account, workspace), metadata, { metric: 'workspaces-set' });
+        };
+        this.create = (account, workspace, production) => {
+            return this.http.post(routes.Account(account), { name: workspace, production }, { metric: 'workspaces-create' });
+        };
+        this.delete = (account, workspace) => {
+            return this.http.delete(routes.Workspace(account, workspace), { metric: 'workspaces-delete' });
+        };
+        this.reset = (account, workspace, metadata = {}) => {
+            const params = { reset: true };
+            const metric = 'workspaces-reset';
+            return this.http.put(routes.Workspace(account, workspace), metadata, { params, metric });
+        };
+        this.promote = (account, workspace, conflictResolutionStrategy) => {
+            return this.http.put(routes.Promote(account), { workspace, conflictResolutionStrategy }, { metric: 'workspaces-promote' });
+        };
+    }
+}
+exports.Workspaces = Workspaces;

package/lib/clients/index.d.ts

@@ -1,9 +1,21 @@
-export * from './apps';
-export * from './external';
-export * from './infra';
-export * from './janus';
-export * from './IOClient';
-export * from './IOClients';
-export * from './IOGraphQLClient';
-import promclient from 'prom-client';
-export { promclient };
+export * from './Apps';
+export * from './Assets';
+export * from './Billing';
+export * from './BillingMetrics';
+export * from './Builder';
+export * from './Events';
+export * from './Housekeeper';
+export * from './ID';
+export * from './LicenseManager';
+export * from './Logger';
+export * from './Messages';
+export * from './MessagesGraphQL';
+export * from './Metadata';
+export * from './Registry';
+export * from './Router';
+export * from './Segment';
+export * from './Settings';
+export * from './Session';
+export * from './Sphinx';
+export * from './VBase';
+export * from './Workspaces';