Add support for embedded schemas

Author: jdesrosiers

README.md

@@ -28,7 +28,6 @@ All files    |   81.81 |    66.66 |      80 |   88.88 |
 
 The following are known limitations I'm hopeful can be addressed.
 
-- Coverage can't be reported for embedded schemas.
 - Coverage can only be reported for `**/*.schema.json` and `**/schema.json`
   files.
 - Schemas in YAML aren't supported.

src/coverage-util.js

@@ -1,5 +1,5 @@
 import { getKeyword } from "@hyperjump/json-schema/experimental";
-import { parseIri } from "@hyperjump/uri";
+import { parseIri, toAbsoluteIri } from "@hyperjump/uri";
 import { getNodeFromPointer } from "./json-util.js";
 
 /**
@@ -9,8 +9,8 @@ import { getNodeFromPointer } from "./json-util.js";
  * @import { JsonNode } from "./jsonast.js"
  */
 
-/** @type (compiledSchema: CompiledSchema, schemaPath: string, tree: JsonNode) => CoverageMapData */
-export const astToCoverageMap = (compiledSchema, schemaPath, tree) => {
+/** @type (compiledSchema: CompiledSchema, schemaPath: string, schemaNodes: Record<string, JsonNode>) => CoverageMapData */
+export const astToCoverageMap = (compiledSchema, schemaPath, schemaNodes) => {
   /** @type FileCoverageData */
   const fileCoverage = {
     path: schemaPath,
@@ -23,12 +23,16 @@ export const astToCoverageMap = (compiledSchema, schemaPath, tree) => {
   };
 
   for (const schemaLocation in compiledSchema.ast) {
-    if (schemaLocation === "metaData" || schemaLocation === "plugins" || !schemaLocation.startsWith(compiledSchema.schemaUri)) {
+    if (schemaLocation === "metaData" || schemaLocation === "plugins") {
+      continue;
+    }
+
+    if (!(toAbsoluteIri(schemaLocation) in schemaNodes)) {
       continue;
     }
 
     const pointer = decodeURI(parseIri(schemaLocation).fragment ?? "");
-    const node = getNodeFromPointer(tree, pointer);
+    const node = getNodeFromPointer(schemaNodes[toAbsoluteIri(schemaLocation)], pointer, true);
 
     const declRange = node.type === "json-property"
       ? positionToRange(node.children[0].position)
@@ -58,7 +62,7 @@ export const astToCoverageMap = (compiledSchema, schemaPath, tree) => {
           const [keywordUri, keywordLocation] = keywordNode;
 
           const pointer = decodeURI(parseIri(keywordLocation).fragment ?? "");
-          const node = getNodeFromPointer(tree, pointer);
+          const node = getNodeFromPointer(schemaNodes[toAbsoluteIri(keywordLocation)], pointer, true);
           const range = positionToRange(node.position);
 
           // Create statement

src/json-util.js

@@ -169,8 +169,24 @@ const tokenPosition = (startToken, endToken) => {
   };
 };
 
-/** @type (tree: JsonNode, pointer: string) => JsonNode | JsonPropertyNode */
-export const getNodeFromPointer = (tree, pointer) => {
+/**
+ * @overload
+ * @param {JsonNode} tree
+ * @param {string} pointer
+ * @param {true} returnProperty
+ * @return {JsonNode | JsonPropertyNode}
+ *
+ * @overload
+ * @param {JsonNode} tree
+ * @param {string} pointer
+ * @return {JsonNode}
+ *
+ * @param {JsonNode} tree
+ * @param {string} pointer
+ * @param {true} [returnProperty]
+ * @return {JsonNode | JsonPropertyNode}
+ */
+export const getNodeFromPointer = (tree, pointer, returnProperty) => {
   /** @type JsonNode | JsonPropertyNode | undefined */
   let node = tree;
 
@@ -193,5 +209,5 @@ export const getNodeFromPointer = (tree, pointer) => {
     }
   }
 
-  return node;
+  return node.type === "json-property" && !returnProperty ? node.children[1] : node;
 };

src/test-coverage-evaluation-plugin.js

@@ -20,8 +20,8 @@ export class TestCoverageEvaluationPlugin {
 
   /** @type NonNullable<EvaluationPlugin["beforeSchema"]> */
   beforeSchema(schemaUri) {
-    const schemaLocation = toAbsoluteIri(schemaUri);
-    if (!(schemaLocation in this.#filePathFor)) {
+    if (!(schemaUri in this.#filePathFor)) {
+      const schemaLocation = toAbsoluteIri(schemaUri);
       const fileHash = createHash("md5").update(`${schemaLocation}#`).digest("hex");
       const coverageFilePath = resolve(".json-schema-coverage", fileHash);
 
@@ -30,17 +30,19 @@ export class TestCoverageEvaluationPlugin {
         /** @type CoverageMapData */
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const coverageMapData = JSON.parse(json);
-        const fileCoveragePath = Object.keys(coverageMapData)[0];
-        Object.assign(this.coverageMap, coverageMapData);
-        this.#filePathFor[schemaLocation] = fileCoveragePath;
+        for (const fileCoveragePath in coverageMapData) {
+          this.coverageMap[fileCoveragePath] = coverageMapData[fileCoveragePath];
+          for (const location in this.coverageMap[fileCoveragePath].s) {
+            this.#filePathFor[location] = fileCoveragePath;
+          }
+        }
       }
     }
   }
 
   /** @type NonNullable<EvaluationPlugin["afterKeyword"]> */
   afterKeyword([, keywordLocation], _instance, _context, valid) {
-    const schemaLocation = toAbsoluteIri(keywordLocation);
-    const filePath = this.#filePathFor[schemaLocation];
+    const filePath = this.#filePathFor[keywordLocation];
     if (!(filePath in this.coverageMap)) {
       return;
     }
@@ -54,8 +56,7 @@ export class TestCoverageEvaluationPlugin {
 
   /** @type NonNullable<EvaluationPlugin["afterSchema"]> */
   afterSchema(schemaUri) {
-    const schemaLocation = toAbsoluteIri(schemaUri);
-    const filePath = this.#filePathFor[schemaLocation];
+    const filePath = this.#filePathFor[schemaUri];
     if (!(filePath in this.coverageMap)) {
       return;
     }

src/vitest/coverage-provider.js

@@ -18,8 +18,10 @@ import "@hyperjump/json-schema/draft-04";
 import "@hyperjump/json-schema/openapi-3-0";
 import "@hyperjump/json-schema/openapi-3-1";
 import { compile, getSchema } from "@hyperjump/json-schema/experimental";
+import * as JsonPointer from "@hyperjump/json-pointer";
+import { jrefTypeOf, Reference } from "@hyperjump/browser/jref";
 import { astToCoverageMap } from "../coverage-util.js";
-import { fromJson } from "../json-util.js";
+import { fromJson, getNodeFromPointer } from "../json-util.js";
 
 /**
  * @import {
@@ -31,6 +33,8 @@ import { fromJson } from "../json-util.js";
  * } from "vitest"
  * @import { CoverageMap, CoverageMapData } from "istanbul-lib-coverage"
  * @import { SchemaObject } from "@hyperjump/json-schema"
+ * @import { JRef } from "@hyperjump/browser/jref"
+ * @import { JsonNode } from "../jsonast.js"
  */
 
 /** @type CoverageProviderModule */
@@ -142,16 +146,60 @@ class JsonSchemaCoverageProvider {
         const schemaPath = path.resolve(root, file);
         const schema = await getSchema(schemaPath);
         const compiledSchema = await compile(schema);
-        const fileHash = createHash("md5").update(compiledSchema.schemaUri).digest("hex");
-        const coverageFilePath = path.resolve(this.coverageFilesDirectory, fileHash);
+
         const json = await fs.readFile(schemaPath, "utf-8");
         const tree = fromJson(json);
-        const coverageMap = astToCoverageMap(compiledSchema, path.resolve(root, file), tree);
+        /** @type Record<string, JsonNode> */
+        const schemaNodes = {};
+        for (const schemaUri in schema.document.embedded ?? {}) {
+          const pointer = this.#findEmbedded(schema.document.root, schemaUri);
+          schemaNodes[schemaUri] = getNodeFromPointer(tree, pointer);
+        }
+        const coverageMap = astToCoverageMap(compiledSchema, schemaPath, schemaNodes);
+
+        const fileHash = createHash("md5").update(compiledSchema.schemaUri).digest("hex");
+        const coverageFilePath = path.resolve(this.coverageFilesDirectory, fileHash);
         await fs.writeFile(coverageFilePath, JSON.stringify(coverageMap));
       }
     }
   }
 
+  /** @type (node: JRef, uri: string, pointer?: string) => Generator<[string, JRef]> */
+  * #allSchemaNodes(node, uri, pointer = "") {
+    yield [pointer, node];
+
+    switch (jrefTypeOf(node)) {
+      case "object":
+        const jrefObject = /** @type Record<string, JRef> */ (node);
+        for (const key in jrefObject) {
+          yield* this.#allSchemaNodes(jrefObject[key], uri, JsonPointer.append(key, pointer));
+        }
+        break;
+
+      case "array":
+        const jrefArray = /** @type JRef[] */ (node);
+        let index = 0;
+        for (const item of jrefArray) {
+          yield* this.#allSchemaNodes(item, uri, JsonPointer.append(`${index++}`, pointer));
+        }
+        break;
+    }
+  }
+
+  /** @type (root: JRef, uri: string) => string */
+  #findEmbedded(root, uri) {
+    for (const [pointer, node] of this.#allSchemaNodes(root, uri)) {
+      if (node instanceof Reference) {
+        const json = node.toJSON();
+        if (typeof json === "object" && json !== null && !("$ref" in json) && node.href === uri) {
+          return pointer;
+        }
+      }
+    }
+
+    return "";
+  }
+
   /** @type () => Promise<void> */
   async cleanAfterRun() {
     await fs.rm(this.coverageFilesDirectory, { recursive: true });