@vtex/api 6.45.4

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,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+        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.log({ event: 'error', ...indexedLogs, error: serializableError });
+        if (logger && this.shouldLogToSplunk(span)) {
+            logger.error(serializableError);
+            this.markErrorAsReported();
+        }
+        return this;
+    }
+    shouldLogToSplunk(span) {
+        return !this.isErrorReported() && utils_1.getTraceInfo(span).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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const opentracing_1 = require("opentracing");
+exports.FORMAT_HTTP_HEADERS = opentracing_1.FORMAT_HTTP_HEADERS;
+exports.Span = opentracing_1.Span;
+var node_error_report_1 = require("@vtex/node-error-report");
+exports.ErrorKinds = node_error_report_1.ErrorKindsBase;
+var ErrorReport_1 = require("./errorReporting/ErrorReport");
+exports.ErrorReport = ErrorReport_1.ErrorReport;
+var createSpanReference_1 = require("./spanReference/createSpanReference");
+exports.createSpanReference = createSpanReference_1.createSpanReference;
+var SpanReferenceTypes_1 = require("./spanReference/SpanReferenceTypes");
+exports.SpanReferenceTypes = SpanReferenceTypes_1.SpanReferenceTypes;
+var Tags_1 = require("./Tags");
+exports.TracingTags = Tags_1.UserlandTags;
+var UserLandTracer_1 = require("./UserLandTracer");
+exports.createTracingContextFromCarrier = UserLandTracer_1.createTracingContextFromCarrier;
+var utils_1 = require("./utils");
+exports.getTraceInfo = 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,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_error_report_1 = require("@vtex/node-error-report");
+function getTraceInfo(span) {
+    var _a, _b, _c;
+    const spanContext = span.context();
+    return {
+        isSampled: (_c = (_b = (_a = spanContext).isSampled) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : false,
+        traceId: 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

@@ -0,0 +1,28 @@
+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<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
+     */
+    private client;
+    private bucket;
+    private filePath;
+    private comparableKeys;
+    constructor(client: VBase, bucket: string, filePath: string, comparableKeys?: string[]);
+    resolve(logger?: Logger): Promise<T>;
+    protected mergeMineWins(base: Configuration, master: Configuration, mine: Configuration): Configuration;
+    private parseConflict;
+    private serializeContentByMimetype;
+    private parseContentByMimetype;
+    private resolveConflictMineWins;
+    private mergeMineWinsObject;
+    private mergeMineWinsArray;
+    private removeMasterDeletedElements;
+    private isObjectInArray;
+    private appendMasterAddedElements;
+    private shouldAddToMine;
+}
+export {};

package/lib/utils/MineWinsConflictsResolver.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_base64_1 = require("js-base64");
+const ramda_1 = require("ramda");
+const util_1 = require("util");
+class MineWinsConflictsResolver {
+    constructor(client, bucket, filePath, comparableKeys) {
+        this.client = client;
+        this.bucket = bucket;
+        this.filePath = filePath;
+        this.comparableKeys = comparableKeys;
+    }
+    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);
+            if (!selectedConflict) {
+                return {};
+            }
+            selectedConflict.base.parsedContent = this.parseConflict(selectedConflict.base);
+            selectedConflict.master.parsedContent = this.parseConflict(selectedConflict.master);
+            selectedConflict.mine.parsedContent = this.parseConflict(selectedConflict.mine);
+            const resolved = this.resolveConflictMineWins(selectedConflict);
+            if (logger) {
+                logger.info({
+                    base: selectedConflict.base.parsedContent,
+                    bucket: this.bucket,
+                    conflictsResolution: MineWinsConflictsResolver.constructor.name,
+                    filePath: this.filePath,
+                    master: selectedConflict.master.parsedContent,
+                    mine: selectedConflict.mine.parsedContent,
+                    resolved,
+                });
+            }
+            return resolved;
+        });
+    }
+    mergeMineWins(base, master, mine) {
+        if (util_1.isArray(master)) {
+            return this.mergeMineWinsArray((base || []), master, (mine || []));
+        }
+        else if (util_1.isObject(master)) {
+            return this.mergeMineWinsObject((base || {}), master, (mine || {}));
+        }
+        return mine ? mine : master;
+    }
+    parseConflict(conflict) {
+        if (!conflict || !conflict.content) {
+            return {};
+        }
+        return this.parseContentByMimetype(js_base64_1.Base64.decode(conflict.content), conflict.mimeType);
+    }
+    serializeContentByMimetype(content, mimetype) {
+        if (mimetype === 'application/json') {
+            return JSON.stringify(content);
+        }
+        return content;
+    }
+    parseContentByMimetype(content, mimetype) {
+        if (mimetype === 'application/json') {
+            return JSON.parse(content);
+        }
+        return content;
+    }
+    resolveConflictMineWins(conflict) {
+        if (!conflict) {
+            return {};
+        }
+        const { base, master, mine, path } = conflict;
+        this.mergeMineWins(base.parsedContent, master.parsedContent, mine.parsedContent);
+        const mergedContent = {
+            content: js_base64_1.Base64.encode(this.serializeContentByMimetype(mine.parsedContent, conflict.mine.mimeType)),
+            mimeType: conflict.mine.mimeType,
+        };
+        this.client.resolveConflict(this.bucket, path, mergedContent);
+        return mine.parsedContent;
+    }
+    mergeMineWinsObject(base, 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
+            }
+            else if (base[key] && master[key] && !mine[key]) {
+                delete merged[key]; // value deleted from mine
+            }
+            else if (util_1.isArray(value)) {
+                merged[key] = this.mergeMineWinsArray((base[key] || []), (master[key] || []), value);
+            }
+            else if (util_1.isObject(value)) {
+                merged[key] = this.mergeMineWins((base[key] || {}), (master[key] || {}), (value || {}));
+            }
+        });
+        return merged;
+    }
+    mergeMineWinsArray(base, master, mine) {
+        this.removeMasterDeletedElements(base, master, mine);
+        this.appendMasterAddedElements(base, master, mine);
+        return mine;
+    }
+    removeMasterDeletedElements(base, master, mine) {
+        base.forEach(baseItem => {
+            const foundInMaster = this.isObjectInArray(baseItem, master);
+            if (!foundInMaster) {
+                const foundInMine = mine.findIndex(mineItem => ramda_1.equals(mineItem, baseItem));
+                if (foundInMine > -1) {
+                    mine.splice(foundInMine, 1);
+                }
+            }
+        });
+    }
+    isObjectInArray(obj, array) {
+        return array.find(item => ramda_1.equals(item, obj));
+    }
+    appendMasterAddedElements(base, master, mine) {
+        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) => 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

@@ -0,0 +1,23 @@
+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;
+export declare const transformToLinkedLocator: (appId: string) => string;
+export declare const formatLocator: (name: string, versionAndBuild: string) => string;
+export declare const isLinkedApp: (app: AppMetaInfo) => boolean;
+export declare const parseAppId: (appId: string) => ParsedLocator;
+export declare const formatAppId: ({ locator, build }: ParsedLocator) => string;
+export declare const satisfies: (appId: string, version: string) => boolean;
+export declare const versionToMajor: (version: string) => string;
+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;
+    locator: string;
+    build?: string;
+}

package/lib/utils/app.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 splittedVersion = version.split('+');
+    return {
+        build: splittedVersion[1],
+        locator: 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);
+    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);
+    return `${name}@${majorRange}`;
+};
+exports.appIdToAppAtMajor = (appId) => {
+    const { name, version } = exports.parseAppId(appId);
+    const majorRange = exports.versionToMajorRange(version);
+    return `${name}@${majorRange}`;
+};
+// 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) => {
+    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);