@vtex/api 6.48.1-beta → 6.48.1-beta.3

package/lib/tracing/errorReporting/ErrorReport.d.ts

@@ -0,0 +1,31 @@
+import { ErrorReportBase, ErrorReportCreateArgs } from '@vtex/node-error-report';
+import { Span } from 'opentracing';
+import { IOContext } from '../../service/worker/runtime/typings';
+export declare class ErrorReport extends ErrorReportBase {
+    /**
+     * Create a new ErrorReport wrapping args.originalError
+     *
+     * In case the args.originalError argument is already an ErrorReport
+     * instance, then ErrorReport.create just returns it. If it's not,
+     * it returns a new ErrorReport wrapping the error. This way you can
+     * use ErrorReport.create on a catchAll, e.g.:
+     *
+     * ```
+     * try {
+     *   await next()
+     * } catch(err) {
+     *   ErrorReport.create({ originalError: err }).injectOnSpan(span)
+     * }
+     * ```
+     *
+     * More docs on the ErrorReport available on: https://github.com/vtex/node-error-report
+     */
+    static create(args: ErrorReportCreateArgs): ErrorReport;
+    /**
+     * Inject information about the error wrapped by this ErrorReport
+     * instance on the provided Span. If a logger is provided and the
+     * span is part of a **sampled** trace, then the error will be logged.
+     */
+    injectOnSpan(span?: Span, logger?: IOContext['logger']): this;
+    private shouldLogToSplunk;
+}

package/lib/tracing/errorReporting/ErrorReport.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorReport = void 0;
+const node_error_report_1 = require("@vtex/node-error-report");
+const __1 = require("..");
+const utils_1 = require("../utils");
+class ErrorReport extends node_error_report_1.ErrorReportBase {
+    /**
+     * Create a new ErrorReport wrapping args.originalError
+     *
+     * In case the args.originalError argument is already an ErrorReport
+     * instance, then ErrorReport.create just returns it. If it's not,
+     * it returns a new ErrorReport wrapping the error. This way you can
+     * use ErrorReport.create on a catchAll, e.g.:
+     *
+     * ```
+     * try {
+     *   await next()
+     * } catch(err) {
+     *   ErrorReport.create({ originalError: err }).injectOnSpan(span)
+     * }
+     * ```
+     *
+     * More docs on the ErrorReport available on: https://github.com/vtex/node-error-report
+     */
+    static create(args) {
+        if (args.originalError instanceof ErrorReport) {
+            return args.originalError;
+        }
+        return new ErrorReport(node_error_report_1.createErrorReportBaseArgs(args));
+    }
+    /**
+     * Inject information about the error wrapped by this ErrorReport
+     * instance on the provided Span. If a logger is provided and the
+     * span is part of a **sampled** trace, then the error will be logged.
+     */
+    injectOnSpan(span, logger) {
+        var _a, _b, _c, _d;
+        span === null || span === void 0 ? void 0 : span.setTag(__1.TracingTags.ERROR, 'true');
+        const indexedLogs = {
+            ["error.kind" /* ERROR_KIND */]: this.kind,
+            ["error.id" /* ERROR_ID */]: this.metadata.errorId,
+        };
+        if (node_error_report_1.isRequestInfo(this.parsedInfo) &&
+            this.parsedInfo.response &&
+            node_error_report_1.isInfraErrorData((_a = this.parsedInfo.response) === null || _a === void 0 ? void 0 : _a.data)) {
+            indexedLogs["error.server.code" /* ERROR_SERVER_CODE */] = this.parsedInfo.response.data.code;
+            indexedLogs["error.server.request_id" /* ERROR_SERVER_REQUEST_ID */] = this.parsedInfo.response.data.requestId;
+        }
+        const serializableError = this.toObject();
+        span === null || span === void 0 ? void 0 : span.log({
+            event: 'error',
+            ...indexedLogs,
+            ["error.message" /* ERROR_MESSAGE */]: serializableError.message,
+            ["error.metadata.metrics.InstantiationTime" /* ERROR_METADATA_METRICS_INSTANTIATION_TIME */]: (_b = serializableError.metadata) === null || _b === void 0 ? void 0 : _b.reportCount,
+            ["error.metadata.reportCount" /* ERROR_METADATA_REPORT_COUNT */]: (_d = (_c = serializableError.metadata) === null || _c === void 0 ? void 0 : _c.metrics) === null || _d === void 0 ? void 0 : _d.instantiationTime,
+            ["error.stack" /* ERROR_STACK */]: serializableError.stack,
+            ["error.code" /* ERROR_CODE */]: serializableError.code,
+        });
+        if (logger && this.shouldLogToSplunk(span)) {
+            logger.error(serializableError);
+            this.markErrorAsReported();
+        }
+        return this;
+    }
+    shouldLogToSplunk(span) {
+        var _a;
+        return !this.isErrorReported() && ((_a = utils_1.getTraceInfo(span)) === null || _a === void 0 ? void 0 : _a.isSampled);
+    }
+}
+exports.ErrorReport = ErrorReport;

package/lib/tracing/index.d.ts

@@ -0,0 +1,9 @@
+import { FORMAT_HTTP_HEADERS, Span } from 'opentracing';
+export { ErrorKindsBase as ErrorKinds } from '@vtex/node-error-report';
+export { ErrorReport } from './errorReporting/ErrorReport';
+export { createSpanReference } from './spanReference/createSpanReference';
+export { SpanReferenceTypes } from './spanReference/SpanReferenceTypes';
+export { UserlandTags as TracingTags } from './Tags';
+export { createTracingContextFromCarrier, IUserLandTracer } from './UserLandTracer';
+export { getTraceInfo, TraceInfo } from './utils';
+export { Span, FORMAT_HTTP_HEADERS };

package/lib/tracing/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAT_HTTP_HEADERS = exports.Span = void 0;
+const opentracing_1 = require("opentracing");
+Object.defineProperty(exports, "FORMAT_HTTP_HEADERS", { enumerable: true, get: function () { return opentracing_1.FORMAT_HTTP_HEADERS; } });
+Object.defineProperty(exports, "Span", { enumerable: true, get: function () { return opentracing_1.Span; } });
+var node_error_report_1 = require("@vtex/node-error-report");
+Object.defineProperty(exports, "ErrorKinds", { enumerable: true, get: function () { return node_error_report_1.ErrorKindsBase; } });
+var ErrorReport_1 = require("./errorReporting/ErrorReport");
+Object.defineProperty(exports, "ErrorReport", { enumerable: true, get: function () { return ErrorReport_1.ErrorReport; } });
+var createSpanReference_1 = require("./spanReference/createSpanReference");
+Object.defineProperty(exports, "createSpanReference", { enumerable: true, get: function () { return createSpanReference_1.createSpanReference; } });
+var SpanReferenceTypes_1 = require("./spanReference/SpanReferenceTypes");
+Object.defineProperty(exports, "SpanReferenceTypes", { enumerable: true, get: function () { return SpanReferenceTypes_1.SpanReferenceTypes; } });
+var Tags_1 = require("./Tags");
+Object.defineProperty(exports, "TracingTags", { enumerable: true, get: function () { return Tags_1.UserlandTags; } });
+var UserLandTracer_1 = require("./UserLandTracer");
+Object.defineProperty(exports, "createTracingContextFromCarrier", { enumerable: true, get: function () { return UserLandTracer_1.createTracingContextFromCarrier; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "getTraceInfo", { enumerable: true, get: function () { return utils_1.getTraceInfo; } });

package/lib/tracing/spanReference/SpanReferenceTypes.d.ts

@@ -0,0 +1,4 @@
+export declare enum SpanReferenceTypes {
+    CHILD_OF = 0,
+    FOLLOWS_FROM = 1
+}

package/lib/tracing/spanReference/SpanReferenceTypes.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpanReferenceTypes = void 0;
+var SpanReferenceTypes;
+(function (SpanReferenceTypes) {
+    SpanReferenceTypes[SpanReferenceTypes["CHILD_OF"] = 0] = "CHILD_OF";
+    SpanReferenceTypes[SpanReferenceTypes["FOLLOWS_FROM"] = 1] = "FOLLOWS_FROM";
+})(SpanReferenceTypes = exports.SpanReferenceTypes || (exports.SpanReferenceTypes = {}));

package/lib/tracing/spanReference/createSpanReference.d.ts

@@ -0,0 +1,3 @@
+import { Reference, Span } from 'opentracing';
+import { SpanReferenceTypes } from './SpanReferenceTypes';
+export declare function createSpanReference(span: Span, type: SpanReferenceTypes): Reference;

package/lib/tracing/spanReference/createSpanReference.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSpanReference = void 0;
+const opentracing_1 = require("opentracing");
+const SpanReferenceTypes_1 = require("./SpanReferenceTypes");
+function createSpanReference(span, type) {
+    return new opentracing_1.Reference(type === SpanReferenceTypes_1.SpanReferenceTypes.CHILD_OF ? opentracing_1.REFERENCE_CHILD_OF : opentracing_1.REFERENCE_FOLLOWS_FROM, span.context());
+}
+exports.createSpanReference = createSpanReference;

package/lib/tracing/utils.d.ts

@@ -0,0 +1,13 @@
+import { Span } from 'opentracing';
+export interface TraceInfo {
+    traceId?: string;
+    isSampled: boolean;
+}
+export declare function getTraceInfo(span?: Span): TraceInfo;
+/**
+ * Do a shallow copy of a headers object and redacts sensitive information.
+ *
+ * @param headersObj The headers object
+ * @param resultFieldsPrefix The prefix that will be added to each field on the result object
+ */
+export declare const cloneAndSanitizeHeaders: (headersObj: Record<string, any>, resultFieldsPrefix?: string) => Record<string, string>;

package/lib/tracing/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneAndSanitizeHeaders = exports.getTraceInfo = void 0;
+const node_error_report_1 = require("@vtex/node-error-report");
+function getTraceInfo(span) {
+    var _a, _b, _c;
+    const spanContext = span === null || span === void 0 ? void 0 : span.context();
+    return {
+        isSampled: (_c = (_b = (_a = spanContext) === null || _a === void 0 ? void 0 : _a.isSampled) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : false,
+        traceId: spanContext === null || spanContext === void 0 ? void 0 : spanContext.toTraceId(),
+    };
+}
+exports.getTraceInfo = getTraceInfo;
+/**
+ * Do a shallow copy of a headers object and redacts sensitive information.
+ *
+ * @param headersObj The headers object
+ * @param resultFieldsPrefix The prefix that will be added to each field on the result object
+ */
+exports.cloneAndSanitizeHeaders = (headersObj, resultFieldsPrefix = '') => {
+    const ret = {};
+    const entries = Object.entries(headersObj);
+    for (const [key, val] of entries) {
+        // Most of the time val is a string, but there are some cases, for example when we do a axios interceptor,
+        // that a header field can contain an object, for example:
+        // ```
+        // "common": {
+        //   "Accept": "application/json, text/plain, */*"
+        // },
+        // "delete": { },
+        // "get": { },
+        // "head": { },
+        // "post": {
+        //   "Content-Type": "application/x-www-form-urlencoded"
+        // },
+        // ```
+        // In those corner cases we probably won't have a sensitive string as key, so we don't treat them here
+        ret[`${resultFieldsPrefix}${key}`] = node_error_report_1.authFields.includes(key) ? node_error_report_1.sanitizeAuth(val) : val;
+    }
+    return ret;
+};

package/lib/utils/MineWinsConflictsResolver.d.ts

@@ -1,7 +1,8 @@
-import { ConflictsResolver, VBase } from '../clients/VBase';
+import { Logger } from './../service/logger/logger';
+import { ConflictsResolver, VBase } from '../clients/infra/VBase';
 declare type Configuration = Record<string, ConfigurationData | ConfigurationData[] | object> | ConfigurationData[];
 declare type ConfigurationData = Record<string, object>;
-export declare class MineWinsConflictsResolver implements ConflictsResolver {
+export declare class MineWinsConflictsResolver<T> implements ConflictsResolver<T> {
     /***
      * Take mine and merge with master keys that have no conflict
      * We use base to decide wether a key was deleted or not
@@ -11,8 +12,9 @@ export declare class MineWinsConflictsResolver implements ConflictsResolver {
     private filePath;
     private comparableKeys;
     constructor(client: VBase, bucket: string, filePath: string, comparableKeys?: string[]);
-    resolve(): Promise<any>;
-    protected mergeMineWins(base: Configuration, master: Configuration, mine: Configuration): Configuration;
+    resolve(logger?: Logger): Promise<any>;
+    resolveAll(): Promise<(Record<string, object | Record<string, object> | Record<string, object>[]> | Record<string, object>[])[]>;
+    protected mergeMineWins(base: Configuration, master: Configuration, mine: Configuration): Record<string, object | Record<string, object> | Record<string, object>[]> | Record<string, object>[];
     private parseConflict;
     private serializeContentByMimetype;
     private parseContentByMimetype;

package/lib/utils/MineWinsConflictsResolver.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MineWinsConflictsResolver = void 0;
 const js_base64_1 = require("js-base64");
 const ramda_1 = require("ramda");
 const util_1 = require("util");
@@ -10,12 +11,15 @@ class MineWinsConflictsResolver {
         this.filePath = filePath;
         this.comparableKeys = comparableKeys;
     }
-    async resolve() {
-        return await this.client.getConflicts(this.bucket).then(data => {
+    async resolve(logger) {
+        return await this.client.getConflicts(this.bucket).then((data) => {
             const { data: conflicts } = data;
-            const selectedConflict = conflicts.find(conflict => conflict.path === this.filePath);
+            const selectedConflict = conflicts.find((conflict) => conflict.path === this.filePath);
             if (!selectedConflict) {
-                return {};
+                throw {
+                    message: 'No conflict could be found.',
+                    status: 404,
+                };
             }
             selectedConflict.base.parsedContent = this.parseConflict(selectedConflict.base);
             selectedConflict.master.parsedContent = this.parseConflict(selectedConflict.master);
@@ -24,6 +28,17 @@ class MineWinsConflictsResolver {
             return resolved;
         });
     }
+    async resolveAll() {
+        const conflictsResponse = await this.client.getConflicts(this.bucket);
+        const { data: conflicts } = conflictsResponse;
+        const resolvedConflicts = conflicts.map((conflict) => {
+            conflict.base.parsedContent = this.parseConflict(conflict.base);
+            conflict.master.parsedContent = this.parseConflict(conflict.master);
+            conflict.mine.parsedContent = this.parseConflict(conflict.mine);
+            return this.resolveConflictMineWins(conflict);
+        });
+        return resolvedConflicts;
+    }
     mergeMineWins(base, master, mine) {
         if (util_1.isArray(master)) {
             return this.mergeMineWinsArray((base || []), master, (mine || []));
@@ -53,19 +68,22 @@ class MineWinsConflictsResolver {
     }
     resolveConflictMineWins(conflict) {
         if (!conflict) {
-            return {};
+            throw {
+                message: 'No conflict could be found.',
+                status: 404,
+            };
         }
         const { base, master, mine, path } = conflict;
-        this.mergeMineWins(base.parsedContent, master.parsedContent, mine.parsedContent);
+        const merged = this.mergeMineWins(base.parsedContent, master.parsedContent, mine.parsedContent);
         const mergedContent = {
-            content: js_base64_1.Base64.encode(this.serializeContentByMimetype(mine.parsedContent, conflict.mine.mimeType)),
+            content: js_base64_1.Base64.encode(this.serializeContentByMimetype(merged, conflict.mine.mimeType)),
             mimeType: conflict.mine.mimeType,
         };
         this.client.resolveConflict(this.bucket, path, mergedContent);
-        return mine.parsedContent;
+        return merged;
     }
     mergeMineWinsObject(base, master, mine) {
-        const merged = Object.assign({}, master, mine);
+        const merged = { ...master, ...mine };
         Object.entries(merged).forEach(([key, value]) => {
             if (master[key] == null && base && base[key] != null && ramda_1.equals(value, base[key])) {
                 delete merged[key]; // value deleted from master with no conflict
@@ -88,10 +106,10 @@ class MineWinsConflictsResolver {
         return mine;
     }
     removeMasterDeletedElements(base, master, mine) {
-        base.forEach(baseItem => {
+        base.forEach((baseItem) => {
             const foundInMaster = this.isObjectInArray(baseItem, master);
             if (!foundInMaster) {
-                const foundInMine = mine.findIndex(mineItem => ramda_1.equals(mineItem, baseItem));
+                const foundInMine = mine.findIndex((mineItem) => ramda_1.equals(mineItem, baseItem));
                 if (foundInMine > -1) {
                     mine.splice(foundInMine, 1);
                 }
@@ -99,21 +117,21 @@ class MineWinsConflictsResolver {
         });
     }
     isObjectInArray(obj, array) {
-        return array.find(item => ramda_1.equals(item, obj));
+        return array.find((item) => ramda_1.equals(item, obj));
     }
     appendMasterAddedElements(base, master, mine) {
-        master.forEach(item => {
+        master.forEach((item) => {
             if (this.shouldAddToMine(item, base, mine)) {
                 mine.push(item);
             }
         });
     }
     shouldAddToMine(item, base, mine) {
-        if (this.comparableKeys && Object.keys(item).some(key => this.comparableKeys.includes(key))) {
-            return (!mine.some(mineItem => this.comparableKeys.some(key => ramda_1.eqProps(key, item, mineItem))) &&
-                !base.some(baseItem => this.comparableKeys.some(key => ramda_1.eqProps(key, item, baseItem))));
+        if (this.comparableKeys && Object.keys(item).some((key) => this.comparableKeys.includes(key))) {
+            return (!mine.some((mineItem) => this.comparableKeys.some((key) => ramda_1.eqProps(key, item, mineItem))) &&
+                !base.some((baseItem) => ramda_1.equals(baseItem, item)));
         }
-        return !mine.some(mineItem => ramda_1.equals(mineItem, item)) && !base.some(baseItem => ramda_1.equals(baseItem, item));
+        return !mine.some((mineItem) => ramda_1.equals(mineItem, item)) && !base.some((baseItem) => ramda_1.equals(baseItem, item));
     }
 }
 exports.MineWinsConflictsResolver = MineWinsConflictsResolver;

package/lib/utils/app.d.ts

@@ -1,4 +1,4 @@
-import { AppMetaInfo } from '../clients/Apps';
+import { AppMetaInfo } from '../clients/infra/Apps';
 export declare const removeBuild: (id: string) => string;
 export declare const removeVersionFromAppId: (appId: string) => string;
 export declare const extractVersionFromAppId: (appId: string) => string;
@@ -13,6 +13,8 @@ export declare const versionToMajorRange: (version: string) => string;
 export declare const formatMajorLocator: (name: string, version: string) => string;
 export declare const appIdToAppAtMajor: (appId: string) => string;
 export declare const isValidAppIdOrLocator: (appId: string) => boolean;
+export declare const sameMajor: (v1: string, v2: string) => boolean;
+export declare const majorEqualAndGreaterThan: (v1: string, v2: string) => boolean;
 export interface ParsedLocator {
     name: string;
     version: string;

package/lib/utils/app.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.majorEqualAndGreaterThan = exports.sameMajor = exports.isValidAppIdOrLocator = exports.appIdToAppAtMajor = exports.formatMajorLocator = exports.versionToMajorRange = exports.versionToMajor = exports.satisfies = exports.formatAppId = exports.parseAppId = exports.isLinkedApp = exports.formatLocator = exports.transformToLinkedLocator = exports.extractVersionFromAppId = exports.removeVersionFromAppId = exports.removeBuild = void 0;
 const semver_1 = __importDefault(require("semver"));
 // Note: The name that composes the part of the appId that precedes the
 // character '@' includes the name given to the app and the vendor name.
@@ -23,7 +24,7 @@ exports.parseAppId = (appId) => {
         version: splittedVersion[0],
     };
 };
-exports.formatAppId = ({ locator, build }) => build ? `${locator}+${build}` : locator;
+exports.formatAppId = ({ locator, build }) => (build ? `${locator}+${build}` : locator);
 exports.satisfies = (appId, version) => {
     const { version: appVer } = exports.parseAppId(appId);
     return semver_1.default.satisfies(appVer, version);
@@ -44,3 +45,5 @@ const APP_ID_REGEX = /^[\w\-]+\.[\w\-]+@(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-
 exports.isValidAppIdOrLocator = (appId) => {
     return APP_ID_REGEX.test(appId);
 };
+exports.sameMajor = (v1, v2) => exports.versionToMajor(v1) === exports.versionToMajor(v2);
+exports.majorEqualAndGreaterThan = (v1, v2) => exports.sameMajor(v1, v2) && semver_1.default.gt(v1, v2);

package/lib/utils/appsStaleIfError.d.ts

@@ -2,7 +2,7 @@
 import { AppMetaInfo, Apps } from '..';
 import { CacheLayer } from '../caches';
 import { Logger } from '../service/logger';
-export declare const getMetaInfoKey: (account: string) => string;
+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<{

package/lib/utils/appsStaleIfError.js

@@ -1,19 +1,32 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 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;
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFallbackFile = exports.saveVersion = exports.updateMetaInfoCache = exports.getMetaInfoKey = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const ramda_1 = require("ramda");
 const semver = __importStar(require("semver"));
-exports.getMetaInfoKey = (account) => `${account}-meta-infos`;
+exports.getMetaInfoKey = (account, workspace) => `${account}-${workspace}-meta-infos`;
 const hashMD5 = (text) => crypto_1.default
     .createHash('md5')
     .update(text)
@@ -22,7 +35,7 @@ exports.updateMetaInfoCache = async (cacheStorage, account, workspace, dependenc
     if (workspace !== 'master') {
         return;
     }
-    const key = exports.getMetaInfoKey(account);
+    const key = exports.getMetaInfoKey(account, workspace);
     const hash = hashMD5(dependencies.toString());
     try {
         const storedDependencies = await cacheStorage.get(key) || '';

package/lib/utils/billingOptions.d.ts

@@ -1,3 +1,36 @@
-import { BillingOptions, CalculationItem, FixedCalculationItem, FreeBillingOptions } from '../responses';
-export declare const isFreeBillingOptions: (billingOptions: BillingOptions) => billingOptions is FreeBillingOptions;
-export declare const isFixedCalculationItem: (item: CalculationItem) => item is FixedCalculationItem;
+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

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ramda_1 = require("ramda");
-exports.isFreeBillingOptions = (billingOptions) => billingOptions.free;
-exports.isFixedCalculationItem = (item) => !ramda_1.isNil(item.fixed);
+exports.BILLING_TYPE = exports.isFreeBillingOptions = void 0;
+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

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

package/lib/utils/binding.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBindingHeaderValue = exports.formatBindingHeaderValue = void 0;
 var BindingHeaderFormat;
 (function (BindingHeaderFormat) {
     BindingHeaderFormat["webframework0"] = "v0+webframework";

package/lib/utils/buildFullPath.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a new URL by combining the baseURL with the requestedURL,
+ * only when the requestedURL is not already an absolute URL.
+ * If the requestURL is absolute, this function returns the requestedURL untouched.
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} requestedURL Absolute or relative URL to combine
+ *
+ * @returns {string} The combined full path
+ */
+export default function (baseURL?: string, requestedURL?: string, allowAbsoluteUrls?: boolean): string | undefined;

package/lib/utils/buildFullPath.js

@@ -0,0 +1,54 @@
+"use strict";
+// This module is part of the Axios library.
+// It is used to build a full URL by combining a base URL with a relative URL.
+Object.defineProperty(exports, "__esModule", { value: true });
+// It is originally not intended to be used directly, but rather as a utility function within the Axios library.
+// Since Axios 1.0, this function is not exported by default, and the team does not recommend using it directly, 
+// as it may not be available in future versions.
+// The function takes a base URL and a relative URL as input, and returns the full URL.
+// It handles both absolute and relative URLs, and ensures that the resulting URL is properly formatted.
+// It is used internally by Axios to construct the full URL for HTTP requests.
+/**
+ * Creates a new URL by combining the baseURL with the requestedURL,
+ * only when the requestedURL is not already an absolute URL.
+ * If the requestURL is absolute, this function returns the requestedURL untouched.
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} requestedURL Absolute or relative URL to combine
+ *
+ * @returns {string} The combined full path
+ */
+function default_1(baseURL, requestedURL, allowAbsoluteUrls) {
+    let isRelativeUrl = !isAbsoluteURL(requestedURL);
+    if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
+        return combineURLs(baseURL, requestedURL);
+    }
+    return requestedURL;
+}
+exports.default = default_1;
+/**
+ * Determines whether the specified URL is absolute
+ *
+ * @param {string} url The URL to test
+ *
+ * @returns {boolean} True if the specified URL is absolute, otherwise false
+ */
+function isAbsoluteURL(url) {
+    // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
+    // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
+    // by any combination of letters, digits, plus, period, or hyphen.
+    return !!url && /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}
+/**
+ * Creates a new URL by combining the specified URLs
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} relativeURL The relative URL
+ *
+ * @returns {string} The combined URL
+ */
+function combineURLs(baseURL, relativeURL) {
+    return relativeURL && baseURL
+        ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')
+        : baseURL;
+}

package/lib/utils/cancel.d.ts

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

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.cancel = void 0;
 function cancel(middleware) {
     return async (ctx, next) => {
-        if (ctx.vtex.cancellation && ctx.vtex.cancellation.cancelled) {
+        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);

package/lib/utils/conflicts.mock.d.ts

@@ -0,0 +1,17 @@
+export declare function getMockConflicts(path: string, base: object, mine: object, master: object): {
+    data: {
+        base: {
+            content: string;
+            mimeType: string;
+        };
+        master: {
+            content: string;
+            mimeType: string;
+        };
+        mine: {
+            content: string;
+            mimeType: string;
+        };
+        path: string;
+    }[];
+};