@vtex/api 6.45.4

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

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable, Writable } from 'stream';
+import { ZlibOptions } from 'zlib';
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { AppBundlePublished, AppFilesList, AppManifest, AppState } from '../../responses';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class Registry extends InfraClient {
+    constructor(context: IOContext, options?: InstanceOptions);
+    getAppState: (app: string, version: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<AppState>;
+    publishApp: (files: File[], tag?: string | undefined, { zlib }?: ZipOptions, tracingConfig?: RequestTracingConfig | undefined) => Promise<AppBundlePublished>;
+    publishAppRc: (files: File[], tag?: string | undefined, { zlib }?: ZipOptions, tracingConfig?: RequestTracingConfig | undefined) => Promise<AppBundlePublished>;
+    listApps: (tracingConfig?: RequestTracingConfig | undefined) => Promise<RegistryAppsList>;
+    listVersionsByApp: (app: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<RegistryAppVersionsList>;
+    deprecateApp: (app: string, version: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<void>;
+    undeprecateApp: (app: string, version: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<void>;
+    validateApp: (app: string, version: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<void>;
+    getAppManifest: (app: string, version: string, opts?: AppsManifestOptions | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<AppManifest>;
+    listAppFiles: (app: string, version: string, opts?: ListAppFilesOptions | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<AppFilesList>;
+    getAppFile: (app: string, version: string, path: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getAppJSON: <T extends object | null>(app: string, version: string, path: string, nullIfNotFound?: boolean | undefined, tracingConfig?: RequestTracingConfig | undefined) => Promise<T>;
+    getAppFileStream: (app: string, version: string, path: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<IncomingMessage>;
+    getAppBundle: (app: string, version: string, bundlePath: string, generatePackageJson: boolean, tracingConfig?: RequestTracingConfig | undefined) => Promise<Readable>;
+    unpackAppBundle: (app: string, version: string, bundlePath: string, unpackPath: string, generatePackageJson: boolean, tracingConfig?: RequestTracingConfig | undefined) => Promise<Writable>;
+    resolveDependenciesWithManifest: (manifest: AppManifest, filter?: string, tracingConfig?: RequestTracingConfig | undefined) => Promise<Record<string, string[]>>;
+    private publish;
+}
+interface ZipOptions {
+    zlib?: ZlibOptions;
+}
+export interface AppsManifestOptions {
+    resolveDeps: boolean;
+}
+export interface ListAppFilesOptions {
+    prefix: string;
+}
+export interface RegistryAppsListItem {
+    partialIdentifier: string;
+    location: string;
+}
+export interface RegistryAppsList {
+    data: RegistryAppsListItem[];
+}
+export interface RegistryAppVersionsListItem {
+    versionIdentifier: string;
+    location: string;
+}
+export interface RegistryAppVersionsList {
+    data: RegistryAppVersionsListItem[];
+}
+export interface File {
+    path: string;
+    content: any;
+}
+export {};

package/lib/clients/infra/Registry.js

@@ -0,0 +1,207 @@
+"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 tar_fs_1 = require("tar-fs");
+const zlib_1 = require("zlib");
+const constants_1 = require("../../constants");
+const HttpClient_1 = require("../../HttpClient");
+const InfraClient_1 = require("./InfraClient");
+const EMPTY_OBJECT = {};
+const routes = {
+    App: (app) => `${routes.Registry}/${app}`,
+    AppBundle: (app, version, path) => {
+        return path ? `${routes.AppVersion(app, version)}/bundle/${path}` : `${routes.AppVersion(app, version)}/bundle`;
+    },
+    AppFile: (app, version, path) => `${routes.AppFiles(app, version)}/${path}`,
+    AppFiles: (app, version) => `${routes.AppVersion(app, version)}/files`,
+    AppState: (app, version) => `${routes.AppVersion(app, version)}/state`,
+    AppVersion: (app, version) => `${routes.App(app)}/${version}`,
+    Publish: '/v2/registry',
+    PublishRc: '/v2/registry/rc',
+    Registry: '/registry',
+    ResolveDependenciesWithManifest: '/v2/registry/_resolve',
+};
+class Registry extends InfraClient_1.InfraClient {
+    constructor(context, options) {
+        super('apps@0.x', { ...context, workspace: constants_1.DEFAULT_WORKSPACE }, options);
+        this.getAppState = (app, version, tracingConfig) => {
+            const metric = 'registry-app-state';
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            return this.http.get(routes.AppState(app, version), {
+                inflightKey,
+                metric,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.publishApp = (files, tag, { zlib } = {}, tracingConfig) => {
+            return this.publish(routes.Publish, files, tag, { zlib }, tracingConfig);
+        };
+        this.publishAppRc = (files, tag, { zlib } = {}, tracingConfig) => {
+            return this.publish(routes.PublishRc, files, tag, { zlib }, tracingConfig);
+        };
+        this.listApps = (tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'registry-list';
+            return this.http.get(routes.Registry, { inflightKey, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.listVersionsByApp = (app, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'registry-list-versions';
+            return this.http.get(routes.App(app), { inflightKey, metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.deprecateApp = (app, version, tracingConfig) => {
+            const metric = 'registry-deprecate';
+            return this.http.patch(routes.AppVersion(app, version), { patchState: 'deprecate' }, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.undeprecateApp = (app, version, tracingConfig) => {
+            const metric = 'registry-undeprecate';
+            return this.http.patch(routes.AppVersion(app, version), { patchState: 'undeprecate' }, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.validateApp = (app, version, tracingConfig) => {
+            const metric = 'registry-validate';
+            return this.http.patch(routes.AppVersion(app, version), { patchState: 'validate' }, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getAppManifest = (app, version, opts, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            const params = opts;
+            const metric = 'registry-manifest';
+            return this.http.get(routes.AppVersion(app, version), { inflightKey, metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.listAppFiles = (app, version, opts, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightUrlWithQuery;
+            const params = opts;
+            const metric = 'registry-list-files';
+            return this.http.get(routes.AppFiles(app, version), { inflightKey, metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getAppFile = (app, version, path, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'registry-get-file';
+            return this.http.getBuffer(routes.AppFile(app, version, path), {
+                cacheable: HttpClient_1.CacheType.Disk,
+                inflightKey,
+                metric,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppJSON = (app, version, path, nullIfNotFound, tracingConfig) => {
+            const inflightKey = HttpClient_1.inflightURL;
+            const metric = 'registry-get-json';
+            return this.http.get(routes.AppFile(app, version, path), {
+                cacheable: HttpClient_1.CacheType.Any,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppFileStream = (app, version, path, tracingConfig) => {
+            const metric = 'registry-get-file-s';
+            return this.http.getStream(routes.AppFile(app, version, path), {
+                metric,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.getAppBundle = (app, version, bundlePath, generatePackageJson, tracingConfig) => {
+            const params = generatePackageJson && { _packageJSONEngine: 'npm', _packageJSONFilter: 'vtex.render-builder@x' };
+            const metric = 'registry-get-bundle';
+            return this.http.getStream(routes.AppBundle(app, version, bundlePath), {
+                headers: {
+                    Accept: 'application/x-gzip',
+                    'Accept-Encoding': 'gzip',
+                },
+                metric,
+                params,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.unpackAppBundle = (app, version, bundlePath, unpackPath, generatePackageJson, tracingConfig) => {
+            return this.getAppBundle(app, version, bundlePath, generatePackageJson, tracingConfig)
+                .then(stream => stream
+                .pipe(zlib_1.createGunzip())
+                .pipe(tar_fs_1.extract(unpackPath)));
+        };
+        this.resolveDependenciesWithManifest = (manifest, filter = '', tracingConfig) => {
+            const params = { filter };
+            const metric = 'registry-resolve-deps';
+            return this.http.post(routes.ResolveDependenciesWithManifest, manifest, { metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.publish = async (route, files, tag, { zlib } = {}, 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 metric = 'registry-publish';
+            const request = this.http.post(route, zip, {
+                headers: { 'Content-Type': 'application/zip' },
+                metric,
+                params: tag ? { tag } : EMPTY_OBJECT,
+                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();
+            try {
+                const [response] = await Promise.all([request, finalize]);
+                response.bundleSize = zip.pointer();
+                return response;
+            }
+            catch (e) {
+                e.bundleSize = zip.pointer();
+                throw e;
+            }
+        };
+    }
+}
+exports.Registry = Registry;

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,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 } 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<void>;
+    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>;
+}