New normalized output implementation

Author: jdesrosiers

src/basic-to-detailed.js

@@ -0,0 +1,242 @@
+import { registerSchema, validate } from "@hyperjump/json-schema/draft-2020-12";
+import { BASIC, compile, getSchema } from "@hyperjump/json-schema/experimental";
+import * as Instance from "@hyperjump/json-schema/instance/experimental";
+
+/**
+ * @import { OutputUnit } from "@hyperjump/json-schema"
+ * @import { AST } from "@hyperjump/json-schema/experimental"
+ * @import { JsonNode } from "@hyperjump/json-schema/instance/experimental"
+ */
+
+/**
+ * @typedef {{
+ *   [instanceLocation: string]: {
+ *     [keywordUri: string]: {
+ *       [keywordLocation: string]: boolean | {
+ *         [schemaLocation: string]: NormalizedOutput
+ *       }
+ *     }
+ *   }
+ * }} NormalizedOutput
+ */
+
+/** @type (schemaLocation: string, ast: AST, instance: JsonNode, errorIndex: ErrorIndex) => NormalizedOutput */
+const evaluateSchema = (schemaLocation, ast, instance, errorIndex) => {
+  const instanceLocation = Instance.uri(instance);
+  const schemaNode = ast[schemaLocation];
+
+  if (typeof schemaNode === "boolean") {
+    return {
+      [instanceLocation]: {
+        "https://json-schema.org/validation": {
+          [schemaLocation]: schemaNode
+        }
+      }
+    };
+  }
+
+  /** @type NormalizedOutput */
+  const output = { [instanceLocation]: {} };
+  for (const [keywordUri, keywordLocation, keywordValue] of schemaNode) {
+    const keyword = keywordHandlers[keywordUri] ?? {};
+
+    const keywordOutput = keyword.evaluate?.(keywordValue, ast, instance, errorIndex);
+    if (keyword.simpleApplicator) {
+      for (const subschemaLocation in keywordOutput) {
+        mergeOutput(output, keywordOutput[subschemaLocation]);
+      }
+    } else if (errorIndex[keywordLocation]?.[instanceLocation]) {
+      output[instanceLocation][keywordUri] ??= {};
+      output[instanceLocation][keywordUri][keywordLocation] = keywordOutput ?? false;
+    } else if (keyword.appliesTo?.(Instance.typeOf(instance)) !== false) {
+      output[instanceLocation][keywordUri] ??= {};
+      output[instanceLocation][keywordUri][keywordLocation] = !errorIndex[keywordLocation]?.[instanceLocation];
+    }
+  }
+
+  return output;
+};
+
+/** @type (a: NormalizedOutput, b: NormalizedOutput) => void */
+const mergeOutput = (a, b) => {
+  for (const instanceLocation in b) {
+    for (const keywordUri in b[instanceLocation]) {
+      a[instanceLocation] ??= {};
+      a[instanceLocation][keywordUri] ??= {};
+
+      Object.assign(a[instanceLocation][keywordUri], b[instanceLocation][keywordUri]);
+    }
+  }
+};
+
+/**
+ * @typedef {{
+ *   evaluate?(value: any, ast: AST, instance: JsonNode, errorIndex: ErrorIndex): { [schemaLocation: string]: NormalizedOutput }
+ *   appliesTo?(type: string): boolean;
+ *   simpleApplicator?: true;
+ * }} KeywordHandler
+ */
+
+/** @type Record<string, KeywordHandler> */
+const keywordHandlers = {};
+
+keywordHandlers["https://json-schema.org/keyword/anyOf"] = {
+  evaluate(/** @type string[] */ anyOf, ast, instance, errorIndex) {
+    /** @type {{ [schemaLocation: string]: NormalizedOutput}} */
+    const errors = {};
+
+    for (const schemaLocation of anyOf) {
+      errors[schemaLocation] = evaluateSchema(schemaLocation, ast, instance, errorIndex);
+    }
+
+    return errors;
+  }
+};
+
+keywordHandlers["https://json-schema.org/keyword/oneOf"] = {
+  evaluate(/** @type string[] */ oneOf, ast, instance, errorIndex) {
+    /** @type Record<string, NormalizedOutput> */
+    const errors = {};
+
+    for (const schemaLocation of oneOf) {
+      errors[schemaLocation] = evaluateSchema(schemaLocation, ast, instance, errorIndex);
+    }
+
+    return errors;
+  }
+};
+
+keywordHandlers["https://json-schema.org/keyword/allOf"] = {
+  evaluate(/** @type string[] */ allOf, ast, instance, errorIndex) {
+    /** @type Record<string, NormalizedOutput> */
+    const errors = {};
+
+    for (const schemaLocation of allOf) {
+      errors[schemaLocation] = evaluateSchema(schemaLocation, ast, instance, errorIndex);
+    }
+
+    return errors;
+  },
+  simpleApplicator: true
+};
+
+keywordHandlers["https://json-schema.org/keyword/ref"] = {
+  evaluate(/** @type string */ ref, ast, instance, errorIndex) {
+    return { [ref]: evaluateSchema(ref, ast, instance, errorIndex) };
+  },
+  simpleApplicator: true
+};
+
+keywordHandlers["https://json-schema.org/keyword/properties"] = {
+  evaluate(/** @type Record<string, string> */ properties, ast, instance, errorIndex) {
+    /** @type Record<string, NormalizedOutput> */
+    const errors = {};
+
+    for (const propertyName in properties) {
+      const propertyNode = Instance.step(propertyName, instance);
+      if (!propertyNode) {
+        continue;
+      }
+
+      errors[properties[propertyName]] = evaluateSchema(properties[propertyName], ast, propertyNode, errorIndex);
+    }
+
+    return errors;
+  },
+  simpleApplicator: true
+};
+
+keywordHandlers["https://json-schema.org/keyword/definitions"] = {
+  appliesTo() {
+    return false;
+  }
+};
+
+keywordHandlers["https://json-schema.org/keyword/minLength"] = {
+  appliesTo(type) {
+    return type === "string";
+  }
+};
+
+keywordHandlers["https://json-schema.org/keyword/minimum"] = {
+  appliesTo(type) {
+    return type === "number";
+  }
+};
+
+/** @typedef {Record<string, Record<string, true>>} ErrorIndex */
+
+/** @type (basicOutput: OutputUnit) => ErrorIndex */
+const constructErrorIndex = (basicOutput) => {
+  /** @type ErrorIndex */
+  const errorIndex = {};
+
+  if (basicOutput.valid) {
+    return errorIndex;
+  }
+
+  for (const error of /** @type OutputUnit[] */ (basicOutput.errors)) {
+    errorIndex[error.absoluteKeywordLocation] ??= {};
+    errorIndex[error.absoluteKeywordLocation][error.instanceLocation] = true;
+  }
+
+  return errorIndex;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+const subjectUri = "https://example.com/main";
+
+registerSchema({
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+
+  // type: "object",
+  // properties: {
+  //   foo: false,
+  //   bar: true
+  // }
+
+  // type: "number",
+  // allOf: [
+  //   { minimum: 5 },
+  //   { minimum: 3 }
+  // ]
+
+  // allOf: [
+  //   true,
+  //   false
+  // ],
+
+  type: "object",
+  properties: {
+    foo: {
+      anyOf: [
+        { $ref: "#/$defs/stringSchema" },
+        { $ref: "#/$defs/numberSchema" }
+      ]
+    },
+    bar: { type: "boolean" }
+  },
+
+  $defs: {
+    stringSchema: {
+      type: "string",
+      minLength: 5
+    },
+    numberSchema: {
+      type: "number",
+      minimum: 10
+    }
+  }
+}, subjectUri);
+
+const instance = { foo: 2 };
+
+const basicOutput = await validate(subjectUri, instance, BASIC);
+const errorIndex = constructErrorIndex(basicOutput);
+
+const schema = await getSchema(subjectUri);
+const { schemaUri, ast } = await compile(schema);
+const value = Instance.fromJs(instance);
+const normalizedOutput = evaluateSchema(schemaUri, ast, value, errorIndex);
+console.log(JSON.stringify(normalizedOutput, null, "  "));