@vtex/api 6.45.14-beta.0 → 6.45.14

package/CHANGELOG.md

@@ -6,12 +6,27 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+
+## [6.45.14] - 2023-02-01
+
+### Added
+
+- New tests for `MineWinsConflictsResolver`.
+
+### Fixed
+
+- Merged/Rebased content not being returned causing inconsistencies.
+- Do not return empty content if no conflict is found.
+
+## [6.45.13] - 2022-12-12
 ### Changed
+- Deterministic cache for getWithBody
 - Remove socket metrics per origin
 
 ## [6.45.12] - 2022-04-14
 
 ### Fixed
+
 - Update sensitive fields list.
   - Remove "error" field.
   - Add missing fields.
@@ -1736,3 +1751,8 @@ instead
 ### Changed
 
 - `HttpClient` now adds `'Accept-Encoding': 'gzip'` header by default.
+
+
+[Unreleased]: https://github.com/vtex/node-vtex-api/compare/v6.45.14...HEAD
+[6.45.14]: https://github.com/vtex/node-vtex-api/compare/v6.45.13...v6.45.14
+[6.45.13]: https://github.com/vtex/node-vtex-api/compare/v6.45.12...v6.45.13

package/lib/HttpClient/HttpClient.d.ts

@@ -6,6 +6,7 @@ import { InstanceOptions, IOResponse, RequestConfig } from './typings';
 declare type ClientOptions = IOContext & Partial<InstanceOptions>;
 export declare class HttpClient {
     name: string;
+    private logger;
     private runMiddlewares;
     constructor(opts: ClientOptions);
     get: <T = any>(url: string, config?: RequestConfig) => Promise<T>;

package/lib/HttpClient/HttpClient.js

@@ -31,7 +31,19 @@ class HttpClient {
             return this.request(cacheableConfig);
         };
         this.getWithBody = (url, data, config = {}) => {
-            const bodyHash = crypto_1.createHash('md5').update(JSON.stringify(data)).digest('hex');
+            const deterministicReplacer = (_, v) => {
+                try {
+                    return typeof v !== 'object' || v === null || Array.isArray(v) ? v :
+                        Object.fromEntries(Object.entries(v).sort(([ka], [kb]) => ka < kb ? -1 : ka > kb ? 1 : 0));
+                }
+                catch (error) {
+                    // I don't believe this will ever happen, but just in case
+                    // Also, I didn't include error as I am unsure if it would have sensitive information
+                    this.logger.warn({ message: 'Error while sorting object for cache key' });
+                    return v;
+                }
+            };
+            const bodyHash = crypto_1.createHash('md5').update(JSON.stringify(data, deterministicReplacer)).digest('hex');
             const cacheableConfig = this.getConfig(url, {
                 ...config,
                 data,
@@ -91,6 +103,7 @@ class HttpClient {
         });
         const { baseURL, authToken, authType, memoryCache, diskCache, locale, name, metrics, product, serverTiming, recorder, userAgent, timeout = DEFAULT_TIMEOUT_MS, segmentToken, sessionToken, retries, concurrency, headers: defaultHeaders, host, params, operationId, tenant, binding, verbose, cancellation, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent, tracer, logger, } = opts;
         this.name = name || baseURL || 'unknown';
+        this.logger = logger;
         const limit = concurrency && concurrency > 0 && p_limit_1.default(concurrency) || undefined;
         const headers = {
             ...defaultHeaders,

package/lib/clients/infra/VBase.js

@@ -68,15 +68,40 @@ class VBase extends InfraClient_1.InfraClient {
             const headers = conflictsResolver ? { 'X-Vtex-Detect-Conflicts': true } : {};
             const inflightKey = HttpClient_1.inflightURL;
             const metric = 'vbase-get-json';
-            return this.http.getRaw(routes.File(bucket, path), { headers, inflightKey, metric, nullIfNotFound, tracing: {
+            return this.http
+                .getRaw(routes.File(bucket, path), {
+                headers,
+                inflightKey,
+                metric,
+                nullIfNotFound,
+                tracing: {
                     requestSpanNameSuffix: metric,
                     ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
-                } })
+                },
+            })
                 .catch(async (error) => {
                 const { response } = error;
                 if (response && response.status === 409 && conflictsResolver) {
-                    const conflictsMergedData = await conflictsResolver.resolve(this.context.logger);
-                    return { ...response, data: conflictsMergedData };
+                    try {
+                        const conflictsMergedData = await conflictsResolver.resolve(this.context.logger);
+                        return { ...response, data: conflictsMergedData };
+                    }
+                    catch (resolverError) {
+                        const typedResolverError = resolverError;
+                        if ((typedResolverError === null || typedResolverError === void 0 ? void 0 : typedResolverError.status) === 404) {
+                            return this.http.getRaw(routes.File(bucket, path), {
+                                'X-Vtex-Detect-Conflicts': false,
+                                inflightKey,
+                                metric,
+                                nullIfNotFound,
+                                tracing: {
+                                    requestSpanNameSuffix: metric,
+                                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                                },
+                            });
+                        }
+                        throw resolverError;
+                    }
                 }
                 throw error;
             });

package/lib/service/worker/runtime/utils/context.d.ts

@@ -1,2 +1,2 @@
 import { IOContext, TracingContext } from '../typings';
-export declare const prepareHandlerCtx: (header: any, tracingContext: TracingContext) => Pick<IOContext, "host" | "logger" | "account" | "workspace" | "requestId" | "operationId" | "production" | "platform" | "authToken" | "adminUserAuthToken" | "storeUserAuthToken" | "locale" | "product" | "recorder" | "region" | "userAgent" | "segmentToken" | "sessionToken" | "janusEnv" | "serverTiming" | "eventInfo" | "tenant" | "binding" | "cancellation" | "settings" | "tracer">;
+export declare const prepareHandlerCtx: (header: any, tracingContext: TracingContext) => Pick<IOContext, "host" | "serverTiming" | "locale" | "account" | "workspace" | "region" | "logger" | "requestId" | "operationId" | "production" | "platform" | "authToken" | "adminUserAuthToken" | "storeUserAuthToken" | "product" | "recorder" | "userAgent" | "segmentToken" | "sessionToken" | "janusEnv" | "eventInfo" | "tenant" | "binding" | "cancellation" | "settings" | "tracer">;

package/lib/utils/MineWinsConflictsResolver.d.ts

@@ -12,8 +12,8 @@ export declare class MineWinsConflictsResolver<T> implements ConflictsResolver<T
     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;
+    resolve(logger?: Logger): Promise<any>;
+    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

@@ -11,27 +11,19 @@ class MineWinsConflictsResolver {
         this.comparableKeys = comparableKeys;
     }
     async resolve(logger) {
-        return await this.client.getConflicts(this.bucket).then(data => {
+        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);
             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;
         });
     }
@@ -64,16 +56,19 @@ 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 = { ...master, ...mine };
@@ -99,10 +94,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);
                 }
@@ -110,10 +105,10 @@ 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);
             }

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;
+    }[];
+};

package/lib/utils/conflicts.mock.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function jsonToBase64(json) {
+    return Buffer.from(JSON.stringify(json)).toString('base64');
+}
+function getMockConflicts(path, base, mine, master) {
+    return {
+        data: [
+            {
+                base: {
+                    content: jsonToBase64(base),
+                    mimeType: 'application/json',
+                },
+                master: {
+                    content: jsonToBase64(master),
+                    mimeType: 'application/json',
+                },
+                mine: {
+                    content: jsonToBase64(mine),
+                    mimeType: 'application/json',
+                },
+                path,
+            },
+        ],
+    };
+}
+exports.getMockConflicts = getMockConflicts;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vtex/api",
-  "version": "6.45.14-beta.0",
+  "version": "6.45.14",
   "description": "VTEX I/O API client",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",