Combine required and dependentRequired error messages

src/error-handlers/draft-04/dependencies.js

@@ -1,6 +1,3 @@
-import { getSchema } from "@hyperjump/json-schema/experimental";
-import * as Schema from "@hyperjump/browser";
-import * as Instance from "@hyperjump/json-schema/instance/experimental";
 import { getErrors } from "../../json-schema-errors.js";
 
 /**
@@ -22,25 +19,6 @@ const dependenciesErrorHandler = async (normalizedErrors, instance, localization
       const dependentSchemaErrors = await getErrors(dependentSchemaOutput, instance, localization);
       errors.push(...dependentSchemaErrors);
     }
-
-    const dependencies = await getSchema(schemaLocation);
-    for await (const [propertyName, dependency] of Schema.entries(dependencies)) {
-      if (!Instance.has(propertyName, instance)) {
-        continue;
-      }
-
-      if (Schema.typeOf(dependency) !== "array") {
-        continue;
-      }
-
-      const dependentRequired = /** @type {string[]} */ (Schema.value(dependency));
-      const missing = dependentRequired.filter((required) => !Instance.has(required, instance));
-      errors.push({
-        message: localization.getRequiredErrorMessage(missing),
-        instanceLocation: Instance.uri(instance),
-        schemaLocations: [schemaLocation]
-      });
-    }
   }
 
   return errors;

src/error-handlers/required.js

@@ -8,32 +8,93 @@ import * as Instance from "@hyperjump/json-schema/instance/experimental";
 
 /** @type ErrorHandler */
 const requiredErrorHandler = async (normalizedErrors, instance, localization) => {
-  /** @type ErrorObject[] */
-  const errors = [];
+  const allMissingRequired = new Set();
+  const allSchemaLocations = new Set();
 
-  for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/required"]) {
-    if (normalizedErrors["https://json-schema.org/keyword/required"][schemaLocation]) {
-      continue;
+  const requiredErrors = normalizedErrors["https://json-schema.org/keyword/required"];
+  if (requiredErrors) {
+    for (const schemaLocation in requiredErrors) {
+      if (requiredErrors[schemaLocation] === false) {
+        allSchemaLocations.add(schemaLocation);
+        const keyword = await getSchema(schemaLocation);
+        const required = /** @type string[] */ (Schema.value(keyword));
+
+        for (const propertyName of required) {
+          if (!Instance.has(propertyName, instance)) {
+            allMissingRequired.add(propertyName);
+          }
+        }
+      }
+    }
+  }
+
+  const dependentRequiredErrors = normalizedErrors["https://json-schema.org/keyword/dependentRequired"];
+  if (dependentRequiredErrors) {
+    for (const schemaLocation in dependentRequiredErrors) {
+      if (dependentRequiredErrors[schemaLocation] === false) {
+        allSchemaLocations.add(schemaLocation);
+        const keyword = await getSchema(schemaLocation);
+        const dependentRequired = /** @type Record<string, string[]> */ (Schema.value(keyword));
+
+        for (const propertyName in dependentRequired) {
+          if (Instance.has(propertyName, instance)) {
+            for (const requiredPropertyName of dependentRequired[propertyName]) {
+              if (!Instance.has(requiredPropertyName, instance)) {
+                allMissingRequired.add(requiredPropertyName);
+              }
+            }
+          }
+        }
+      }
     }
+  }
+
+  const dependenciesErrors = normalizedErrors["https://json-schema.org/keyword/draft-04/dependencies"];
+  if (dependenciesErrors) {
+    for (const schemaLocation in dependenciesErrors) {
+      const dependencyValue = dependenciesErrors[schemaLocation];
+      if (dependencyValue === false || Array.isArray(dependencyValue)) {
+        const keyword = await getSchema(schemaLocation);
+        const dependencies = /** @type Record<string, string[] | object> */ (Schema.value(keyword));
 
-    const keyword = await getSchema(schemaLocation);
-    const required = /** @type string[] */ (Schema.value(keyword));
+        let hasArrayFormDependencies = false;
+        for (const propertyName in dependencies) {
+          if (Instance.has(propertyName, instance)) {
+            const dependency = dependencies[propertyName];
+            if (Array.isArray(dependency)) {
+              hasArrayFormDependencies = true;
+              const dependencyArray = /** @type {string[]} */ (dependency);
+              for (const requiredPropertyName of dependencyArray) {
+                if (!Instance.has(requiredPropertyName, instance)) {
+                  allMissingRequired.add(requiredPropertyName);
+                }
+              }
+            }
+          }
+        }
 
-    const missingRequired = [];
-    for (const propertyName of required) {
-      if (!Instance.has(propertyName, instance)) {
-        missingRequired.push(propertyName);
+        if (hasArrayFormDependencies) {
+          allSchemaLocations.add(schemaLocation);
+        }
       }
     }
+  }
+
+  if (allMissingRequired.size > 0) {
+    /** @type {string[]} */
+    const missingProperties = [...allMissingRequired].sort();
+
+    /** @type {string[]} */
+    const locations = [...allSchemaLocations].sort();
 
-    errors.push({
-      message: localization.getRequiredErrorMessage(missingRequired),
+    return [{
+      message: localization.getRequiredErrorMessage(missingProperties),
       instanceLocation: Instance.uri(instance),
-      schemaLocations: [schemaLocation]
-    });
+      schemaLocations: locations
+    }];
   }
 
-  return errors;
+  return [];
 };
 
 export default requiredErrorHandler;

src/index.js

@@ -58,7 +58,6 @@ import booleanSchemaErrorHandler from "./error-handlers/boolean-schema.js";
 import constErrorHandler from "./error-handlers/const.js";
 import containsErrorHandler from "./error-handlers/contains.js";
 import dependenciesErrorHandler from "./error-handlers/draft-04/dependencies.js";
-import dependentRequiredErrorHandler from "./error-handlers/dependentRequired.js";
 import enumErrorHandler from "./error-handlers/enum.js";
 import exclusiveMaximumErrorHandler from "./error-handlers/exclusiveMaximum.js";
 import exclusiveMinimumErrorHandler from "./error-handlers/exclusiveMinimum.js";
@@ -144,7 +143,6 @@ addErrorHandler(booleanSchemaErrorHandler);
 addErrorHandler(constErrorHandler);
 addErrorHandler(containsErrorHandler);
 addErrorHandler(dependenciesErrorHandler);
-addErrorHandler(dependentRequiredErrorHandler);
 addErrorHandler(enumErrorHandler);
 addErrorHandler(exclusiveMaximumErrorHandler);
 addErrorHandler(exclusiveMinimumErrorHandler);

src/normalization-handlers/draft-04/dependencies.js

@@ -12,18 +12,18 @@ const dependenciesNormalizationHandler = {
     const outputs = [];
 
     if (Instance.typeOf(instance) !== "object") {
-      return outputs;
+      return undefined;
     }
 
     for (const [propertyName, dependency] of dependencies) {
-      if (!Instance.has(propertyName, instance) || typeof dependency !== "string") {
+      if (!Instance.has(propertyName, instance)) {
         continue;
       }
-
-      outputs.push(evaluateSchema(dependency, instance, context));
+      if (typeof dependency === "string") {
+        outputs.push(evaluateSchema(dependency, instance, context));
+      }
     }
-
-    return outputs;
+    return outputs.length > 0 ? outputs : undefined;
   }
 };