Single match object per condition, instead of array

Author: joneubank

packages/dictionary/src/metaSchema/restrictionsSchemas.ts

@@ -166,7 +166,17 @@ export type MatchRuleRegex = zod.infer<typeof MatchRuleRegex>;
 export const MatchRuleValue = FieldValue;
 export type MatchRuleValue = zod.infer<typeof MatchRuleValue>;
 
-export const ConditionMatchRule = zod
+export const MatchRule = zod.union([
+	MatchRuleCodeList,
+	MatchRuleCount,
+	MatchRuleExists,
+	MatchRuleRange,
+	MatchRuleRegex,
+	MatchRuleValue,
+]);
+export type MatchRule = zod.infer<typeof MatchRule>;
+
+export const ConditionMatch = zod
 	.object({
 		codeList: MatchRuleCodeList,
 		count: MatchRuleCount,
@@ -176,11 +186,11 @@ export const ConditionMatchRule = zod
 		value: MatchRuleValue,
 	})
 	.partial();
-type ConditionMatchRule = zod.infer<typeof ConditionMatchRule>;
+type ConditionMatch = zod.infer<typeof ConditionMatch>;
 
 export const RestrictionCondition = zod.object({
 	fields: zod.string().array(),
-	match: ConditionMatchRule.array(),
+	match: ConditionMatch,
 	case: ArrayTestCase.optional(),
 	arrayFieldCase: ArrayTestCase.optional(),
 });

packages/dictionary/src/references.ts

@@ -193,18 +193,20 @@ const replaceReferencesInStringRestrictionsObject = (
 	if ('if' in restrictionsObject) {
 		// Do replacements inside the if conditions
 		restrictionsObject.if.conditions = restrictionsObject.if.conditions.map((condition) => {
-			condition.match = condition.match.map((match) => {
-				if (match.codeList && !isNumberArray(match.codeList)) {
-					match.codeList = TypeUtils.asArray(resolveAllReferences(match.codeList, references, discovered, visited));
-				}
-				if (typeof match.value === 'string' || isStringArray(match.value)) {
-					match.value = resolveAllReferences(match.value, references, discovered, visited);
-				}
-				if (match.regex) {
-					match.regex = TypeUtils.asArray(resolveAllReferences(match.regex, references, discovered, visited));
-				}
-				return match;
-			});
+			if (condition.match.codeList && !isNumberArray(condition.match.codeList)) {
+				condition.match.codeList = TypeUtils.asArray(
+					resolveAllReferences(condition.match.codeList, references, discovered, visited),
+				);
+			}
+			if (typeof condition.match.value === 'string' || isStringArray(condition.match.value)) {
+				condition.match.value = resolveAllReferences(condition.match.value, references, discovered, visited);
+			}
+			if (condition.match.regex) {
+				condition.match.regex = TypeUtils.asArray(
+					resolveAllReferences(condition.match.regex, references, discovered, visited),
+				);
+			}
+
 			return condition;
 		});
 

packages/validation/src/utils/resultForArayTestCase.ts packages/validation/src/utils/resultForArrayTestCase.ts

@@ -45,41 +45,38 @@ const testConditionForSingularValue = (
 	_value: SingleDataValue,
 	fieldValues: DataRecordValue[],
 ): boolean => {
-	const results = condition.match.map((match) => {
-		if (match.codeList) {
-			if (!allValuesPassMatchTest(fieldValues, match.codeList, testMatchCodeList)) {
-				return false;
-			}
+	if (condition.match.codeList) {
+		if (!allValuesPassMatchTest(fieldValues, condition.match.codeList, testMatchCodeList)) {
+			return false;
 		}
-		// count rule can have value of 0 so we need to directly check for undefined
-		if (match.count !== undefined) {
-			if (!allValuesPassMatchTest(fieldValues, match.count, testMatchCount)) {
-				return false;
-			}
+	}
+	// count rule can have value of 0 so we need to directly check for undefined
+	if (condition.match.count !== undefined) {
+		if (!allValuesPassMatchTest(fieldValues, condition.match.count, testMatchCount)) {
+			return false;
 		}
-		if (match.exists) {
-			if (!allValuesPassMatchTest(fieldValues, match.exists, testMatchExists)) {
-				return false;
-			}
+	}
+	if (condition.match.exists) {
+		if (!allValuesPassMatchTest(fieldValues, condition.match.exists, testMatchExists)) {
+			return false;
 		}
-		if (match.range) {
-			if (!allValuesPassMatchTest(fieldValues, match.range, testMatchRange)) {
-				return false;
-			}
+	}
+	if (condition.match.range) {
+		if (!allValuesPassMatchTest(fieldValues, condition.match.range, testMatchRange)) {
+			return false;
 		}
-		if (match.regex) {
-			if (!allValuesPassMatchTest(fieldValues, match.regex, testMatchRegex)) {
-				return false;
-			}
+	}
+	if (condition.match.regex) {
+		if (!allValuesPassMatchTest(fieldValues, condition.match.regex, testMatchRegex)) {
+			return false;
 		}
-		if (match.value) {
-			if (!allValuesPassMatchTest(fieldValues, match.value, testMatchValue)) {
-				return false;
-			}
+	}
+	if (condition.match.value) {
+		if (!allValuesPassMatchTest(fieldValues, condition.match.value, testMatchValue)) {
+			return false;
 		}
-		return true;
-	});
-	return resultForArrayTestCase(results, condition.case || ARRAY_TEST_CASE_DEFAULT);
+	}
+	return true;
 };
 
 const testConditionForArray = (

packages/validation/src/validateField/conditions/testConditionalRestriction.ts

@@ -143,7 +143,6 @@ describe('Record - validateRecord', () => {
 				},
 				schemaAllDataTypesMixedRestrictions,
 			);
-			console.log(JSON.stringify(result, null, 2));
 			expect(result.valid).false;
 			assert(result.valid === false);