@vtex/api 6.45.4

package/lib/clients/apps/Billing.d.ts

@@ -0,0 +1,12 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { AppClient } from './AppClient';
+export declare class Billing extends AppClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    status: (tracingConfig?: RequestTracingConfig | undefined) => Promise<ContractStatus>;
+}
+export declare enum ContractStatus {
+    ACTIVE = "active_contract",
+    INACTIVE = "inactive_contract",
+    NO_CONTRACT = "no_contract"
+}

package/lib/clients/apps/Billing.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AppClient_1 = require("./AppClient");
+class Billing extends AppClient_1.AppClient {
+    constructor(context, options) {
+        super('vtex.billing@0.x', context, options);
+        this.status = (tracingConfig) => this.http.get('/_v/contractStatus', {
+            tracing: {
+                requestSpanNameSuffix: 'billing-status',
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+}
+exports.Billing = Billing;
+var ContractStatus;
+(function (ContractStatus) {
+    ContractStatus["ACTIVE"] = "active_contract";
+    ContractStatus["INACTIVE"] = "inactive_contract";
+    ContractStatus["NO_CONTRACT"] = "no_contract";
+})(ContractStatus = exports.ContractStatus || (exports.ContractStatus = {}));

package/lib/clients/apps/Builder.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" />
+import { ZlibOptions } from 'zlib';
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { Change } from '../infra/Apps';
+import { File } from '../infra/Registry';
+import { AppClient } from './AppClient';
+export declare class Builder extends AppClient {
+    private stickyHost;
+    constructor(ioContext: IOContext, opts?: InstanceOptions);
+    availability: (app: string, hintIndex: number, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        host: string;
+        hostname: string | undefined;
+        score: number;
+    }>;
+    clean: (app: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
+    getPinnedDependencies: (tracingConfig?: RequestTracingConfig | undefined) => Promise<any>;
+    linkApp: (app: string, files: File[], zipOptions?: ZipOptions, params?: RequestParams, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
+    publishApp: (app: string, files: File[], zipOptions?: ZipOptions, params?: RequestParams, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
+    relinkApp: (app: string, changes: Change[], params?: RequestParams, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
+    testApp: (app: string, files: File[], zipOptions?: ZipOptions, params?: RequestParams, tracingConfig?: RequestTracingConfig | undefined) => Promise<BuildResult>;
+    private zipAndSend;
+}
+interface RequestParams {
+    tsErrorsAsWarnings?: boolean;
+    skipSemVerEnsure?: boolean;
+}
+interface ZipOptions {
+    sticky?: boolean;
+    stickyHint?: string;
+    tag?: string;
+    zlib?: ZlibOptions;
+}
+export interface BuildResult {
+    availability?: AvailabilityResponse;
+    code?: string;
+    message?: any;
+    timeNano?: number;
+}
+export interface AvailabilityResponse {
+    host: string | undefined;
+    hostname: string | undefined;
+    score: number;
+}
+export {};

package/lib/clients/apps/Builder.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const archiver_1 = __importDefault(require("archiver"));
+const cache_1 = require("../../HttpClient/middlewares/cache");
+const AppClient_1 = require("./AppClient");
+const routes = {
+    Availability: (app) => `${routes.Builder}/availability/${app}`,
+    Builder: '/_v/builder/0',
+    Clean: (app) => `${routes.Builder}/clean/${app}`,
+    Link: (app) => `${routes.Builder}/link/${app}`,
+    PinnedDependencies: () => `${routes.Builder}/pinneddeps`,
+    Publish: (app) => `${routes.Builder}/publish/${app}`,
+    Relink: (app) => `${routes.Builder}/relink/${app}`,
+    Test: (app) => `${routes.Builder}/test/${app}`,
+};
+class Builder extends AppClient_1.AppClient {
+    constructor(ioContext, opts) {
+        super('vtex.builder-hub@0.x', ioContext, opts);
+        this.availability = async (app, hintIndex, tracingConfig) => {
+            const stickyHint = hintIndex === undefined || hintIndex === null ?
+                `request:${this.context.account}:${this.context.workspace}:${app}` :
+                `request:${this.context.account}:${this.context.workspace}:${app}:${hintIndex}`;
+            const headers = {
+                'Content-Type': 'application/json',
+                'x-vtex-sticky-host': stickyHint,
+            };
+            const metric = 'bh-availability';
+            const { data: { availability }, headers: { 'x-vtex-sticky-host': host }, } = await this.http.getRaw(routes.Availability(app), { cacheable: cache_1.CacheType.None, headers, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+            const { hostname, score } = availability;
+            return { host, hostname, score };
+        };
+        this.clean = (app, tracingConfig) => {
+            const headers = {
+                'Content-Type': 'application/json',
+                ...this.stickyHost && { 'x-vtex-sticky-host': this.stickyHost },
+            };
+            const metric = 'bh-clean';
+            return this.http.post(routes.Clean(app), { headers, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getPinnedDependencies = (tracingConfig) => {
+            return this.http.get(routes.PinnedDependencies(), {
+                tracing: {
+                    requestSpanNameSuffix: 'pinned-dependencies',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.linkApp = (app, files, zipOptions = { sticky: true }, params = {}, tracingConfig) => {
+            return this.zipAndSend(routes.Link(app), app, files, zipOptions, params, tracingConfig);
+        };
+        this.publishApp = (app, files, zipOptions = { sticky: true }, params = {}, tracingConfig) => {
+            return this.zipAndSend(routes.Publish(app), app, files, zipOptions, params, tracingConfig);
+        };
+        this.relinkApp = (app, changes, params = {}, tracingConfig) => {
+            const headers = {
+                'Content-Type': 'application/json',
+                ...this.stickyHost && { 'x-vtex-sticky-host': this.stickyHost },
+            };
+            const metric = 'bh-relink';
+            return this.http.put(routes.Relink(app), changes, { headers, metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.testApp = (app, files, zipOptions = { sticky: true }, params = {}, tracingConfig) => {
+            return this.zipAndSend(routes.Test(app), app, files, zipOptions, params, tracingConfig);
+        };
+        this.zipAndSend = async (route, app, files, { tag, sticky, stickyHint, zlib } = {}, requestParams = {}, tracingConfig) => {
+            if (!(files[0] && files[0].path && files[0].content)) {
+                throw new Error('Argument files must be an array of {path, content}, where content can be a String, a Buffer or a ReadableStream.');
+            }
+            const indexOfManifest = files.findIndex(({ path }) => path === 'manifest.json');
+            if (indexOfManifest === -1) {
+                throw new Error('No manifest.json file found in files.');
+            }
+            const zip = archiver_1.default('zip', { zlib });
+            // Throw stream errors so they reject the promise chain.
+            zip.on('error', (e) => {
+                throw e;
+            });
+            const hint = stickyHint || `request:${this.context.account}:${this.context.workspace}:${app}`;
+            const metric = 'bh-zip-send';
+            const params = tag ? { ...requestParams, tag } : requestParams;
+            const request = this.http.postRaw(route, zip, {
+                headers: {
+                    'Content-Type': 'application/octet-stream',
+                    ...sticky && { 'x-vtex-sticky-host': this.stickyHost || hint },
+                },
+                metric,
+                params,
+                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();
+            const [response] = await Promise.all([request, finalize]);
+            const { data, headers: { 'x-vtex-sticky-host': host } } = response;
+            this.stickyHost = host;
+            return data;
+        };
+    }
+}
+exports.Builder = Builder;

package/lib/clients/apps/MessagesGraphQL.d.ts

@@ -0,0 +1,61 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { AppGraphQLClient } from './AppGraphQLClient';
+export interface IndexedByFrom {
+    messages: Array<Omit<Message, 'from'>>;
+    from: string;
+}
+export declare type Behavior = 'FULL' | 'USER_ONLY' | 'USER_AND_APP';
+export interface Message {
+    content: string;
+    context?: string;
+    behavior?: Behavior;
+    from: string;
+}
+export interface MessageSaveInput {
+    srcLang: string;
+    srcMessage: string;
+    context?: string;
+    targetMessage: string;
+    groupContext?: string;
+}
+export interface TranslateInput {
+    indexedByFrom: IndexedByFrom[];
+    to: string;
+    depTree?: string;
+    encoding?: 'ICU' | 'HANDLEBARS';
+}
+export interface TranslateWithDependenciesInput {
+    indexedByFrom: IndexedByFrom[];
+    to: string;
+    depTree: string;
+    encoding?: 'ICU' | 'HANDLEBARS';
+}
+export interface SaveInput {
+    fireEvent?: boolean;
+    to: string;
+    messages: MessageSaveInput[];
+}
+export interface MessageInputV2 {
+    content: string;
+    context?: string;
+    behavior?: Behavior;
+}
+export interface MessageListV2 {
+    srcLang: string;
+    groupContext?: string;
+    context?: string;
+    translations: Translation[];
+}
+export interface Translation {
+    lang: string;
+    translation: string;
+}
+export declare class MessagesGraphQL extends AppGraphQLClient {
+    constructor(vtex: IOContext, options?: InstanceOptions);
+    translateV2(args: TranslateInput, tracingConfig?: RequestTracingConfig): Promise<string[]>;
+    translate(args: TranslateInput, tracingConfig?: RequestTracingConfig): Promise<string[]>;
+    translateWithDependencies(args: TranslateWithDependenciesInput, tracingConfig?: RequestTracingConfig): Promise<string[]>;
+    saveV2(args: SaveInput, tracingConfig?: RequestTracingConfig): Promise<boolean>;
+    userTranslations(args: IndexedByFrom, tracingConfig?: RequestTracingConfig): Promise<MessageListV2[]>;
+}

package/lib/clients/apps/MessagesGraphQL.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const AppGraphQLClient_1 = require("./AppGraphQLClient");
+const MAX_BATCH_SIZE = 500;
+class MessagesGraphQL extends AppGraphQLClient_1.AppGraphQLClient {
+    constructor(vtex, options) {
+        super('vtex.messages@1.x', vtex, options);
+    }
+    translateV2(args, tracingConfig) {
+        const { indexedByFrom, ...rest } = args;
+        const allMessages = indexedByFrom.reduce((acc, { from, messages }) => {
+            return acc.concat(messages.map(message => ({ from, message })));
+        }, []);
+        const batchedMessages = ramda_1.splitEvery(MAX_BATCH_SIZE, allMessages);
+        const metric = 'messages-translate-v2';
+        return Promise.all(batchedMessages.map(batch => {
+            const indexedBatch = batch.reduce((acc, { from, message }) => {
+                if (!acc[from]) {
+                    acc[from] = {
+                        from,
+                        messages: [],
+                    };
+                }
+                acc[from].messages.push(message);
+                return acc;
+            }, {});
+            const batchArgs = {
+                ...rest,
+                indexedByFrom: ramda_1.values(indexedBatch),
+            };
+            return this.graphql.query({
+                query: `
+      query Translate($args: TranslateArgs!) {
+        translate(args: $args)
+      }
+      `,
+                variables: { args: batchArgs },
+            }, {
+                metric,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            }).then(ramda_1.path(['data', 'translate']));
+        })).then(ramda_1.flatten);
+    }
+    async translate(args, tracingConfig) {
+        const metric = 'messages-translate-v2';
+        const response = await this.graphql.query({
+            query: `query Translate($args: TranslateArgs!) {
+          translate(args: $args)
+        }`,
+            variables: { args },
+        }, {
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+        return response.data.translate;
+    }
+    async translateWithDependencies(args, tracingConfig) {
+        const metric = 'messages-translate-with-deps-v2';
+        const response = await this.graphql.query({
+            query: `query TranslateWithDeps($args: TranslateWithDependenciesArgs!) {
+          translateWithDependencies(args: $args)
+        }`,
+            variables: { args },
+        }, {
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+        return response.data.translateWithDependencies;
+    }
+    async saveV2(args, tracingConfig) {
+        const metric = 'messages-saveV2-translation';
+        const response = await this.graphql.mutate({
+            mutate: `mutation SaveV2($args: SaveArgsV2!) {
+          saveV2(args: $args)
+        }`,
+            variables: { args },
+        }, {
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+        return response.data.saveV2;
+    }
+    async userTranslations(args, tracingConfig) {
+        const metric = 'messages-user-translations';
+        const response = await this.graphql.query({
+            query: `query UserTranslations($args: IndexedMessages!){
+          userTranslations(args: $args) {
+            srcLang
+            groupContext
+            context
+            translations {
+              lang
+              translation
+            }
+          }
+        }`,
+            variables: { args },
+        }, {
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+        return response.data.userTranslations;
+    }
+}
+exports.MessagesGraphQL = MessagesGraphQL;

package/lib/clients/apps/Settings.d.ts

@@ -0,0 +1,14 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { AppMetaInfo } from '../infra/Apps';
+import { AppClient } from './AppClient';
+export interface SettingsParams {
+    merge?: boolean;
+    files?: string[];
+}
+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>;
+}

package/lib/clients/apps/Settings.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 LINKED_ROUTE = 'linked';
+const containsLinks = ramda_1.any(app_1.isLinkedApp);
+class Settings extends AppClient_1.AppClient {
+    constructor(context, options) {
+        super('vtex.settings-server@0.x', context, options);
+    }
+    getFilteredDependencies(appAtMajor, dependencies) {
+        return settings_1.getFilteredDependencies(appAtMajor, dependencies);
+    }
+    getDependenciesHash(dependencies) {
+        return settings_1.getDependenciesHash(dependencies);
+    }
+    async getSettings(dependencies, appAtMajor, params, tracingConfig) {
+        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,
+            params,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+}
+exports.Settings = Settings;

package/lib/clients/apps/catalogGraphQL/brand.d.ts

@@ -0,0 +1,13 @@
+export declare const query = "\nquery GetBrand($id: ID!) {\n  brand (id: $id) {\n    id\n    name\n    text\n    keywords\n    siteTitle\n    active\n    menuHome\n    adWordsRemarketingCode\n    lomadeeCampaignCode\n    score\n  }\n}\n";
+export interface Brand {
+    id: string;
+    name: string;
+    text?: string;
+    keywords?: string[];
+    siteTitle?: string;
+    active: boolean;
+    menuHome: boolean;
+    adWordsRemarketingCode?: string;
+    lomadeeCampaignCode?: string;
+    score?: number;
+}