feat(Compare Datasets Node): Fuzzy compare option

packages/nodes-base/nodes/Merge/v2/GenericFunctions.ts

@@ -4,9 +4,10 @@ import {
 	IDataObject,
 	INodeExecutionData,
 	IPairedItemData,
+	jsonParse,
 } from 'n8n-workflow';
 
-import { assign, assignWith, get, isEqual, merge, mergeWith } from 'lodash';
+import { assign, assignWith, get, isEqual, isNull, merge, mergeWith } from 'lodash';
 
 type PairToMatch = {
 	field1: string;
@@ -18,6 +19,7 @@ export type MatchFieldsOptions = {
 	outputDataFrom: MatchFieldsOutput;
 	multipleMatches: MultipleMatches;
 	disableDotNotation: boolean;
+	fuzzyCompare?: boolean;
 };
 
 export type ClashResolveOptions = {
@@ -46,6 +48,8 @@ type EntryMatches = {
 	matches: INodeExecutionData[];
 };
 
+type CompareFunction = <T, U>(a: T, b: U) => boolean;
+
 export function addSuffixToEntriesKeys(data: INodeExecutionData[], suffix: string) {
 	return data.map((entry) => {
 		const json: IDataObject = {};
@@ -60,6 +64,7 @@ function findAllMatches(
 	data: INodeExecutionData[],
 	lookup: IDataObject,
 	disableDotNotation: boolean,
+	isEntriesEqual: CompareFunction,
 ) {
 	return data.reduce((acc, entry2, i) => {
 		if (entry2 === undefined) return acc;
@@ -74,7 +79,7 @@ function findAllMatches(
 				entry2FieldValue = get(entry2.json, key);
 			}
 
-			if (!isEqual(excpectedValue, entry2FieldValue)) {
+			if (!isEntriesEqual(excpectedValue, entry2FieldValue)) {
 				return acc;
 			}
 		}
@@ -90,6 +95,7 @@ function findFirstMatch(
 	data: INodeExecutionData[],
 	lookup: IDataObject,
 	disableDotNotation: boolean,
+	isEntriesEqual: CompareFunction,
 ) {
 	const index = data.findIndex((entry2) => {
 		if (entry2 === undefined) return false;
@@ -104,7 +110,7 @@ function findFirstMatch(
 				entry2FieldValue = get(entry2.json, key);
 			}
 
-			if (!isEqual(excpectedValue, entry2FieldValue)) {
+			if (!isEntriesEqual(excpectedValue, entry2FieldValue)) {
 				return false;
 			}
 		}
@@ -129,6 +135,7 @@ export function findMatches(
 		[data1, data2] = [data2, data1];
 	}
 
+	const isEntriesEqual = fuzzyCompare(options);
 	const disableDotNotation = options.disableDotNotation || false;
 	const multipleMatches = (options.multipleMatches as string) || 'all';
 
@@ -163,8 +170,8 @@ export function findMatches(
 
 		const foundedMatches =
 			multipleMatches === 'all'
-				? findAllMatches(data2, lookup, disableDotNotation)
-				: findFirstMatch(data2, lookup, disableDotNotation);
+				? findAllMatches(data2, lookup, disableDotNotation, isEntriesEqual)
+				: findFirstMatch(data2, lookup, disableDotNotation, isEntriesEqual);
 
 		const matches = foundedMatches.map((match) => match.entry) as INodeExecutionData[];
 		foundedMatches.map((match) => matchedInInput2.add(match.index as number));
@@ -367,3 +374,90 @@ export function addSourceField(data: INodeExecutionData[], sourceField: string)
 		};
 	});
 }
+
+const fuzzyCompare =
+	(options: IDataObject) =>
+	<T, U>(item1: T, item2: U) => {
+		//Fuzzy compare is disabled, so we do strict comparison
+		if (!options.fuzzyCompare) return isEqual(item1, item2);
+
+		//Both types are the same, so we do strict comparison
+		if (!isNull(item1) && !isNull(item2) && typeof item1 === typeof item2) {
+			return isEqual(item1, item2);
+		}
+
+		//Null, empty strings, empty arrays all treated as the same
+		if (isFalsy(item1) && isFalsy(item2)) return true;
+
+		//When a field is missing in one branch and isFalsy() in another, treat them as matching
+		if (isFalsy(item1) && item2 === undefined) return true;
+		if (item1 === undefined && isFalsy(item2)) return true;
+
+		//Compare numbers and strings representing that number
+		if (typeof item1 === 'number' && typeof item2 === 'string') {
+			return item1.toString() === item2;
+		}
+
+		if (typeof item1 === 'string' && typeof item2 === 'number') {
+			return item1 === item2.toString();
+		}
+
+		//Compare objects/arrays and their stringified version
+		if (!isNull(item1) && typeof item1 === 'object' && typeof item2 === 'string') {
+			return parseStringAndCompareToObject(item2, item1 as IDataObject);
+		}
+
+		if (!isNull(item2) && typeof item1 === 'string' && typeof item2 === 'object') {
+			return parseStringAndCompareToObject(item1, item2 as IDataObject);
+		}
+
+		//Compare booleans and strings representing the boolean (’true’, ‘True’, ‘TRUE’)
+		if (typeof item1 === 'boolean' && typeof item2 === 'string') {
+			if (item1 === true && item2.toLocaleLowerCase() === 'true') return true;
+			if (item1 === false && item2.toLocaleLowerCase() === 'false') return true;
+		}
+
+		if (typeof item2 === 'boolean' && typeof item1 === 'string') {
+			if (item2 === true && item1.toLocaleLowerCase() === 'true') return true;
+			if (item2 === false && item1.toLocaleLowerCase() === 'false') return true;
+		}
+
+		//Compare booleans and the numbers/string 0 and 1
+		if (typeof item1 === 'boolean' && typeof item2 === 'number') {
+			if (item1 === true && item2 === 1) return true;
+			if (item1 === false && item2 === 0) return true;
+		}
+
+		if (typeof item2 === 'boolean' && typeof item1 === 'number') {
+			if (item2 === true && item1 === 1) return true;
+			if (item2 === false && item1 === 0) return true;
+		}
+
+		if (typeof item1 === 'boolean' && typeof item2 === 'string') {
+			if (item1 === true && item2 === '1') return true;
+			if (item1 === false && item2 === '0') return true;
+		}
+
+		if (typeof item2 === 'boolean' && typeof item1 === 'string') {
+			if (item2 === true && item1 === '1') return true;
+			if (item2 === false && item1 === '0') return true;
+		}
+
+		return isEqual(item1, item2);
+	};
+
+const parseStringAndCompareToObject = (str: string, arr: IDataObject) => {
+	try {
+		const parsedArray = jsonParse(str);
+		return isEqual(parsedArray, arr);
+	} catch (error) {
+		return false;
+	}
+};
+
+function isFalsy<T>(value: T) {
+	if (isNull(value)) return true;
+	if (typeof value === 'string' && value === '') return true;
+	if (Array.isArray(value) && value.length === 0) return true;
+	return false;
+}