@vtex/api 6.45.4

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

@@ -0,0 +1,34 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import { AppMetaInfo } from '../..';
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export interface AssetsParams {
+    files?: string[];
+    pick?: string[];
+}
+export declare class Assets extends InfraClient {
+    private routes;
+    constructor(context: IOContext, options?: InstanceOptions);
+    getSettings(dependencies: AppMetaInfo[], appAtMajor: string, params?: AssetsParams, tracingConfig?: RequestTracingConfig): Promise<Record<string, any>[]>;
+    getBuildJSONForApp(app: AppMetaInfo, appVendorName: string, pick?: string | string[], tracingConfig?: RequestTracingConfig): Promise<Record<string, any>>;
+    getSettingsFromFilesForApp(app: AppMetaInfo, files?: string | string[], tracingConfig?: RequestTracingConfig): Promise<Record<string, any>>;
+    getJSON<T extends object | null>(appId: string, file: string, nullIfNotFound?: boolean, tracingConfig?: RequestTracingConfig): Promise<T>;
+    getFile(appId: string, file: string, nullIfNotFound?: boolean, tracingConfig?: RequestTracingConfig): Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getFilteredDependencies(apps: string | string[], dependencies: AppMetaInfo[]): AppMetaInfo[];
+    getAppBundleByVendor: (app: string, bundlePath: string, generatePackageJson: boolean, tracingConfig?: RequestTracingConfig | undefined) => Promise<Readable>;
+    protected getAppJSONByAccount: <T extends object | null>(app: string, path: string, nullIfNotFound?: boolean | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<T>;
+    protected getAppJSONByVendor: <T extends object | null>(app: string, path: string, nullIfNotFound?: boolean | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<T>;
+    protected getAppFileByAccount: (app: string, path: string, nullIfNotFound?: boolean | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    protected getAppFileByVendor: (app: string, path: string, nullIfNotFound?: boolean | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+}

package/lib/clients/infra/Assets.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const HttpClient_1 = require("../../HttpClient");
+const utils_1 = require("../../utils");
+const InfraClient_1 = require("./InfraClient");
+const dependsOnApp = (appsAtMajor) => (a) => {
+    let dependsOn = false;
+    appsAtMajor.forEach(appAtMajor => {
+        const [name, major] = appAtMajor.split('@');
+        const sanitizedMajor = major.includes('.') ? major.split('.')[0] : major;
+        const version = a._resolvedDependencies[name];
+        if (version) {
+            const [depMajor] = version.split('.');
+            if (sanitizedMajor === depMajor) {
+                dependsOn = true;
+            }
+        }
+    });
+    return dependsOn;
+};
+const useBuildJson = (app, appVendorName) => {
+    const buildFeatures = app._buildFeatures;
+    return buildFeatures && buildFeatures[appVendorName] && ramda_1.contains('build.json', buildFeatures[appVendorName]);
+};
+const appOrRegistry = (workspace, { name, version, build }) => build
+    ? `${workspace}/apps/${name}@${version}+${build}`
+    : `master/registry/${name}/${version}`;
+const createRoutes = (workspace) => ({
+    Bundle: (scope, locator, path) => `/${scope}/${appOrRegistry(workspace, locator)}/bundle/${path}`,
+    Files: (scope, locator, path) => `/${scope}/${appOrRegistry(workspace, locator)}/files/${path}`,
+});
+class Assets extends InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('apps@0.x', context, options, true);
+        this.getAppBundleByVendor = (app, bundlePath, generatePackageJson, tracingConfig) => {
+            const locator = utils_1.parseAppId(app);
+            const params = generatePackageJson && { _packageJSONEngine: 'npm', _packageJSONFilter: 'vtex.render-builder@x' };
+            const metric = locator.build ? 'apps-get-bundle' : 'registry-get-bundle';
+            return this.http.getStream(this.routes.Bundle(this.context.account, locator, bundlePath), {
+                headers: {
+                    Accept: 'application/x-gzip',
+                    'Accept-Encoding': 'gzip',
+                },
+                metric,
+                params,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppJSONByAccount = (app, path, nullIfNotFound, tracingConfig) => {
+            const locator = utils_1.parseAppId(app);
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'assets-get-json-by-account';
+            return this.http.get(this.routes.Files(this.context.account, locator, path), {
+                cacheable: HttpClient_1.CacheType.Memory,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppJSONByVendor = (app, path, nullIfNotFound, tracingConfig) => {
+            const locator = utils_1.parseAppId(app);
+            const vendor = locator.name.split('.')[0];
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'assets-get-json-by-vendor';
+            return this.http.get(this.routes.Files(vendor, locator, path), {
+                cacheable: HttpClient_1.CacheType.Any,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppFileByAccount = (app, path, nullIfNotFound, tracingConfig) => {
+            const locator = utils_1.parseAppId(app);
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'assets-get-file-by-account';
+            return this.http.getBuffer(this.routes.Files(this.context.account, locator, path), {
+                cacheable: HttpClient_1.CacheType.Any,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppFileByVendor = (app, path, nullIfNotFound, tracingConfig) => {
+            const locator = utils_1.parseAppId(app);
+            const vendor = locator.name.split('.')[0];
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'assets-get-file-by-vendor';
+            return this.http.getBuffer(this.routes.Files(vendor, locator, path), {
+                cacheable: HttpClient_1.CacheType.Any,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.routes = createRoutes(this.context.workspace);
+    }
+    getSettings(dependencies, appAtMajor, params = {}, tracingConfig) {
+        const { pick, files } = params;
+        const filtered = this.getFilteredDependencies(appAtMajor, dependencies);
+        return Promise.all(filtered.map(dependency => {
+            const [appVendorName] = appAtMajor.split('@');
+            const buildJson = useBuildJson(dependency, appVendorName);
+            return buildJson
+                ? this.getBuildJSONForApp(dependency, appVendorName, pick, tracingConfig)
+                : this.getSettingsFromFilesForApp(dependency, files, tracingConfig);
+        }));
+    }
+    async getBuildJSONForApp(app, appVendorName, pick = [], tracingConfig) {
+        const pickArray = Array.isArray(pick) ? pick : [pick];
+        const buildJson = await this.getJSON(app.id, `dist/${appVendorName}/build.json`, undefined, tracingConfig);
+        const result = !ramda_1.isEmpty(pickArray) ? ramda_1.pick(pickArray, buildJson) : buildJson;
+        result.declarer = app.id;
+        return result;
+    }
+    async getSettingsFromFilesForApp(app, files = [], tracingConfig) {
+        // If there's no support for build.json, then fetch individual files and zip them into an {[file]: content} object.
+        const filesArray = Array.isArray(files) ? files : [files];
+        const fetched = await Promise.all(filesArray.map(file => this.getJSON(app.id, file, true, tracingConfig)));
+        const result = ramda_1.zipObj(filesArray, fetched);
+        result.declarer = app.id;
+        return result;
+    }
+    async getJSON(appId, file, nullIfNotFound, tracingConfig) {
+        const locator = utils_1.parseAppId(appId);
+        const linked = !!locator.build;
+        if (linked) {
+            return this.getAppJSONByAccount(appId, file, nullIfNotFound, tracingConfig);
+        }
+        return this.getAppJSONByVendor(appId, file, nullIfNotFound, tracingConfig);
+    }
+    async getFile(appId, file, nullIfNotFound, tracingConfig) {
+        const locator = utils_1.parseAppId(appId);
+        const linked = !!locator.build;
+        if (linked) {
+            return this.getAppFileByAccount(appId, file, nullIfNotFound, tracingConfig);
+        }
+        return this.getAppFileByVendor(appId, file, nullIfNotFound, tracingConfig);
+    }
+    getFilteredDependencies(apps, dependencies) {
+        const appsAtMajor = typeof (apps) === 'string' ? [apps] : apps;
+        const depends = dependsOnApp(appsAtMajor);
+        return ramda_1.filter(depends, dependencies);
+    }
+}
+exports.Assets = Assets;

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

@@ -0,0 +1,13 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class BillingMetrics extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    sendMetric: (metric: BillingMetric, tracingConfig?: RequestTracingConfig | undefined) => Promise<BillingMetric>;
+}
+export interface BillingMetric {
+    value: number;
+    unit: string;
+    metricId: string;
+    timestamp?: number;
+}

package/lib/clients/infra/BillingMetrics.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const InfraClient_1 = require("./InfraClient");
+class BillingMetrics extends InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('colossus@0.x', context, options);
+        this.sendMetric = (metric, tracingConfig) => {
+            return this.http.post('/metrics', metric, { tracing: {
+                    requestSpanNameSuffix: 'send-metric',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+    }
+}
+exports.BillingMetrics = BillingMetrics;

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

@@ -0,0 +1,12 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class Events extends InfraClient {
+    constructor({ recorder, ...context }: IOContext, options?: InstanceOptions);
+    sendEvent: (appIdOrResource: string | ResourceVRN, route: string, message?: any, tracingConfig?: RequestTracingConfig | undefined) => Promise<void>;
+    private resourceFor;
+}
+export interface ResourceVRN {
+    service: string;
+    path: string;
+}

package/lib/clients/infra/Events.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("util");
+const InfraClient_1 = require("./InfraClient");
+const ANY_APP = '';
+const eventRoute = (route) => `/events/${route}`;
+const isResourceVRN = (appIdOrResource) => util_1.isObject(appIdOrResource) && !util_1.isNullOrUndefined(appIdOrResource.service);
+class Events extends InfraClient_1.InfraClient {
+    constructor({ recorder, ...context }, options) {
+        super('courier@0.x', context, options);
+        this.sendEvent = (appIdOrResource, route, message, tracingConfig) => {
+            const resource = this.resourceFor(appIdOrResource);
+            return this.http.put(eventRoute(route), message, {
+                metric: 'events-send',
+                params: { resource },
+                tracing: {
+                    requestSpanNameSuffix: 'events-send',
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.resourceFor = (appIdOrResource) => {
+            if (appIdOrResource === ANY_APP) {
+                return ANY_APP;
+            }
+            const { service, path } = isResourceVRN(appIdOrResource)
+                ? appIdOrResource
+                : { service: 'apps', path: `/apps/${appIdOrResource}` };
+            return `vrn:${service}:${this.context.region}:${this.context.account}:${this.context.workspace}:${path}`;
+        };
+    }
+}
+exports.Events = Events;

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

@@ -0,0 +1,10 @@
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { HousekeeperStatesAndUpdates } from '../../responses';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class Housekeeper extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    apply: (data: HousekeeperStatesAndUpdates, tracingConfig?: RequestTracingConfig | undefined) => Promise<void>;
+    perform: (tracingConfig?: RequestTracingConfig | undefined) => Promise<void>;
+    resolve: (tracingConfig?: RequestTracingConfig | undefined) => Promise<HousekeeperStatesAndUpdates>;
+}

package/lib/clients/infra/Housekeeper.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const InfraClient_1 = require("./InfraClient");
+class Housekeeper extends InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('housekeeper@0.x', context, options);
+        this.apply = async (data, tracingConfig) => {
+            const metric = 'housekeeper-apply';
+            return this.http.post('v2/housekeeping/apply', data, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.perform = async (tracingConfig) => {
+            const metric = 'housekeeper-perform';
+            return this.http.post('v2/_housekeeping/perform', {}, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.resolve = async (tracingConfig) => {
+            const metric = 'housekeeper-resolve';
+            return this.http.get('v2/housekeeping/resolve', { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+    }
+}
+exports.Housekeeper = Housekeeper;

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

@@ -0,0 +1,9 @@
+import { InstanceOptions } from '../../HttpClient/typings';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { IOClient } from '../IOClient';
+/**
+ * Used to perform calls on infra apps (e.g. sphinx, apps, vbase).
+ */
+export declare class InfraClient extends IOClient {
+    constructor(app: string, context: IOContext, options?: InstanceOptions, isRoot?: boolean);
+}

package/lib/clients/infra/InfraClient.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
+const typings_1 = require("../../HttpClient/typings");
+const IOClient_1 = require("../IOClient");
+const useHttps = !constants_1.IS_IO;
+/**
+ * Used to perform calls on infra apps (e.g. sphinx, apps, vbase).
+ */
+class InfraClient extends IOClient_1.IOClient {
+    constructor(app, context, options, isRoot = false) {
+        const { account, workspace, region } = context;
+        const [appName, appVersion] = app.split('@');
+        const protocol = useHttps ? 'https' : 'http';
+        let baseURL;
+        if (appVersion) {
+            const [appMajor] = appVersion.split('.');
+            baseURL = `${protocol}://infra.io.vtex.com/${appName}/v${appMajor}${isRoot ? '' : `/${account}/${workspace}`}`;
+        }
+        else if (app === 'router') {
+            baseURL = `${protocol}://platform.io.vtex.com/${isRoot ? '' : `/${account}/${workspace}`}`;
+        }
+        else {
+            console.warn(`${account} in ${workspace} is using old routing for ${app}. This will stop working soon`);
+            baseURL = `http://${app}.${region}.vtex.io${isRoot ? '' : `/${account}/${workspace}`}`;
+        }
+        super(context, {
+            ...options,
+            authType: typings_1.AuthType.bearer,
+            baseURL,
+        });
+    }
+}
+exports.InfraClient = InfraClient;

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

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

package/lib/clients/infra/Metadata.js

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