Making getErrors synchronous by Ahmedmhmud · Pull Request #205 · hyperjump-io/json-schema-errors

Ahmedmhmud · 2026-04-13T01:22:52Z

This PR removes async schema value lookups from the error formatting path and makes getErrors synchronous by resolving keyword values from the compiled AST to using it so it can be used in @hyperjump/json-schema as we need here (#204).

I replaced async schema reads with two AST resolver functions: getCompiledKeywordValue() for normal keyword lookups by schemaLocation, and getSiblingKeywordValue() for sibling keywords in the same parent node (like draft-04 min/max exclusivity and contains min/max contains). Then getErrors passes this resolver to handlers, so the whole error handling path is synchronous and no longer depends on await getSchema().

getErrors now passes an AST resolver to handlers, including recursive ones, and sibling-dependent keywords use sibling lookup from the same parent AST node. I also adjusted handlers for compiled value shapes (like regex, draft-04 tuples, and const/enum JSON strings), then updated types. All tests are still passing leaves us with the same behavior.

jdesrosiers · 2026-04-13T02:48:11Z

@srivastava-diya, please do the first review

Ahmedmhmud · 2026-04-13T11:04:36Z

Hi @jdesrosiers, @srivastava-diya
I did a clean up for the oxlint & JSDoc issues, is there anything else to do?

Ahmedmhmud · 2026-04-13T22:51:05Z

I made resolver required in ErrorHandler and getErrors, then removed resolver checks from all handlers that use it.

srivastava-diya · 2026-04-14T15:42:55Z

hey @jdesrosiers all my comments have been addressed, LGTM from my side.

jdesrosiers · 2026-04-16T18:07:48Z

+/**
+ * @param {AST} ast
+ * @returns {API.ErrorResolver}
+ */
+const createErrorResolver = (ast) => ({
+  getCompiledKeywordValue: (schemaLocation) => getCompiledKeywordValue(ast, schemaLocation),
+  getSiblingKeywordValue: (schemaLocation, siblingKeywordUri) => {
+    return getSiblingKeywordValue(ast, schemaLocation, siblingKeywordUri);
+  }
+});


I don't think this is necessary. Just pass the AST instead of the resolver and call the functions directly.

It was solving the problem of recursion with anyOf, oneof and dependencies.
These handlers are calling getErrors recursively, so when I delete this method and pass the ast directly, it will be expected that the higher level has AST but the recursive calls expect another type which is ErrorResolver, but I am going to pass it and solve it by ternary condition that checks the type and selecting the value according to it.
If it suits, we will keep it in that way .

No, I mean you don't need an ErrorResolver at all. It doesn't need to exist anywhere. In all cases, you can pass the AST and import the utility functions that use that AST where they are needed.

jdesrosiers · 2026-04-16T18:12:24Z

+const getSiblingKeywordValue = (ast, schemaLocation, siblingKeywordUri) => {
+  const parentLocation = schemaLocation.replace(/\/[^/]+$/, "");
+  const parentNode = ast[parentLocation];
+
+  if (!Array.isArray(parentNode)) {
+    return undefined;
+  }
+
+  for (const [keywordUri, keywordLocation, keywordValue] of parentNode) {
+    if (keywordUri === siblingKeywordUri) {
+      return {
+        keywordLocation,
+        keywordValue
+      };
+    }
+  }
+
+  return undefined;
+};


I don't think it's necessary this function to return the value and the location. The value will come from the AST in all cases. The only thing we need is the location of the sibling keyword.

the value is returned with the location as the handlers like contains.js needs the value but has no access to the AST, getError only has it.

The value that comes from the AST always includes the values you need from the sibling keyword. The min/max keywords use a tuple like [value, isExclusive] and the contains keyword uses an object like { constains, minContains, maxContains }. You don't need to get the value again. All you should ever need that you don't get from the keyword lookup is the schema location of the sibling keyword(s).

Ahmedmhmud · 2026-04-17T17:02:04Z

Hi @jdesrosiers
I solved all the refactor problems above and optimized with Array.find as you mentioned.
But the thing is that I left getSiblingKeywordValue as it is, because if we returned the location only, we will need the value in the handlers like contains.js, but the handles don't have access to the AST so it's better to pass the value also with the location.

jdesrosiers · 2026-04-17T17:51:17Z

+    const compiledPattern = resolver.getCompiledKeywordValue(schemaLocation);
+    const pattern = /** @type RegExp */ (compiledPattern).source;


The cast should be on compiledPattern.

jdesrosiers · 2026-04-17T17:57:59Z

+/**
+ * @param {AST} ast
+ * @returns {API.ErrorResolver}
+ */
+const createErrorResolver = (ast) => ({
+  getCompiledKeywordValue: (schemaLocation) => getCompiledKeywordValue(ast, schemaLocation),
+  getSiblingKeywordValue: (schemaLocation, siblingKeywordUri) => {
+    return getSiblingKeywordValue(ast, schemaLocation, siblingKeywordUri);
+  }
+});


No, I mean you don't need an ErrorResolver at all. It doesn't need to exist anywhere. In all cases, you can pass the AST and import the utility functions that use that AST where they are needed.

jdesrosiers · 2026-04-17T18:01:41Z

+const getSiblingKeywordValue = (ast, schemaLocation, siblingKeywordUri) => {
+  const parentLocation = schemaLocation.replace(/\/[^/]+$/, "");
+  const parentNode = ast[parentLocation];
+
+  if (!Array.isArray(parentNode)) {
+    return undefined;
+  }
+
+  for (const [keywordUri, keywordLocation, keywordValue] of parentNode) {
+    if (keywordUri === siblingKeywordUri) {
+      return {
+        keywordLocation,
+        keywordValue
+      };
+    }
+  }
+
+  return undefined;
+};


The value that comes from the AST always includes the values you need from the sibling keyword. The min/max keywords use a tuple like [value, isExclusive] and the contains keyword uses an object like { constains, minContains, maxContains }. You don't need to get the value again. All you should ever need that you don't get from the keyword lookup is the schema location of the sibling keyword(s).

Ahmedmhmud · 2026-04-18T18:54:51Z

Hi @jdesrosiers
I removed the unnecessary ErrorResolver and passed the AST to the handlers
Now I call the resolvers in the handlers whenever I need them & this fixed also the problem of returning the value with the location of the sibling keywords since we already got the AST in the handlers.

jdesrosiers · 2026-04-18T23:27:20Z

+      const parentLocation = schemaLocation.replace(/\/[^/]+$/, "");
+      const parentNode = ast[parentLocation];
+      const containsNode = Array.isArray(parentNode) ? parentNode.find(([, keywordLocation]) => keywordLocation === schemaLocation) : undefined;
+      const containsRange = /** @type {ContainsRange} */ (containsNode?.[2] ?? {});


Why aren't you using getCompiledKeywordValue here?

Sorry I used the AST and totally forgot that I'm already doing this in getCompiledKewewordValue, my bad.

jdesrosiers · 2026-04-18T23:33:02Z

+    const exclusiveKeywordLocation = getSiblingKeywordValue(ast, schemaLocation, "https://json-schema.org/keyword/draft-04/exclusiveMaximum");
+    const exclusiveLocation = exclusive && exclusiveKeywordLocation ? exclusiveKeywordLocation : "";


This only gets used if maximum < lowestMaximum && exclusive === true, so only build it in the conditional below if it's exclusive.

jdesrosiers · 2026-04-18T23:34:32Z

+};
+
+/** @type (ast: AST, schemaLocation: string, siblingKeywordUri: string) => string | undefined */
+export const getSiblingKeywordValue = (ast, schemaLocation, siblingKeywordUri) => {


This now returns a location, not a value. So, we need to update the function name.

…th getErrors