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

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 | undefined) => Promise<AvaiableIO[]>;
+    getInstalledIoVersion: (tracingConfig?: RequestTracingConfig | undefined) => Promise<AvaiableIO>;
+    installIo: (version: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<void>;
+    listAvailableServices: (tracingConfig?: RequestTracingConfig | undefined) => Promise<AvailableServices>;
+    getAvailableVersions: (name: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<AvailableServiceVersions>;
+    listInstalledServices: (tracingConfig?: RequestTracingConfig | undefined) => Promise<InstalledService[]>;
+    installService: (name: string, version: string, tracingConfig?: RequestTracingConfig | undefined) => 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/infra/Router.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Router = void 0;
+const InfraClient_1 = require("./InfraClient");
+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 InfraClient_1.InfraClient {
+    constructor(ioContext, opts) {
+        super('router', ioContext, opts, true);
+        this.listAvailableIoVersions = (tracingConfig) => {
+            return this.http.get(routes.AvailableIoVersions, { tracing: {
+                    requestSpanNameSuffix: 'list-io-versions',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getInstalledIoVersion = (tracingConfig) => {
+            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), {
+                tracing: {
+                    requestSpanNameSuffix: 'get-installed-io-version',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.installIo = (version, tracingConfig) => {
+            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 }, { tracing: {
+                    requestSpanNameSuffix: 'install-io',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.listAvailableServices = (tracingConfig) => {
+            return this.http.get(routes.AvailableServices, {
+                tracing: {
+                    requestSpanNameSuffix: 'list-available-services',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAvailableVersions = (name, tracingConfig) => {
+            return this.http.get(routes.AvailableServiceVersions(name), {
+                tracing: {
+                    requestSpanNameSuffix: 'get-versions',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.listInstalledServices = (tracingConfig) => {
+            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), {
+                tracing: {
+                    requestSpanNameSuffix: 'list-installed-services',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.installService = (name, version, tracingConfig) => {
+            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 }, {
+                tracing: {
+                    requestSpanNameSuffix: 'install-service',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+    }
+}
+exports.Router = Router;

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

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

package/lib/clients/infra/Sphinx.js

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

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

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable } from 'stream';
+import { Logger } from './../../service/logger/logger';
+import { InstanceOptions, IOResponse, RequestTracingConfig } from '../../HttpClient';
+import { BucketMetadata, FileListItem, VBaseSaveResponse } from '../../responses';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class VBase extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    getBucket: (bucket: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<BucketMetadata>;
+    resetBucket: (bucket: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<IOResponse<void>>;
+    listFiles: (bucket: string, opts?: string | VBaseOptions | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<BucketFileList>;
+    getFile: (bucket: string, path: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getJSON: <T>(bucket: string, path: string, nullIfNotFound?: boolean | undefined, conflictsResolver?: ConflictsResolver<T> | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<T>;
+    getRawJSON: <T>(bucket: string, path: string, nullIfNotFound?: boolean | undefined, conflictsResolver?: ConflictsResolver<T> | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<IOResponse<T>>;
+    getFileStream: (bucket: string, path: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<IncomingMessage>;
+    saveFile: (bucket: string, path: string, stream: Readable, gzip?: boolean, ttl?: number | undefined, tracingConfig?: RequestTracingConfig | undefined, ifMatch?: string | undefined) => Promise<void>;
+    getFileMetadata: (bucket: string, path: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<IOResponse<void>>;
+    saveJSON: <T>(bucket: string, path: string, data: T, tracingConfig?: RequestTracingConfig | undefined, ifMatch?: string | undefined) => Promise<VBaseSaveResponse>;
+    saveZippedContent: (bucket: string, path: string, stream: Readable, tracingConfig?: RequestTracingConfig | undefined, ifMatch?: string | undefined) => Promise<void>;
+    deleteFile: (bucket: string, path: string, tracingConfig?: RequestTracingConfig | undefined, ifMatch?: string | undefined) => Promise<IOResponse<void>>;
+    getConflicts: <T>(bucket: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<T>;
+    resolveConflict: <T>(bucket: string, path: string, content: any, tracingConfig?: RequestTracingConfig | undefined) => 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<T> {
+    resolve: (logger?: Logger) => T | Promise<T>;
+}

package/lib/clients/infra/VBase.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VBase = void 0;
+const mime_types_1 = __importDefault(require("mime-types"));
+const path_1 = require("path");
+const zlib_1 = require("zlib");
+const HttpClient_1 = require("../../HttpClient");
+const InfraClient_1 = require("./InfraClient");
+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 InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('vbase@2.x', context, options);
+        this.getBucket = (bucket, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'vbase-get-bucket';
+            return this.http.get(routes.Bucket(bucket), { inflightKey, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.resetBucket = (bucket, tracingConfig) => {
+            const metric = 'vbase-reset-bucket';
+            return this.http.delete(routes.Files(bucket), { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.listFiles = (bucket, opts, tracingConfig) => {
+            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), { inflightKey, metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getFile = (bucket, path, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'vbase-get-file';
+            return this.http.getBuffer(routes.File(bucket, path), { inflightKey, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getJSON = (bucket, path, nullIfNotFound, conflictsResolver, tracingConfig) => {
+            return this.getRawJSON(bucket, path, nullIfNotFound, conflictsResolver, tracingConfig)
+                .then(response => response.data);
+        };
+        this.getRawJSON = (bucket, path, nullIfNotFound, conflictsResolver, tracingConfig) => {
+            const headers = conflictsResolver ? { 'X-Vtex-Detect-Conflicts': true } : {};
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'vbase-get-json';
+            return this.http
+                .getRaw(routes.File(bucket, path), {
+                headers,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            })
+                .catch(async (error) => {
+                const { response } = error;
+                if (response && response.status === 409 && conflictsResolver) {
+                    try {
+                        const conflictsMergedData = await conflictsResolver.resolve(this.context.logger);
+                        return { ...response, data: conflictsMergedData };
+                    }
+                    catch (resolverError) {
+                        const typedResolverError = resolverError;
+                        if ((typedResolverError === null || typedResolverError === void 0 ? void 0 : typedResolverError.status) === 404) {
+                            return this.http.getRaw(routes.File(bucket, path), {
+                                'X-Vtex-Detect-Conflicts': false,
+                                inflightKey,
+                                metric,
+                                nullIfNotFound,
+                                tracing: {
+                                    requestSpanNameSuffix: metric,
+                                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                                },
+                            });
+                        }
+                        throw resolverError;
+                    }
+                }
+                throw error;
+            });
+        };
+        this.getFileStream = (bucket, path, tracingConfig) => {
+            const metric = 'vbase-get-file-s';
+            return this.http.getStream(routes.File(bucket, path), { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.saveFile = (bucket, path, stream, gzip = true, ttl, tracingConfig, ifMatch) => {
+            return this.saveContent(bucket, path, stream, { gzip, ttl }, tracingConfig, ifMatch);
+        };
+        this.getFileMetadata = (bucket, path, tracingConfig) => {
+            const metric = 'vbase-get-file-metadata';
+            return this.http.head(routes.File(bucket, path), { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.saveJSON = (bucket, path, data, tracingConfig, ifMatch) => {
+            const headers = { 'Content-Type': 'application/json' };
+            if (ifMatch) {
+                headers['If-Match'] = ifMatch;
+            }
+            const metric = 'vbase-save-json';
+            return this.http.put(routes.File(bucket, path), data, { headers, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.saveZippedContent = (bucket, path, stream, tracingConfig, ifMatch) => {
+            return this.saveContent(bucket, path, stream, { unzip: true }, tracingConfig, ifMatch);
+        };
+        this.deleteFile = (bucket, path, tracingConfig, ifMatch) => {
+            const headers = ifMatch ? { 'If-Match': ifMatch } : {};
+            const metric = 'vbase-delete-file';
+            return this.http.delete(routes.File(bucket, path), { headers, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getConflicts = (bucket, tracingConfig) => {
+            const metric = 'vbase-get-conflicts';
+            return this.http.get(routes.Conflicts(bucket), { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.resolveConflict = (bucket, path, content, tracingConfig) => {
+            const data = [{
+                    op: 'replace',
+                    path,
+                    value: content,
+                }];
+            const metric = 'vbase-resolve-conflicts';
+            return this.http.patch(routes.Conflicts(bucket), data, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.saveContent = (bucket, path, stream, opts = {}, tracingConfig, ifMatch) => {
+            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;
+            }
+            if (ifMatch) {
+                headers['If-Match'] = ifMatch;
+            }
+            const metric = 'vbase-save-blob';
+            return this.http.put(routes.File(bucket, path), finalStream, { headers, metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        if (runningAppName === '') {
+            throw new Error(`Invalid path to access VBase. Variable VTEX_APP_ID is not available.`);
+        }
+    }
+}
+exports.VBase = VBase;

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

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

package/lib/clients/infra/Workspaces.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workspaces = void 0;
+const constants_1 = require("../../constants");
+const InfraClient_1 = require("./InfraClient");
+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 InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('router', context, options, true);
+        this.list = (account, tracingConfig) => {
+            const metric = 'workspaces-list';
+            return this.http.get(routes.Account(account), { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.get = (account, workspace, tracingConfig) => {
+            const metric = 'workspaces-get';
+            return this.http.get(routes.Workspace(account, workspace), { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.set = (account, workspace, metadata, tracingConfig) => {
+            const metric = 'workspaces-set';
+            return this.http.put(routes.Workspace(account, workspace), metadata, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.create = (account, workspace, production, tracingConfig) => {
+            const metric = 'workspaces-create';
+            return this.http.post(routes.Account(account), { name: workspace, production }, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.delete = (account, workspace, tracingConfig) => {
+            const metric = 'workspaces-delete';
+            return this.http.delete(routes.Workspace(account, workspace), { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.reset = (account, workspace, metadata = {}, tracingConfig) => {
+            const params = { reset: true };
+            const metric = 'workspaces-reset';
+            return this.http.put(routes.Workspace(account, workspace), metadata, { metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.promote = (account, workspace, tracingConfig) => {
+            const metric = 'workspaces-promote';
+            return this.http.put(routes.Promote(account), { workspace }, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+    }
+}
+exports.Workspaces = Workspaces;

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

@@ -0,0 +1,11 @@
+export * from './Apps';
+export * from './Assets';
+export * from './BillingMetrics';
+export * from './Events';
+export * from './Housekeeper';
+export * from './InfraClient';
+export * from './Registry';
+export * from './Router';
+export * from './VBase';
+export * from './Workspaces';
+export * from './Sphinx';

package/lib/clients/infra/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Apps"), exports);
+__exportStar(require("./Assets"), exports);
+__exportStar(require("./BillingMetrics"), exports);
+__exportStar(require("./Events"), exports);
+__exportStar(require("./Housekeeper"), exports);
+__exportStar(require("./InfraClient"), exports);
+__exportStar(require("./Registry"), exports);
+__exportStar(require("./Router"), exports);
+__exportStar(require("./VBase"), exports);
+__exportStar(require("./Workspaces"), exports);
+__exportStar(require("./Sphinx"), exports);

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

@@ -1,6 +1,6 @@
-import { IOContext } from '../service/typings';
-import { ExternalClient } from './ExternalClient';
-import { InstanceOptions } from './typings';
+import { InstanceOptions } from '../../HttpClient/typings';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { ExternalClient } from '../external/ExternalClient';
 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/{HttpClient → clients/janus}/JanusClient.js

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

package/lib/clients/janus/LicenseManager.d.ts

@@ -0,0 +1,7 @@
+import { RequestTracingConfig } from '../../HttpClient';
+import { JanusClient } from './JanusClient';
+export declare class LicenseManager extends JanusClient {
+    getAccountData(VtexIdclientAutCookie: string, tracingConfig?: RequestTracingConfig): Promise<any>;
+    getTopbarData(VtexIdclientAutCookie: string, tracingConfig?: RequestTracingConfig): Promise<any>;
+    canAccessResource(VtexIdclientAutCookie: string, resourceKey: string, tracingConfig?: RequestTracingConfig): Promise<boolean>;
+}

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LicenseManager = void 0;
 const qs_1 = require("qs");
-const HttpClient_1 = require("../HttpClient");
+const JanusClient_1 = require("./JanusClient");
 const TWO_MINUTES_S = 2 * 60;
 const BASE_URL = '/api/license-manager';
 const routes = {
@@ -12,31 +13,46 @@ const routes = {
 const inflightKey = ({ baseURL, url, params }) => {
     return baseURL + url + qs_1.stringify(params, { arrayFormat: 'repeat', addQueryPrefix: true });
 };
-class LicenseManager extends HttpClient_1.JanusClient {
-    getAccountData(VtexIdclientAutCookie) {
+class LicenseManager extends JanusClient_1.JanusClient {
+    getAccountData(VtexIdclientAutCookie, tracingConfig) {
+        const metric = 'lm-account-data';
         return this.http.get(routes.accountData, {
             forceMaxAge: TWO_MINUTES_S,
             headers: {
                 VtexIdclientAutCookie,
             },
             inflightKey,
-            metric: 'lm-account-data',
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
         });
     }
-    getTopbarData(VtexIdclientAutCookie) {
+    getTopbarData(VtexIdclientAutCookie, tracingConfig) {
+        const metric = 'lm-topbar-data';
         return this.http.get(routes.topbarData, {
             headers: {
                 VtexIdclientAutCookie,
             },
-            metric: 'lm-topbar-data',
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
         });
     }
-    canAccessResource(VtexIdclientAutCookie, resourceKey) {
+    canAccessResource(VtexIdclientAutCookie, resourceKey, tracingConfig) {
+        const metric = 'lm-resource-access';
         return this.http.get(`${routes.resourceAccess}/${resourceKey}/access`, {
             headers: {
                 VtexIdclientAutCookie,
             },
-            metric: 'lm-resource-access',
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
         }).then(() => true, () => false);
     }
 }