@vtex/api 6.45.4

package/lib/utils/appsStaleIfError.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { AppMetaInfo, Apps } from '..';
+import { CacheLayer } from '../caches';
+import { Logger } from '../service/logger';
+export declare const getMetaInfoKey: (account: string, workspace: string) => string;
+export declare const updateMetaInfoCache: (cacheStorage: CacheLayer<string, AppMetaInfo[]>, account: string, workspace: string, dependencies: AppMetaInfo[], logger: Logger) => Promise<void>;
+export declare const saveVersion: (app: string, cacheStorage: CacheLayer<string, string>) => Promise<void>;
+export declare const getFallbackFile: (app: string, path: string, cacheStorage: CacheLayer<string, string>, apps: Apps) => Promise<{
+    data: Buffer;
+    headers: any;
+}>;

package/lib/utils/appsStaleIfError.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const ramda_1 = require("ramda");
+const semver = __importStar(require("semver"));
+exports.getMetaInfoKey = (account, workspace) => `${account}-${workspace}-meta-infos`;
+const hashMD5 = (text) => crypto_1.default
+    .createHash('md5')
+    .update(text)
+    .digest('hex');
+exports.updateMetaInfoCache = async (cacheStorage, account, workspace, dependencies, logger) => {
+    if (workspace !== 'master') {
+        return;
+    }
+    const key = exports.getMetaInfoKey(account, workspace);
+    const hash = hashMD5(dependencies.toString());
+    try {
+        const storedDependencies = await cacheStorage.get(key) || '';
+        if (hash !== hashMD5(storedDependencies.toString())) {
+            await cacheStorage.set(key, dependencies);
+        }
+    }
+    catch (error) {
+        logger.error({ error, message: 'Apps disk cache update failed' });
+    }
+    return;
+};
+const getFallbackKey = (appName, major) => `${appName}@${major}`;
+exports.saveVersion = async (app, cacheStorage) => {
+    const [appName, version] = app.split('@');
+    const major = ramda_1.head(version.split('.')) || '';
+    const fallbackKey = getFallbackKey(appName, major);
+    if (cacheStorage.has(fallbackKey)) {
+        const savedVersion = await cacheStorage.get(fallbackKey);
+        if (savedVersion && (version === `${major}.x` || semver.gt(version, savedVersion))) {
+            await cacheStorage.set(fallbackKey, version);
+        }
+    }
+    else {
+        await cacheStorage.set(fallbackKey, version);
+    }
+};
+exports.getFallbackFile = async (app, path, cacheStorage, apps) => {
+    const [appName, version] = app.split('@');
+    const major = ramda_1.head(version.split('.')) || '';
+    const fallbackKey = getFallbackKey(appName, major);
+    const fallbackVersion = await cacheStorage.get(fallbackKey);
+    if (fallbackVersion) {
+        const appFallbackVersion = `${appName}@${fallbackVersion}`;
+        return apps.getAppFile(appFallbackVersion, path);
+    }
+    throw Error('Fallback version was not found');
+};

package/lib/utils/billingOptions.d.ts

@@ -0,0 +1,36 @@
+export declare const isFreeBillingOptions: (billingOptions: BillingOptions) => boolean;
+export interface BillingOptions {
+    type: BILLING_TYPE;
+    support: Support;
+    availableCountries: string[];
+    plans?: Plan[];
+}
+export declare enum BILLING_TYPE {
+    FREE = "free",
+    BILLABLE = "billable",
+    SPONSORED = "sponsored"
+}
+export interface PriceMetric {
+    id: string;
+    ranges: Range[];
+    customUrl: string;
+}
+export interface Range {
+    exclusiveFrom: number;
+    inclusiveTo?: number;
+    multiplier: number;
+}
+export interface Plan {
+    id: string;
+    currency: string;
+    price: Price;
+}
+export interface Price {
+    subscription?: number;
+    metrics?: PriceMetric[];
+}
+export interface Support {
+    email: string;
+    url?: string;
+    phone?: string;
+}

package/lib/utils/billingOptions.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFreeBillingOptions = (billingOptions) => billingOptions.type === BILLING_TYPE.FREE;
+var BILLING_TYPE;
+(function (BILLING_TYPE) {
+    BILLING_TYPE["FREE"] = "free";
+    BILLING_TYPE["BILLABLE"] = "billable";
+    BILLING_TYPE["SPONSORED"] = "sponsored";
+})(BILLING_TYPE = exports.BILLING_TYPE || (exports.BILLING_TYPE = {}));

package/lib/utils/binding.d.ts

@@ -0,0 +1,13 @@
+export interface BindingHeader {
+    id?: string;
+    rootPath?: string;
+    locale: string;
+    currency?: string;
+}
+declare enum BindingHeaderFormat {
+    webframework0 = "v0+webframework",
+    kuberouter0 = "v0+kuberouter"
+}
+export declare const formatBindingHeaderValue: (binding: BindingHeader, format?: BindingHeaderFormat) => string;
+export declare const parseBindingHeaderValue: (value: string) => BindingHeader;
+export {};

package/lib/utils/binding.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BindingHeaderFormat;
+(function (BindingHeaderFormat) {
+    BindingHeaderFormat["webframework0"] = "v0+webframework";
+    BindingHeaderFormat["kuberouter0"] = "v0+kuberouter";
+})(BindingHeaderFormat || (BindingHeaderFormat = {}));
+exports.formatBindingHeaderValue = (binding, format = BindingHeaderFormat.webframework0) => {
+    if (format === BindingHeaderFormat.webframework0) {
+        const jsonString = JSON.stringify(binding);
+        return Buffer.from(jsonString, 'utf8').toString('base64');
+    }
+    if (format === BindingHeaderFormat.kuberouter0) {
+        return [
+            '0',
+            binding.id || '',
+            binding.rootPath || '',
+            binding.locale || '',
+            binding.currency || '',
+        ].join(',');
+    }
+    throw new Error(`Unkown binding format: ${format}`);
+};
+exports.parseBindingHeaderValue = (value) => {
+    if (value[0] === '0' && value[1] === ',') {
+        // v0+kuberouter
+        const [, id, rootPath, locale, currency] = value.split(',');
+        return {
+            currency: currency || undefined,
+            id: id || undefined,
+            locale,
+            rootPath: rootPath || undefined,
+        };
+    }
+    // v0+webframework
+    const jsonString = Buffer.from(value, 'base64').toString('utf8');
+    return JSON.parse(jsonString);
+};

package/lib/utils/cancel.d.ts

@@ -0,0 +1,3 @@
+import { ParamsContext, RecorderState, RouteHandler } from '../service/worker/runtime/typings';
+import { IOClients } from './../clients/IOClients';
+export declare function cancel<T extends IOClients, U extends RecorderState, V extends ParamsContext>(middleware: RouteHandler<T, U, V>): RouteHandler<T, U, V>;

package/lib/utils/cancel.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function cancel(middleware) {
+    return async (ctx, next) => {
+        var _a, _b;
+        if ((_b = (_a = ctx.vtex) === null || _a === void 0 ? void 0 : _a.cancellation) === null || _b === void 0 ? void 0 : _b.cancelled) {
+            return;
+        }
+        await middleware(ctx, next);
+    };
+}
+exports.cancel = cancel;

package/lib/utils/domain.d.ts

@@ -0,0 +1 @@
+export declare const PUBLIC_DOMAINS: string[];

package/lib/utils/domain.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+const VTEX_PUBLIC_ENDPOINT = process.env.VTEX_PUBLIC_ENDPOINT || 'myvtex.com';
+exports.PUBLIC_DOMAINS = ramda_1.uniq([VTEX_PUBLIC_ENDPOINT, 'myvtex.com', 'mygocommerce.com', 'vtexsmb.com']);

package/lib/utils/error.d.ts

@@ -0,0 +1,8 @@
+export declare const PICKED_AXIOS_PROPS: string[];
+export declare const SENSITIVE_EXCEPTION_FIELDS: string[];
+/**
+ * Cleans errors by removing circular properties, truncating large strings and picking axios properties
+ *
+ * @param value an Error instance
+ */
+export declare const cleanError: (value: any) => any;

package/lib/utils/error.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Inspired by https://github.com/sindresorhus/serialize-error
+const ramda_1 = require("ramda");
+exports.PICKED_AXIOS_PROPS = ['baseURL', 'cacheable', 'data', 'finished', 'headers', 'method', 'timeout', 'status', 'path', 'url', 'metric', 'inflightKey', 'forceMaxAge', 'params', 'responseType'];
+exports.SENSITIVE_EXCEPTION_FIELDS = ['config', 'request', 'stack'];
+const MAX_ERROR_STRING_LENGTH = process.env.MAX_ERROR_STRING_LENGTH ? parseInt(process.env.MAX_ERROR_STRING_LENGTH, 10) : 8 * 1024;
+const findCaseInsensitive = (target, set) => ramda_1.find(t => t.toLocaleLowerCase() === target, set);
+const destroyCircular = (from, seen) => {
+    const to = Array.isArray(from) ? [] : {};
+    seen.push(from);
+    for (const [key, value] of Object.entries(from)) {
+        // Skip functions
+        if (typeof value === 'function') {
+            continue;
+        }
+        // Skip "private" properties
+        if (key.startsWith('_')) {
+            continue;
+        }
+        if (!value || typeof value !== 'object') {
+            // Truncate very large strings
+            if (typeof value === 'string' && value.length > MAX_ERROR_STRING_LENGTH) {
+                to[key] = value.substr(0, MAX_ERROR_STRING_LENGTH) + '[...TRUNCATED]';
+            }
+            else {
+                to[key] = value;
+            }
+            continue;
+        }
+        if (!seen.includes(from[key])) {
+            to[key] = destroyCircular(from[key], seen.slice());
+            continue;
+        }
+        to[key] = '[Circular]';
+    }
+    const commonProperties = [
+        'name',
+        'message',
+        'stack',
+        'code',
+    ];
+    for (const property of commonProperties) {
+        if (typeof from[property] === 'string') {
+            to[property] = from[property];
+        }
+    }
+    const axiosProperties = [
+        'config',
+        'request',
+        'response',
+    ];
+    for (const property of axiosProperties) {
+        if (to[property] != null && typeof to[property] === 'object') {
+            to[property] = ramda_1.pick(exports.PICKED_AXIOS_PROPS, to[property]);
+            const headers = to[property] && to[property].headers;
+            if (headers) {
+                const headerNames = ramda_1.keys(headers);
+                const authorization = findCaseInsensitive('authorization', headerNames);
+                if (!!authorization) {
+                    delete headers[authorization];
+                }
+                const proxyAuth = findCaseInsensitive('proxy-authorization', headerNames);
+                if (!!proxyAuth) {
+                    delete headers[proxyAuth];
+                }
+                const vtexIdClientAutCookie = findCaseInsensitive('vtexidclientautcookie', headerNames);
+                if (!!vtexIdClientAutCookie) {
+                    delete headers[vtexIdClientAutCookie];
+                }
+            }
+        }
+    }
+    if (!to.code && to.response) {
+        to.code = to.response.status && `E_HTTP_${to.response.status}` || 'E_UNKNOWN';
+    }
+    return to;
+};
+/**
+ * Cleans errors by removing circular properties, truncating large strings and picking axios properties
+ *
+ * @param value an Error instance
+ */
+exports.cleanError = (value) => {
+    if (typeof value === 'object') {
+        return destroyCircular(value, []);
+    }
+    // People sometimes throw things besides Error objects…
+    if (typeof value === 'function') {
+        // `JSON.stringify()` discards functions. We do too, unless a function is thrown directly.
+        return `[Function: ${(value.name || 'anonymous')}]`;
+    }
+    return value;
+};

package/lib/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './app';
+export * from './error';
+export * from './retry';
+export * from './time';
+export * from './billingOptions';
+export * from './domain';
+export * from './tenant';
+export * from './binding';
+export * from './MineWinsConflictsResolver';

package/lib/utils/index.js

@@ -0,0 +1,14 @@
+"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("./app"));
+__export(require("./error"));
+__export(require("./retry"));
+__export(require("./time"));
+__export(require("./billingOptions"));
+__export(require("./domain"));
+__export(require("./tenant"));
+__export(require("./binding"));
+__export(require("./MineWinsConflictsResolver"));

package/lib/utils/message.d.ts

@@ -0,0 +1,25 @@
+export declare const PROVIDER_SPACER = "::";
+export interface IOMessage {
+    id: string;
+    content?: string;
+    description?: string;
+    from?: string;
+    to?: string;
+    behavior?: string;
+}
+export declare const providerFromMessage: (message: IOMessage) => string;
+export declare const parseIOMessageId: ({ id }: IOMessage) => {
+    locator: string;
+    provider: string;
+} | {
+    locator: string;
+    provider?: undefined;
+};
+export declare const removeProviderFromId: (message: IOMessage) => {
+    id: string;
+    content?: string | undefined;
+    description?: string | undefined;
+    from?: string | undefined;
+    to?: string | undefined;
+    behavior?: string | undefined;
+};

package/lib/utils/message.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_SPACER = '::';
+exports.providerFromMessage = (message) => {
+    const { provider } = exports.parseIOMessageId(message);
+    return provider || 'unknown';
+};
+exports.parseIOMessageId = ({ id }) => {
+    const splitted = id.split(exports.PROVIDER_SPACER);
+    if (splitted.length === 2) {
+        return {
+            locator: splitted[1],
+            provider: splitted[0],
+        };
+    }
+    return {
+        locator: splitted[0],
+    };
+};
+exports.removeProviderFromId = (message) => ({
+    ...message,
+    id: exports.parseIOMessageId(message).locator,
+});

package/lib/utils/renameBy.d.ts

@@ -0,0 +1 @@
+export declare const renameBy: <K>(fn: (key: string) => string, obj: Record<string, K>) => Record<string, K>;

package/lib/utils/renameBy.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ramda_1 = require("ramda");
+exports.renameBy = (fn, obj) => ramda_1.compose(ramda_1.fromPairs, ramda_1.map(([key, val]) => [fn(key), val]), ramda_1.toPairs)(obj);

package/lib/utils/retry.d.ts

@@ -0,0 +1,4 @@
+export declare const TIMEOUT_CODE = "ProxyTimeout";
+export declare const isNetworkErrorOrRouterTimeout: (e: any) => boolean;
+export declare const isAbortedOrNetworkErrorOrRouterTimeout: (e: any) => boolean;
+export { isNetworkOrIdempotentRequestError, exponentialDelay } from 'axios-retry';

package/lib/utils/retry.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_retry_1 = require("axios-retry");
+exports.TIMEOUT_CODE = 'ProxyTimeout';
+const printLabel = (e, message) => {
+    if (!e || !e.config || !e.config.label) {
+        return;
+    }
+    console.warn(e.config.label, message);
+};
+exports.isNetworkErrorOrRouterTimeout = (e) => {
+    if (axios_retry_1.isNetworkOrIdempotentRequestError(e)) {
+        printLabel(e, 'Retry from network error');
+        return true;
+    }
+    if (e && axios_retry_1.isSafeRequestError(e) && e.response && e.response.data && e.response.data.code === exports.TIMEOUT_CODE) {
+        printLabel(e, 'Retry from timeout');
+        return true;
+    }
+    return false;
+};
+// Retry on timeout from our end
+exports.isAbortedOrNetworkErrorOrRouterTimeout = (e) => {
+    if (e && e.code === 'ECONNABORTED') {
+        printLabel(e, 'Retry from abort');
+        return true;
+    }
+    return exports.isNetworkErrorOrRouterTimeout(e);
+};
+var axios_retry_2 = require("axios-retry");
+exports.isNetworkOrIdempotentRequestError = axios_retry_2.isNetworkOrIdempotentRequestError;
+exports.exponentialDelay = axios_retry_2.exponentialDelay;

package/lib/utils/status.d.ts

@@ -0,0 +1 @@
+export declare const statusLabel: (status: number) => string;