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

package/lib/tracing/Tags.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserlandTags = exports.OpentracingTags = void 0;
+const opentracing_1 = require("opentracing");
+Object.defineProperty(exports, "OpentracingTags", { enumerable: true, get: function () { return opentracing_1.Tags; } });
+exports.UserlandTags = {
+    ...opentracing_1.Tags,
+};

package/lib/tracing/UserLandTracer.d.ts

@@ -0,0 +1,27 @@
+import { Span, SpanContext, SpanOptions, Tracer } from 'opentracing';
+export interface IUserLandTracer {
+    traceId?: string;
+    isTraceSampled: boolean;
+    startSpan: Tracer['startSpan'];
+    inject: Tracer['inject'];
+    fallbackSpanContext: () => SpanContext | undefined;
+}
+export declare const createTracingContextFromCarrier: (newSpanName: string, carrier: Record<string, any>) => {
+    span: Span;
+    tracer: IUserLandTracer;
+};
+export declare class UserLandTracer implements IUserLandTracer {
+    private tracer;
+    private fallbackSpan;
+    private fallbackSpanLock;
+    private _isSampled;
+    private _traceId?;
+    constructor(tracer: Tracer, fallbackSpan?: Span);
+    get traceId(): string | undefined;
+    get isTraceSampled(): boolean;
+    lockFallbackSpan(): void;
+    setFallbackSpan(newSpan?: Span): void;
+    startSpan(name: string, options?: SpanOptions): Span;
+    inject(spanContext: SpanContext | Span, format: string, carrier: any): void;
+    fallbackSpanContext(): SpanContext | undefined;
+}

package/lib/tracing/UserLandTracer.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserLandTracer = exports.createTracingContextFromCarrier = void 0;
+const opentracing_1 = require("opentracing");
+const TracerSingleton_1 = require("../service/tracing/TracerSingleton");
+const utils_1 = require("./utils");
+const createTracingContextFromCarrier = (newSpanName, carrier) => {
+    const tracer = TracerSingleton_1.TracerSingleton.getTracer();
+    const rootSpan = tracer.extract(opentracing_1.FORMAT_HTTP_HEADERS, carrier);
+    if (rootSpan == null) {
+        throw new Error('Missing span context data on carrier');
+    }
+    const span = tracer.startSpan(newSpanName, { childOf: rootSpan });
+    const userlandTracer = new UserLandTracer(tracer, span);
+    userlandTracer.lockFallbackSpan();
+    return { span, tracer: userlandTracer };
+};
+exports.createTracingContextFromCarrier = createTracingContextFromCarrier;
+class UserLandTracer {
+    constructor(tracer, fallbackSpan) {
+        this.tracer = tracer;
+        this.fallbackSpan = fallbackSpan;
+        this.fallbackSpanLock = false;
+        const { traceId, isSampled } = (0, utils_1.getTraceInfo)(fallbackSpan);
+        this._traceId = traceId;
+        this._isSampled = isSampled;
+    }
+    get traceId() {
+        return this._traceId;
+    }
+    get isTraceSampled() {
+        return this._isSampled;
+    }
+    lockFallbackSpan() {
+        this.fallbackSpanLock = true;
+    }
+    setFallbackSpan(newSpan) {
+        if (this.fallbackSpanLock) {
+            throw new Error(`FallbackSpan is locked, can't change it`);
+        }
+        this.fallbackSpan = newSpan;
+    }
+    startSpan(name, options) {
+        var _a;
+        if (options && (options.childOf || ((_a = options.references) === null || _a === void 0 ? void 0 : _a.length))) {
+            return this.tracer.startSpan(name, options);
+        }
+        return this.tracer.startSpan(name, { ...options, childOf: this.fallbackSpan });
+    }
+    inject(spanContext, format, carrier) {
+        return this.tracer.inject(spanContext, format, carrier);
+    }
+    fallbackSpanContext() {
+        var _a;
+        return (_a = this.fallbackSpan) === null || _a === void 0 ? void 0 : _a.context();
+    }
+}
+exports.UserLandTracer = UserLandTracer;

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((0, 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" /* ErrorReportLogFields.ERROR_KIND */]: this.kind,
+            ["error.id" /* ErrorReportLogFields.ERROR_ID */]: this.metadata.errorId,
+        };
+        if ((0, node_error_report_1.isRequestInfo)(this.parsedInfo) &&
+            this.parsedInfo.response &&
+            (0, node_error_report_1.isInfraErrorData)((_a = this.parsedInfo.response) === null || _a === void 0 ? void 0 : _a.data)) {
+            indexedLogs["error.server.code" /* ErrorReportLogFields.ERROR_SERVER_CODE */] = this.parsedInfo.response.data.code;
+            indexedLogs["error.server.request_id" /* ErrorReportLogFields.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" /* ErrorReportLogFields.ERROR_MESSAGE */]: serializableError.message,
+            ["error.metadata.metrics.InstantiationTime" /* ErrorReportLogFields.ERROR_METADATA_METRICS_INSTANTIATION_TIME */]: (_b = serializableError.metadata) === null || _b === void 0 ? void 0 : _b.reportCount,
+            ["error.metadata.reportCount" /* ErrorReportLogFields.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" /* ErrorReportLogFields.ERROR_STACK */]: serializableError.stack,
+            ["error.code" /* ErrorReportLogFields.ERROR_CODE */]: serializableError.code,
+        });
+        if (logger && this.shouldLogToSplunk(span)) {
+            logger.error(serializableError);
+            this.markErrorAsReported();
+        }
+        return this;
+    }
+    shouldLogToSplunk(span) {
+        var _a;
+        return !this.isErrorReported() && ((_a = (0, 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 = exports.getTraceInfo = exports.createTracingContextFromCarrier = exports.TracingTags = exports.SpanReferenceTypes = exports.createSpanReference = exports.ErrorReport = exports.ErrorKinds = 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,42 @@
+"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;
+    const spanContext = span === null || span === void 0 ? void 0 : span.context();
+    return {
+        isSampled: (_b = (_a = spanContext === null || spanContext === void 0 ? void 0 : spanContext.isSampled) === null || _a === void 0 ? void 0 : _a.call(spanContext)) !== null && _b !== void 0 ? _b : 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
+ */
+const 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) ? (0, node_error_report_1.sanitizeAuth)(val) : val;
+    }
+    return ret;
+};
+exports.cloneAndSanitizeHeaders = cloneAndSanitizeHeaders;

package/lib/utils/MineWinsConflictsResolver.d.ts

@@ -1,7 +1,8 @@
-import { ConflictsResolver, VBase } from '../clients/VBase';
-declare type Configuration = Record<string, ConfigurationData | ConfigurationData[] | object> | ConfigurationData[];
-declare type ConfigurationData = Record<string, object>;
-export declare class MineWinsConflictsResolver implements ConflictsResolver {
+import { Logger } from './../service/logger/logger';
+import { ConflictsResolver, VBase } from '../clients/infra/VBase';
+type Configuration = Record<string, ConfigurationData | ConfigurationData[] | object> | ConfigurationData[];
+type ConfigurationData = Record<string, object>;
+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,7 +12,8 @@ export declare class MineWinsConflictsResolver implements ConflictsResolver {
     private filePath;
     private comparableKeys;
     constructor(client: VBase, bucket: string, filePath: string, comparableKeys?: string[]);
-    resolve(): Promise<any>;
+    resolve(logger?: Logger): Promise<any>;
+    resolveAll(): Promise<Configuration[]>;
     protected mergeMineWins(base: Configuration, master: Configuration, mine: Configuration): Configuration;
     private parseConflict;
     private serializeContentByMimetype;

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,11 +28,22 @@ 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)) {
+        if ((0, util_1.isArray)(master)) {
             return this.mergeMineWinsArray((base || []), master, (mine || []));
         }
-        else if (util_1.isObject(master)) {
+        else if ((0, util_1.isObject)(master)) {
             return this.mergeMineWinsObject((base || {}), master, (mine || {}));
         }
         return mine ? mine : master;
@@ -53,30 +68,33 @@ 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])) {
+            if (master[key] == null && base && base[key] != null && (0, ramda_1.equals)(value, base[key])) {
                 delete merged[key]; // value deleted from master with no conflict
             }
             else if (base[key] && master[key] && !mine[key]) {
                 delete merged[key]; // value deleted from mine
             }
-            else if (util_1.isArray(value)) {
+            else if ((0, util_1.isArray)(value)) {
                 merged[key] = this.mergeMineWinsArray((base[key] || []), (master[key] || []), value);
             }
-            else if (util_1.isObject(value)) {
+            else if ((0, util_1.isObject)(value)) {
                 merged[key] = this.mergeMineWins((base[key] || {}), (master[key] || {}), (value || {}));
             }
         });
@@ -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) => (0, 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) => (0, 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) => (0, ramda_1.eqProps)(key, item, mineItem))) &&
+                !base.some((baseItem) => (0, 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) => (0, ramda_1.equals)(mineItem, item)) && !base.some((baseItem) => (0, 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,44 +3,63 @@ 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.
-exports.removeBuild = (id) => id.split('+')[0];
-exports.removeVersionFromAppId = (appId) => appId.split('@')[0];
-exports.extractVersionFromAppId = (appId) => appId.split('@').slice(-1)[0];
-exports.transformToLinkedLocator = (appId) => appId.replace(/\+build.*$/, '+linked');
-exports.formatLocator = (name, versionAndBuild) => `${name}@${exports.removeBuild(versionAndBuild)}`;
-exports.isLinkedApp = (app) => app.id.includes('+build');
-exports.parseAppId = (appId) => {
-    const name = exports.removeVersionFromAppId(appId);
-    const version = exports.extractVersionFromAppId(appId);
+const removeBuild = (id) => id.split('+')[0];
+exports.removeBuild = removeBuild;
+const removeVersionFromAppId = (appId) => appId.split('@')[0];
+exports.removeVersionFromAppId = removeVersionFromAppId;
+const extractVersionFromAppId = (appId) => appId.split('@').slice(-1)[0];
+exports.extractVersionFromAppId = extractVersionFromAppId;
+const transformToLinkedLocator = (appId) => appId.replace(/\+build.*$/, '+linked');
+exports.transformToLinkedLocator = transformToLinkedLocator;
+const formatLocator = (name, versionAndBuild) => `${name}@${(0, exports.removeBuild)(versionAndBuild)}`;
+exports.formatLocator = formatLocator;
+const isLinkedApp = (app) => app.id.includes('+build');
+exports.isLinkedApp = isLinkedApp;
+const parseAppId = (appId) => {
+    const name = (0, exports.removeVersionFromAppId)(appId);
+    const version = (0, exports.extractVersionFromAppId)(appId);
     const splittedVersion = version.split('+');
     return {
         build: splittedVersion[1],
-        locator: exports.formatLocator(name, version),
+        locator: (0, exports.formatLocator)(name, version),
         name,
         version: splittedVersion[0],
     };
 };
-exports.formatAppId = ({ locator, build }) => build ? `${locator}+${build}` : locator;
-exports.satisfies = (appId, version) => {
-    const { version: appVer } = exports.parseAppId(appId);
+exports.parseAppId = parseAppId;
+const formatAppId = ({ locator, build }) => (build ? `${locator}+${build}` : locator);
+exports.formatAppId = formatAppId;
+const satisfies = (appId, version) => {
+    const { version: appVer } = (0, exports.parseAppId)(appId);
     return semver_1.default.satisfies(appVer, version);
 };
-exports.versionToMajor = (version) => version.split('.')[0];
-exports.versionToMajorRange = (version) => `${exports.versionToMajor(version)}.x`;
-exports.formatMajorLocator = (name, version) => {
-    const majorRange = exports.versionToMajorRange(version);
+exports.satisfies = satisfies;
+const versionToMajor = (version) => version.split('.')[0];
+exports.versionToMajor = versionToMajor;
+const versionToMajorRange = (version) => `${(0, exports.versionToMajor)(version)}.x`;
+exports.versionToMajorRange = versionToMajorRange;
+const formatMajorLocator = (name, version) => {
+    const majorRange = (0, exports.versionToMajorRange)(version);
     return `${name}@${majorRange}`;
 };
-exports.appIdToAppAtMajor = (appId) => {
-    const { name, version } = exports.parseAppId(appId);
-    const majorRange = exports.versionToMajorRange(version);
+exports.formatMajorLocator = formatMajorLocator;
+const appIdToAppAtMajor = (appId) => {
+    const { name, version } = (0, exports.parseAppId)(appId);
+    const majorRange = (0, exports.versionToMajorRange)(version);
     return `${name}@${majorRange}`;
 };
+exports.appIdToAppAtMajor = appIdToAppAtMajor;
 // SemVer regex from https://github.com/sindresorhus/semver-regex
 const APP_ID_REGEX = /^[\w\-]+\.[\w\-]+@(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-[\da-z\-]+(?:\.[\da-z\-]+)*)?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?$/;
-exports.isValidAppIdOrLocator = (appId) => {
+const isValidAppIdOrLocator = (appId) => {
     return APP_ID_REGEX.test(appId);
 };
+exports.isValidAppIdOrLocator = isValidAppIdOrLocator;
+const sameMajor = (v1, v2) => (0, exports.versionToMajor)(v1) === (0, exports.versionToMajor)(v2);
+exports.sameMajor = sameMajor;
+const majorEqualAndGreaterThan = (v1, v2) => (0, exports.sameMajor)(v1, v2) && semver_1.default.gt(v1, v2);
+exports.majorEqualAndGreaterThan = majorEqualAndGreaterThan;

package/lib/utils/appsStaleIfError.d.ts

@@ -1,8 +1,9 @@
 /// <reference types="node" />
+/// <reference types="node" />
 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<{