@vtex/api 6.45.4

package/lib/clients/infra/VBase.js

@@ -0,0 +1,171 @@
+"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 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) {
+                    const conflictsMergedData = await conflictsResolver.resolve(this.context.logger);
+                    return { ...response, data: conflictsMergedData };
+                }
+                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 } : null;
+            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,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,12 @@
+export * from './Apps';
+export * from './Assets';
+export * from './BillingMetrics';
+export * from './Events';
+export * from './Housekeeper';
+export * from './InfraClient';
+export * from './Metadata';
+export * from './Registry';
+export * from './Router';
+export * from './VBase';
+export * from './Workspaces';
+export * from './Sphinx';

package/lib/clients/infra/index.js

@@ -0,0 +1,17 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./Apps"));
+__export(require("./Assets"));
+__export(require("./BillingMetrics"));
+__export(require("./Events"));
+__export(require("./Housekeeper"));
+__export(require("./InfraClient"));
+__export(require("./Metadata"));
+__export(require("./Registry"));
+__export(require("./Router"));
+__export(require("./VBase"));
+__export(require("./Workspaces"));
+__export(require("./Sphinx"));

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

@@ -0,0 +1,21 @@
+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.
+ *
+ * Example policy:
+ *
+ * {
+ *   "name": "outbound-access",
+ *   "attrs": {
+ *     "host": "portal.vtexcommercestable.com.br",
+ *     "path": "/api/*"
+ *   }
+ * }
+ */
+export declare class JanusClient extends ExternalClient {
+    constructor(context: IOContext, options?: InstanceOptions, environment?: Environment);
+}
+export {};

package/lib/clients/janus/JanusClient.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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.
+ *
+ * Example policy:
+ *
+ * {
+ *   "name": "outbound-access",
+ *   "attrs": {
+ *     "host": "portal.vtexcommercestable.com.br",
+ *     "path": "/api/*"
+ *   }
+ * }
+ */
+class JanusClient extends ExternalClient_1.ExternalClient {
+    constructor(context, options, environment) {
+        const { account } = context;
+        const env = context.janusEnv === 'beta' || environment === 'beta' ? 'beta' : 'stable';
+        super(`http://portal.vtexcommerce${env}.com.br`, context, {
+            ...options,
+            params: {
+                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/janus/LicenseManager.js

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

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

@@ -0,0 +1,36 @@
+import { RequestTracingConfig } from '../../HttpClient';
+import { JanusClient } from './JanusClient';
+export interface SegmentData {
+    campaigns?: any;
+    channel: number;
+    channelPrivacy?: 'public' | 'private';
+    priceTables?: any;
+    utm_campaign: string;
+    regionId?: string;
+    utm_source: string;
+    utmi_campaign: string;
+    currencyCode: string;
+    currencySymbol: string;
+    countryCode: string;
+    cultureInfo: string;
+    [key: string]: any;
+}
+export declare class Segment extends JanusClient {
+    /**
+     * Get the segment data using the current `ctx.vtex.segmentToken`
+     *
+     * @memberof Segment
+     */
+    getSegment: (tracingConfig?: RequestTracingConfig | undefined) => 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<{
+        segmentData: SegmentData;
+        segmentToken: string;
+    }>;
+    private rawSegment;
+}