Support schema in YAML

Author: jdesrosiers

README.md

@@ -1,9 +1,9 @@
 # Hyperjump - JSON Schema Test Coverage
 
 This package provides tools for testing JSON Schemas and providing test coverage
-for schema files in your code base. Integration is provided for Vitest, but the
-component for collecting the coverage data is also exposed if you want to
-do some other integration.
+for schema files in JSON or YAML in your code base. Integration is provided for
+Vitest, but the component for collecting the coverage data is also exposed if
+you want to do some other integration.
 
 Validation is done by `@hyperjump/json-schema`, so you can use any version of
 JSON Schema supported by that package.
@@ -28,9 +28,10 @@ All files    |   81.81 |    66.66 |      80 |   88.88 |
 
 The following are known limitations I'm hopeful can be addressed.
 
-- Coverage can only be reported for `**/*.schema.json` and `**/schema.json`
-  files.
-- Schemas in YAML aren't supported.
+- Coverage can only be reported for the following files
+  - `**/*.schema.json` and `**/schema.json`
+  - `**/*.schema.yaml` and `**/schema.yaml`
+  - `**/*.schema.yml` and `**/schema.yml`
 
 ## Vitest
 

package.json

@@ -28,6 +28,7 @@
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "*",
+    "@types/content-type": "^1.1.9",
     "@types/istanbul-lib-coverage": "^2.0.6",
     "@types/istanbul-reports": "^3.0.4",
     "@types/moo": "^0.5.10",
@@ -42,13 +43,16 @@
   "dependencies": {
     "@hyperjump/json-schema": "^1.16.0",
     "@hyperjump/uri": "^1.3.1",
+    "content-type": "^1.0.5",
     "ignore": "^7.0.5",
     "istanbul-lib-coverage": "^3.2.2",
     "istanbul-lib-report": "^3.0.1",
     "istanbul-reports": "^3.1.7",
     "moo": "^0.5.2",
     "pathe": "^2.0.3",
     "tinyglobby": "^0.2.14",
-    "vfile": "^6.0.3"
+    "vfile": "^6.0.3",
+    "yaml": "^2.8.0",
+    "yaml-unist-parser": "^2.0.5"
   }
 }

src/json-schema.js

@@ -0,0 +1,31 @@
+import "@hyperjump/json-schema/draft-2020-12";
+import "@hyperjump/json-schema/draft-2019-09";
+import "@hyperjump/json-schema/draft-07";
+import "@hyperjump/json-schema/draft-06";
+import "@hyperjump/json-schema/draft-04";
+import "@hyperjump/json-schema/openapi-3-0";
+import "@hyperjump/json-schema/openapi-3-1";
+import { buildSchemaDocument } from "@hyperjump/json-schema/experimental";
+import { addMediaTypePlugin } from "@hyperjump/browser";
+import contentTypeParser from "content-type";
+import YAML from "yaml";
+
+/**
+ * @import { SchemaObject } from "@hyperjump/json-schema"
+ */
+
+addMediaTypePlugin("application/schema+yaml", {
+  parse: async (response) => {
+    const contentType = contentTypeParser.parse(response.headers.get("content-type") ?? "");
+    const contextDialectId = contentType.parameters.schema ?? contentType.parameters.profile;
+
+    /** @type SchemaObject */
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const yaml = YAML.parse(await response.text());
+    return buildSchemaDocument(yaml, response.url, contextDialectId);
+  },
+  // eslint-disable-next-line @typescript-eslint/require-await
+  fileMatcher: async (path) => /\.schema\.ya?ml$/.test(path)
+});
+
+export * from "@hyperjump/json-schema/draft-2020-12";

src/json-util.js

@@ -1,5 +1,6 @@
 import * as JsonPointer from "@hyperjump/json-pointer";
 import { JsonLexer } from "./json-lexer.js";
+import { parse as parseYaml } from "yaml-unist-parser";
 
 /**
  * @import { Node, Position } from "unist"
@@ -9,52 +10,59 @@ import { JsonLexer } from "./json-lexer.js";
  *   JsonNode,
  *   JsonObjectNode,
  *   JsonPropertyNameNode,
- *   JsonPropertyNode
+ *   JsonPropertyNode,
+ *   JsonStringNode
  * } from "./jsonast.d.ts"
+ * @import {
+ *   YamlUnistNode,
+ *   MappingKey,
+ *   MappingItem,
+ *   FlowMappingItem,
+ *   ContentNode
+ * } from "yaml-unist-parser"
  */
 
-/** @type (json: string, uri?: string) => JsonNode */
-export const fromJson = (json, uri = "") => {
+/** @type (json: string) => JsonNode */
+export const fromJson = (json) => {
   const lexer = new JsonLexer(json);
 
   const token = lexer.nextToken();
-  const jsonValue = parseValue(token, lexer, undefined, uri, "");
+  const jsonValue = parseValue(token, lexer, undefined);
 
   lexer.done();
 
   return jsonValue;
 };
 
-/** @type (token: JsonToken, lexer: JsonLexer, key: string | undefined, uri: string, pointer: string) => JsonNode */
-const parseValue = (token, lexer, _key, uri, pointer) => {
+/** @type (token: JsonToken, lexer: JsonLexer, key: string | undefined) => JsonNode */
+const parseValue = (token, lexer, _key) => {
   switch (token.type) {
     case "null":
     case "boolean":
     case "number":
     case "string":
-      return parseScalar(token, uri, pointer);
+      return parseScalar(token);
     case "[":
-      return parseArray(token, lexer, uri, pointer);
+      return parseArray(token, lexer);
     case "{":
-      return parseObject(token, lexer, uri, pointer);
+      return parseObject(token, lexer);
     default:
       throw lexer.syntaxError("Expected a JSON value", token);
   }
 };
 
-/** @type (token: JsonToken<"null" | "boolean" | "number" | "string">, uri: string, pointer: string) => JsonNode */
-const parseScalar = (token, uri, pointer) => {
+/** @type (token: JsonToken<"null" | "boolean" | "number" | "string">) => JsonNode */
+const parseScalar = (token) => {
   return {
     type: "json",
     jsonType: token.type,
     value: JSON.parse(token.value), // eslint-disable-line @typescript-eslint/no-unsafe-assignment
-    location: `${uri}#${encodeURI(pointer)}`,
     position: tokenPosition(token)
   };
 };
 
-/** @type (token: JsonToken, lexer: JsonLexer, key: string, uri: string, pointer: string) => JsonPropertyNode */
-const parseProperty = (token, lexer, _key, uri, pointer) => {
+/** @type (token: JsonToken, lexer: JsonLexer, key: string) => JsonPropertyNode */
+const parseProperty = (token, lexer, _key) => {
   if (token.type !== "string") {
     throw lexer.syntaxError("Expected a propertry", token);
   }
@@ -71,7 +79,7 @@ const parseProperty = (token, lexer, _key, uri, pointer) => {
     throw lexer.syntaxError("Expected :", token);
   }
 
-  const valueNode = parseValue(lexer.nextToken(), lexer, keyNode.value, uri, JsonPointer.append(keyNode.value, pointer));
+  const valueNode = parseValue(lexer.nextToken(), lexer, keyNode.value);
 
   return {
     type: "json-property",
@@ -90,11 +98,11 @@ const parseProperty = (token, lexer, _key, uri, pointer) => {
 
 /**
  * @type <P extends ParentNode<C>, C extends JsonNode | JsonPropertyNode>(
- *   parseChild: (token: JsonToken, lexer: JsonLexer, key: string, uri: string, pointer: string) => C,
+ *   parseChild: (token: JsonToken, lexer: JsonLexer, key: string) => C,
  *   endToken: string
- * ) => (lexer: JsonLexer, node: P, uri: string, pointer: string) => P
+ * ) => (lexer: JsonLexer, node: P) => P
  */
-const parseCommaSeparated = (parseChild, endToken) => (lexer, node, uri, pointer) => {
+const parseCommaSeparated = (parseChild, endToken) => (lexer, node) => {
   for (let index = 0; true; index++) {
     let token = lexer.nextToken();
 
@@ -111,44 +119,42 @@ const parseCommaSeparated = (parseChild, endToken) => (lexer, node, uri, pointer
       }
     }
 
-    const childNode = parseChild(token, lexer, `${index}`, uri, pointer);
+    const childNode = parseChild(token, lexer, `${index}`);
     if (childNode) {
       node.children.push(childNode);
     }
   }
 };
 
-/** @type (openToken: JsonToken, lexer: JsonLexer, uri: string, pointer: string) => JsonArrayNode */
-const parseArray = (openToken, lexer, uri, pointer) => {
+/** @type (openToken: JsonToken, lexer: JsonLexer) => JsonArrayNode */
+const parseArray = (openToken, lexer) => {
   return parseItems(lexer, {
     type: "json",
     jsonType: "array",
     children: [],
-    location: `${uri}#${encodeURI(pointer)}`,
     position: tokenPosition(openToken)
-  }, uri, pointer);
+  });
 };
 
-/** @type (token: JsonToken, lexer: JsonLexer, key: string, uri: string, pointer: string) => JsonNode */
-const parseItem = (token, lexer, key, uri, pointer) => {
-  return parseValue(token, lexer, key, uri, JsonPointer.append(key, pointer));
+/** @type (token: JsonToken, lexer: JsonLexer, key: string) => JsonNode */
+const parseItem = (token, lexer, key) => {
+  return parseValue(token, lexer, key);
 };
 
-/** @type (lexer: JsonLexer, node: { type: "json" } & JsonArrayNode, uri: string, pointer: string) => JsonArrayNode */
+/** @type (lexer: JsonLexer, node: { type: "json" } & JsonArrayNode) => JsonArrayNode */
 const parseItems = parseCommaSeparated(parseItem, "]");
 
-/** @type (openToken: JsonToken, lexer: JsonLexer, uri: string, pointer: string) => JsonObjectNode */
-const parseObject = (openToken, lexer, uri, pointer) => {
+/** @type (openToken: JsonToken, lexer: JsonLexer) => JsonObjectNode */
+const parseObject = (openToken, lexer) => {
   return parseProperties(lexer, {
     type: "json",
     jsonType: "object",
     children: [],
-    location: `${uri}#${encodeURI(pointer)}`,
     position: tokenPosition(openToken)
-  }, uri, pointer);
+  });
 };
 
-/** @type (lexer: JsonLexer, node: { type: "json" } & JsonObjectNode, uri: string, pointer: string) => JsonObjectNode */
+/** @type (lexer: JsonLexer, node: { type: "json" } & JsonObjectNode) => JsonObjectNode */
 const parseProperties = parseCommaSeparated(parseProperty, "}");
 
 /** @type (startToken: JsonToken, endToken?: JsonToken) => Position */
@@ -211,3 +217,121 @@ export const getNodeFromPointer = (tree, pointer, returnProperty) => {
 
   return node.type === "json-property" && !returnProperty ? node.children[1] : node;
 };
+
+/** @type (yaml: string) => JsonNode */
+export const fromYaml = (yaml) => {
+  const root = parseYaml(yaml);
+  return yamlToJson(root);
+};
+
+/**
+ * @overload
+ * @param {MappingItem | FlowMappingItem} yamlNode
+ * @returns {JsonPropertyNode}
+ *
+ * @overload
+ * @param {MappingKey} yamlNode
+ * @returns {JsonPropertyNameNode}
+ *
+ * @overload
+ * @param {ContentNode} yamlNode
+ * @returns {JsonStringNode}
+ *
+ * @overload
+ * @param {YamlUnistNode} yamlNode
+ * @returns {JsonNode}
+ *
+ * @param {YamlUnistNode} yamlNode
+ * @returns {JsonNode | JsonPropertyNode | JsonPropertyNameNode}
+ */
+const yamlToJson = (yamlNode) => {
+  switch (yamlNode.type) {
+    case "root":
+      return yamlToJson(yamlNode.children[0]);
+
+    case "document":
+      return yamlToJson(yamlNode.children[1]);
+
+    case "documentHead":
+      throw Error(`Not Implemented - ${yamlNode.type}`);
+
+    case "documentBody":
+      if (yamlNode.children.length === 0) {
+        throw Error("YAML documents must contain a value");
+      }
+      return yamlToJson(yamlNode.children[0]);
+
+    case "plain":
+    case "quoteDouble":
+    case "quoteSingle":
+    case "blockLiteral":
+    case "blockFolded":
+      /** @type JsonStringNode */
+      const stringNode = {
+        type: "json",
+        jsonType: "string",
+        value: yamlNode.value,
+        position: yamlNode.position
+      };
+      return stringNode;
+
+    case "mapping":
+    case "flowMapping":
+      /** @type JsonObjectNode */
+      const objectNode = {
+        type: "json",
+        jsonType: "object",
+        children: yamlNode.children.map((mappingItemNode) => yamlToJson(mappingItemNode)),
+        position: yamlNode.position
+      };
+      return objectNode;
+
+    case "mappingItem":
+    case "flowMappingItem":
+      const [mappingKeyNode, mappingValueNode] = yamlNode.children;
+
+      /** @type JsonPropertyNode */
+      const propertyNode = {
+        type: "json-property",
+        children: [
+          yamlToJson(mappingKeyNode),
+          yamlToJson(mappingValueNode)
+        ],
+        position: yamlNode.position
+      };
+
+      return propertyNode;
+
+    case "mappingKey":
+      const contentNode = yamlToJson(/** @type ContentNode */ (yamlNode.children[0]));
+      /** @type JsonPropertyNameNode */
+      const propertyNameNode = {
+        type: "json-property-name",
+        jsonType: "string",
+        value: contentNode.value,
+        position: yamlNode.position
+      };
+      return propertyNameNode;
+
+    case "mappingValue":
+      return yamlToJson(/** @type ContentNode */ (yamlNode.children[0]));
+
+    case "sequence":
+    case "flowSequence":
+      /** @type JsonArrayNode */
+      const arrayNode = {
+        type: "json",
+        jsonType: "array",
+        children: yamlNode.children.map((sequenceItemNode) => yamlToJson(sequenceItemNode)),
+        position: yamlNode.position
+      };
+      return arrayNode;
+
+    case "sequenceItem":
+    case "flowSequenceItem":
+      return yamlToJson(/** @type ContentNode */ (yamlNode.children[0]));
+
+    default:
+      throw Error(`YAML error. ${yamlNode.type}`);
+  }
+};