feat: implement discriminator optimization for JSON schema validation

Author: mohankumarelec

src/parser/jsonParser.ts

@@ -485,9 +485,140 @@ function validate(n: ASTNode | undefined, schema: JSONSchema, validationResult:
 		const testAlternatives = (alternatives: JSONSchemaRef[], maxOneMatch: boolean) => {
 			const matches = [];
 
+			// Try to detect and apply discriminator optimization dynamically
+			let alternativesToTest = alternatives;
+
+			// Attempt to find a common discriminator property across alternatives
+			const tryDiscriminatorOptimization = () => {
+				if (alternatives.length < 2) {
+					return; // No point optimizing with less than 2 alternatives
+				}
+
+				if (node.type === 'object') {
+					// Early exit: if node has no properties, can't apply optimization
+					if (!node.properties || node.properties.length === 0) {
+						return;
+					}
+
+					// Find properties that have const values in ALL alternatives
+					const propertyConstMap = new Map<string, Map<any, number[]>>();
+
+					for (let i = 0; i < alternatives.length; i++) {
+						const altSchema = asSchema(alternatives[i]);
+						if (!altSchema.properties) {
+							// If any alternative has no properties, we can't use object property discrimination
+							return;
+						}
+						for (const propName in altSchema.properties) {
+							const propSchema = asSchema(altSchema.properties[propName]);
+							if (propSchema.const !== undefined) {
+								if (!propertyConstMap.has(propName)) {
+									propertyConstMap.set(propName, new Map());
+								}
+								const constMap = propertyConstMap.get(propName)!;
+								if (!constMap.has(propSchema.const)) {
+									constMap.set(propSchema.const, []);
+								}
+								constMap.get(propSchema.const)!.push(i);
+							}
+						}
+					}
+
+					// Early exit: if no const properties found, can't apply optimization
+					if (propertyConstMap.size === 0) {
+						return;
+					}
+
+					// Find a property where ALL alternatives have a const value (one per alternative)
+					for (const [propName, constMap] of Array.from(propertyConstMap.entries())) {
+						const coveredAlternatives = new Set<number>();
+						constMap.forEach((indices) => {
+							indices.forEach(idx => coveredAlternatives.add(idx));
+						});
+						// This property is a valid discriminator ONLY if ALL alternatives have a const value for it
+						if (coveredAlternatives.size === alternatives.length) {
+							// Extract the discriminator value from the current node
+							const prop = node.properties.find(p => p.keyNode.value === propName);
+							if (prop?.valueNode?.type === 'string') {
+								const discriminatorValue = prop.valueNode.value;
+								const matchingIndices = constMap.get(discriminatorValue);
+								if (matchingIndices && matchingIndices.length > 0) {
+									alternativesToTest = matchingIndices.map(idx => alternatives[idx]);
+									return;
+								}
+							}
+							// If this property covers all alternatives but we couldn't match,
+							break;
+						}
+					}
+				} else if (node.type === 'array') {
+					// Early exit: if node has no items, can't apply optimization
+					if (!node.items || node.items.length === 0) {
+						return;
+					}
+
+					// Find array item indices that have const values in ALL alternatives
+					const indexConstMap = new Map<number, Map<any, number[]>>();
+
+					for (let i = 0; i < alternatives.length; i++) {
+						const altSchema = asSchema(alternatives[i]);
+						const itemSchemas = altSchema.prefixItems || (Array.isArray(altSchema.items) ? altSchema.items : undefined);
+
+						if (!itemSchemas) {
+							// If any alternative has no item schemas, we can't use array index discrimination
+							return;
+						}
+
+						itemSchemas.forEach((itemSchemaRef, itemIndex) => {
+							const itemSchema = asSchema(itemSchemaRef);
+							if (itemSchema.const !== undefined) {
+								if (!indexConstMap.has(itemIndex)) {
+									indexConstMap.set(itemIndex, new Map());
+								}
+								const constMap = indexConstMap.get(itemIndex)!;
+								if (!constMap.has(itemSchema.const)) {
+									constMap.set(itemSchema.const, []);
+								}
+								constMap.get(itemSchema.const)!.push(i);
+							}
+						});
+					}
+
+					// Early exit: if no const items found, can't apply optimization
+					if (indexConstMap.size === 0) {
+						return;
+					}
+
+					// Find an index where ALL alternatives have a const value (one per alternative)
+					for (const [itemIndex, constMap] of Array.from(indexConstMap.entries())) {
+						const coveredAlternatives = new Set<number>();
+						constMap.forEach((indices) => {
+							indices.forEach(idx => coveredAlternatives.add(idx));
+						});
+						// This index is a valid discriminator ONLY if ALL alternatives have a const value at this index
+						if (coveredAlternatives.size === alternatives.length) {
+							// Extract the discriminator value from the current node
+							const item = node.items[itemIndex];
+							if (item?.type === 'string') {
+								const discriminatorValue = item.value;
+								const matchingIndices = constMap.get(discriminatorValue);
+								if (matchingIndices && matchingIndices.length > 0) {
+									alternativesToTest = matchingIndices.map(idx => alternatives[idx]);
+									return;
+								}
+							}
+							// If this index covers all alternatives but we couldn't match,
+							break;
+						}
+					}
+				}
+			};
+
+			tryDiscriminatorOptimization();
+
 			// remember the best match that is used for error messages
 			let bestMatch: { schema: JSONSchema; validationResult: ValidationResult; matchingSchemas: ISchemaCollector; } | undefined = undefined;
-			for (const subSchemaRef of alternatives) {
+			for (const subSchemaRef of alternativesToTest) {
 				const subSchema = asSchema(subSchemaRef);
 				const subValidationResult = new ValidationResult();
 				const subMatchingSchemas = matchingSchemas.newSub();