completed the normalizingOutputFormat for betterJSONSchemaErrors

Author: arpitkuriyal

package-lock.json

@@ -38,6 +38,6 @@
   },
   "dependencies": {
     "@hyperjump/browser": "^1.3.1",
-    "@hyperjump/json-schema": "^1.14.1"
+    "@hyperjump/json-schema": "^1.16.0"
   }
 }

package.json

@@ -2,7 +2,7 @@ export const betterJsonSchemaErrors: (
   instance: Json,
   schema: SchemaObject,
   errorOutput: OutputFormat
-) => BetterJsonSchemaErrors;
+) => Promise<BetterJsonSchemaErrors>;
 
 export type BetterJsonSchemaErrors = {
   errors: ErrorObject[];

src/index.d.ts

@@ -5,8 +5,8 @@ import { normalizeOutputFormat } from "./normalizeOutputFormat/normalizeOutput.j
  */
 
 /** @type betterJsonSchemaErrors */
-export function betterJsonSchemaErrors(instance, schema, errorOutput) {
-  const normalizedErrors = normalizeOutputFormat(errorOutput);
+export async function betterJsonSchemaErrors(instance, schema, errorOutput) {
+  const normalizedErrors = await normalizeOutputFormat(errorOutput, schema);
 
   const errors = [];
   for (const error of normalizedErrors) {

src/index.js

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, test } from "vitest";
 
 describe("Better JSON Schema Errors", () => {
   test("greeting", () => {

src/index.test.ts

@@ -1,35 +1,61 @@
+import * as Browser from "@hyperjump/browser";
+import { registerSchema, unregisterSchema } from "@hyperjump/json-schema/draft-2020-12";
+import { getSchema } from "@hyperjump/json-schema/experimental";
+import { pointerSegments } from "@hyperjump/json-pointer";
+import { randomUUID } from "crypto";
+
 /**
- * @import {OutputFormat, OutputUnit, NormalizedError } from "../index.d.ts"
+ * @import { OutputFormat, OutputUnit, NormalizedError, SchemaObject} from "../index.d.ts";
+ * @import { SchemaDocument } from "@hyperjump/json-schema/experimental";
+ * @import { Browser as BrowserType } from "@hyperjump/browser";
  */
 
-/** @type {(errorOutput: OutputFormat) => NormalizedError[]} */
-export function normalizeOutputFormat(errorOutput) {
-  /** @type NormalizedError[] */
+/**
+ * @param {OutputFormat} errorOutput
+ * @param {SchemaObject} schema
+ * @returns {Promise<NormalizedError[]>}
+ */
+export async function normalizeOutputFormat(errorOutput, schema) {
+  /** @type {NormalizedError[]} */
   const output = [];
+
   if (!errorOutput || errorOutput.valid !== false) {
     throw new Error("error Output must follow Draft 2019-09");
   }
 
-  /** @type {(errorOutput: OutputUnit) => void} */
-  function collectErrors(error) {
+  const keywords = new Set([
+    "type", "minLength", "maxLength", "minimum", "maximum", "format", "pattern",
+    "enum", "const", "required", "items", "properties", "allOf", "anyOf", "oneOf",
+    "not", "contains", "uniqueItems", "additionalProperties", "minItems", "maxItems",
+    "minProperties", "maxProperties", "dependentRequired", "dependencies"
+  ]);
+
+  /** @type {(errorOutput: OutputUnit) => Promise<void>} */
+  async function collectErrors(error) {
     if (error.valid) return;
 
     if (!("instanceLocation" in error) || !("absoluteKeywordLocation" in error || "keywordLocation" in error)) {
       throw new Error("error Output must follow Draft 2019-09");
     }
 
-    // TODO: Convert keywordLocation to absoluteKeywordLocation
-    error.absoluteKeywordLocation ??= "https://example.com/main#/minLength";
+    const absoluteKeywordLocation = error.absoluteKeywordLocation
+      ?? await toAbsoluteKeywordLocation(schema, /** @type string */ (error.keywordLocation));
+
+    const fragment = absoluteKeywordLocation.split("#")[1];
+    const lastSegment = fragment.split("/").filter(Boolean).pop();
 
-    output.push({
-      valid: false,
-      absoluteKeywordLocation: error.absoluteKeywordLocation,
-      instanceLocation: normalizeInstanceLocation(error.instanceLocation)
-    });
+    // make a check here to remove the schemaLocation.
+    if (lastSegment && keywords.has(lastSegment)) {
+      output.push({
+        valid: false,
+        absoluteKeywordLocation,
+        instanceLocation: normalizeInstanceLocation(error.instanceLocation)
+      });
+    }
 
     if (error.errors) {
       for (const nestedError of error.errors) {
-        collectErrors(nestedError);
+        await collectErrors(nestedError); // Recursive
       }
     }
   }
@@ -39,14 +65,35 @@ export function normalizeOutputFormat(errorOutput) {
   }
 
   for (const err of errorOutput.errors) {
-    collectErrors(err);
+    await collectErrors(err);
   }
 
   return output;
 }
 
-/** @type (location: string) => string */
+/** @type {(location: string) => string} */
 function normalizeInstanceLocation(location) {
-  if (location.startsWith("/") || location === "") return "#" + location;
-  return location;
+  return location.startsWith("/") || location === "" ? `#${location}` : location;
+}
+
+/**
+ * Convert keywordLocation to absoluteKeywordLocation
+ * @param {SchemaObject} schema
+ * @param {string} keywordLocation
+ * @returns {Promise<string>}
+ */
+export async function toAbsoluteKeywordLocation(schema, keywordLocation) {
+  const uri = `urn:uuid:${randomUUID()}`;
+  try {
+    registerSchema(schema, uri);
+
+    let browser = await getSchema(uri);
+    for (const segment of pointerSegments(keywordLocation)) {
+      browser = /** @type BrowserType<SchemaDocument> */ (await Browser.step(segment, browser));
+    }
+
+    return `${browser.document.baseUri}#${browser.cursor}`;
+  } finally {
+    unregisterSchema(uri);
+  }
 }

src/normalizeOutputFormat/normalizeOutput.js

@@ -1,13 +1,12 @@
 import { describe, expect, test } from "vitest";
 import { normalizeOutputFormat } from "./normalizeOutput.js";
 import { betterJsonSchemaErrors } from "../index.js";
-
 /**
  * @import { OutputFormat, OutputUnit, SchemaObject } from "../index.d.ts"
  */
 
 describe("Error Output Normalization", () => {
-  test("Simple keyword with a standard Basic output format", () => {
+  test("Simple keyword with a standard Basic output format", async () => {
     /** @type SchemaObject */
     const schema = {
       minLength: 3
@@ -26,7 +25,7 @@ describe("Error Output Normalization", () => {
       ]
     };
 
-    const result = betterJsonSchemaErrors(instance, schema, output);
+    const result = await betterJsonSchemaErrors(instance, schema, output);
     expect(result.errors).to.eql([{
       schemaLocation: "https://example.com/main#/minLength",
       instanceLocation: "#",
@@ -35,9 +34,11 @@ describe("Error Output Normalization", () => {
     ]);
   });
 
-  test("Checking when output contain only instanceLocation and keywordLocation ", () => {
+  test("Checking when output contain only instanceLocation and keywordLocation ", async () => {
     /** @type SchemaObject */
     const schema = {
+      $id: "https://example.com/main",
+      $schema: "https://json-schema.org/draft/2020-12/schema",
       minLength: 3
     };
 
@@ -54,17 +55,18 @@ describe("Error Output Normalization", () => {
       ]
     };
 
-    const result = betterJsonSchemaErrors(instance, schema, output);
+    const result = await betterJsonSchemaErrors(instance, schema, output);
     expect(result.errors).to.eql([{
       schemaLocation: "https://example.com/main#/minLength",
       instanceLocation: "#",
       message: "The instance should be at least 3 characters"
     }]);
   });
 
-  test("adding # if instanceLocation doesn't have it", () => {
+  test("adding # if instanceLocation doesn't have it", async () => {
     /** @type SchemaObject */
     const schema = {
+      $id: "https://example.com/main",
       minlength: 3
     };
 
@@ -76,13 +78,13 @@ describe("Error Output Normalization", () => {
       errors: [
         {
           valid: false,
-          keywordLocation: "",
+          absoluteKeywordLocation: "https://example.com/main#/minLength",
           instanceLocation: ""
         }
       ]
     };
 
-    const result = betterJsonSchemaErrors(instance, schema, output);
+    const result = await betterJsonSchemaErrors(instance, schema, output);
     expect(result.errors).to.eql([{
       schemaLocation: "https://example.com/main#/minLength",
       instanceLocation: "#",
@@ -103,7 +105,10 @@ describe("Error Output Normalization", () => {
   // const absoluteKeywordLocation = "/$defs/foo/type";
   // const keywordLocation = "/properties/foo/$ref/type";
 
-  test("checking for the basic output format", () => {
+  test("checking for the basic output format", async () => {
+    const schema = {
+      $id: "https://example.com/polygon"
+    };
     const errorOutput = {
       valid: false,
       errors: [
@@ -131,12 +136,7 @@ describe("Error Output Normalization", () => {
       ]
     };
 
-    expect(normalizeOutputFormat(errorOutput)).to.eql([
-      {
-        valid: false,
-        absoluteKeywordLocation: "https://example.com/polygon#/$defs/point",
-        instanceLocation: "#/1"
-      },
+    expect(await normalizeOutputFormat(errorOutput, schema)).to.eql([
       {
         valid: false,
         absoluteKeywordLocation: "https://example.com/polygon#/$defs/point/required",
@@ -150,7 +150,10 @@ describe("Error Output Normalization", () => {
     ]);
   });
 
-  test("checking for the detailed output format", () => {
+  test("checking for the detailed output format", async () => {
+    const schema = {
+      $id: "https://example.com/polygon"
+    };
     const errorOutput = {
       valid: false,
       keywordLocation: "#",
@@ -181,12 +184,7 @@ describe("Error Output Normalization", () => {
       ]
     };
 
-    expect(normalizeOutputFormat(errorOutput)).to.eql([
-      {
-        valid: false,
-        absoluteKeywordLocation: "https://example.com/polygon#/$defs/point",
-        instanceLocation: "#/1"
-      },
+    expect(await normalizeOutputFormat(errorOutput, schema)).to.eql([
       {
         valid: false,
         absoluteKeywordLocation: "https://example.com/polygon#/$defs/point/required",
@@ -200,7 +198,10 @@ describe("Error Output Normalization", () => {
     ]);
   });
 
-  test("checking for the verbose output format", () => {
+  test("checking for the verbose output format", async () => {
+    const schema = {
+      $id: "https://example.com/polygon"
+    };
     const errorOutput = {
       valid: false,
       keywordLocation: "#",
@@ -232,7 +233,7 @@ describe("Error Output Normalization", () => {
       ]
     };
 
-    expect(normalizeOutputFormat(errorOutput)).to.eql([
+    expect(await normalizeOutputFormat(errorOutput, schema)).to.eql([
       {
         valid: false,
         absoluteKeywordLocation: "https://example.com/schema#/additionalProperties",
@@ -246,7 +247,10 @@ describe("Error Output Normalization", () => {
     ]);
   });
 
-  test("when error output doesnot contain any of these three keyword (valid, absoluteKeywordLocation, instanceLocation)", () => {
+  test("when error output doesnot contain any of these three keyword (valid, absoluteKeywordLocation, instanceLocation)", async () => {
+    const schema = {
+      $id: "https://example.com/polygon"
+    };
     const errorOutput = {
       valid: false,
       errors: [
@@ -256,6 +260,75 @@ describe("Error Output Normalization", () => {
         }
       ]
     };
-    expect(() => normalizeOutputFormat(/** @type any */ (errorOutput))).to.throw("error Output must follow Draft 2019-09");
+    await expect(async () => normalizeOutputFormat(/** @type any */(errorOutput), schema)).to.rejects.toThrow("error Output must follow Draft 2019-09");
+  });
+
+  test("correctly resolves keywordLocation through $ref in $defs", async () => {
+    /** @type SchemaObject */
+    const schema = {
+      $id: "https://example.com/main",
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      properties: {
+        foo: { $ref: "#/$defs/lengthDefinition" }
+      },
+      $defs: {
+        lengthDefinition: {
+          minLength: 3
+        }
+      }
+    };
+    const instance = { foo: "aa" };
+    /** @type OutputFormat */
+    const output = {
+      valid: false,
+      errors: [
+        {
+          keywordLocation: "/properties/foo/$ref/minLength",
+          instanceLocation: "#"
+        }
+      ]
+    };
+
+    const result = await betterJsonSchemaErrors(instance, schema, output);
+    expect(result.errors).to.eql([
+      {
+        schemaLocation: "https://example.com/main#/$defs/lengthDefinition/minLength",
+        instanceLocation: "#",
+        message: "The instance should be at least 3 characters"
+      }
+    ]);
+  });
+
+  test("removes schemaLocation nodes from the error output", async () => {
+    const schema = {
+      $id: "https://example.com/polygon"
+    };
+    const errorOutput = {
+      valid: false,
+      errors: [
+        {
+          valid: false,
+          keywordLocation: "#/items/$ref",
+          absoluteKeywordLocation: "https://example.com/polygon#/$defs/point",
+          instanceLocation: "#/1",
+          error: "A subschema had errors."
+        },
+        {
+          valid: false,
+          keywordLocation: "#/items/$ref/required",
+          absoluteKeywordLocation: "https://example.com/polygon#/$defs/point/required",
+          instanceLocation: "#/1",
+          error: "Required property 'y' not found."
+        }
+      ]
+    };
+
+    expect(await normalizeOutputFormat(errorOutput, schema)).to.eql([
+      {
+        valid: false,
+        absoluteKeywordLocation: "https://example.com/polygon#/$defs/point/required",
+        instanceLocation: "#/1"
+      }
+    ]);
   });
 });