Use SchemaNode instead of JsonNode

jdesrosiers · jdesrosiers · commit 61ae4fb305f4 · 2024-06-07T19:22:00.000-07:00
diff --git a/language-server/src/features/deprecated.js b/language-server/src/features/deprecated.js
@@ -1,5 +1,5 @@
 import { DiagnosticSeverity, DiagnosticTag } from "vscode-languageserver";
-import * as JsonNode from "../json-node.js";
+import * as SchemaNode from "../schema-node.js";
 import { subscribe } from "../pubsub.js";
 
 
@@ -12,12 +12,12 @@ export default {
 
   onInitialized() {
     subscribe("diagnostics", async (_message, { schemaDocument, diagnostics }) => {
-      for (const { schemaResource } of schemaDocument.schemaResources) {
-        for (const deprecated of JsonNode.annotatedWith(schemaResource, "deprecated", annotationDialectUri)) {
-          if (JsonNode.annotation(deprecated, "deprecated", annotationDialectUri).some((deprecated) => deprecated)) {
+      for (const schemaResource of schemaDocument.schemaResources) {
+        for (const deprecated of SchemaNode.annotatedWith(schemaResource, "deprecated", annotationDialectUri)) {
+          if (SchemaNode.annotation(deprecated, "deprecated", annotationDialectUri).some((deprecated) => deprecated)) {
             diagnostics.push({
               instance: deprecated.parent,
-              message: JsonNode.annotation(deprecated, "x-deprecationMessage", annotationDialectUri).join("\n") || "deprecated",
+              message: SchemaNode.annotation(deprecated, "x-deprecationMessage", annotationDialectUri).join("\n") || "deprecated",
               severity: DiagnosticSeverity.Warning,
               tags: [DiagnosticTag.Deprecated]
             });
diff --git a/language-server/src/features/hover.js b/language-server/src/features/hover.js
@@ -1,6 +1,6 @@
 import { MarkupKind } from "vscode-languageserver";
 import * as SchemaDocument from "../schema-document.js";
-import * as JsonNode from "../json-node.js";
+import * as SchemaNode from "../schema-node.js";
 import { getSchemaDocument } from "./schema-registry.js";
 
 
@@ -22,11 +22,11 @@ export default {
 
       // This is a little wierd because we want the hover to be on the keyword, but
       // the annotation is actually on the value not the keyword.
-      if (keyword.parent && JsonNode.typeOf(keyword.parent) === "property" && keyword.parent.children[0] === keyword) {
+      if (keyword.parent && SchemaNode.typeOf(keyword.parent) === "property" && keyword.parent.children[0] === keyword) {
         return {
           contents: {
             kind: MarkupKind.Markdown,
-            value: JsonNode.annotation(keyword.parent.children[1], "description", annotationDialectUri).join("\n")
+            value: SchemaNode.annotation(keyword.parent.children[1], "description", annotationDialectUri).join("\n")
           },
           range: {
             start: document.positionAt(keyword.offset),
diff --git a/language-server/src/features/semantic-tokens.js b/language-server/src/features/semantic-tokens.js
@@ -1,6 +1,6 @@
 import { SemanticTokensBuilder } from "vscode-languageserver";
 import { getKeywordId } from "@hyperjump/json-schema/experimental";
-import * as JsonNode from "../json-node.js";
+import * as SchemaNode from "../schema-node.js";
 import { getSchemaDocument } from "./schema-registry.js";
 import { toAbsoluteUri } from "../util.js";
 import { isMatchedFile } from "./workspace.js";
@@ -127,22 +127,22 @@ const sortSemanticTokens = (semanticTokens, textDocument) => {
 };
 
 const getSemanticTokens = function* (schemaDocument) {
-  for (const { schemaResource, dialectUri } of schemaDocument.schemaResources) {
-    yield* schemaHandler(schemaResource, dialectUri);
+  for (const schemaResource of schemaDocument.schemaResources) {
+    yield* schemaHandler(schemaResource);
   }
 };
 
-const schemaHandler = function* (schemaResource, dialectUri) {
-  for (const [keyNode, valueNode] of JsonNode.entries(schemaResource)) {
-    const keywordName = JsonNode.value(keyNode);
-    const keywordId = keywordIdFor(keywordName, dialectUri);
+const schemaHandler = function* (schemaResource) {
+  for (const [keyNode, valueNode] of SchemaNode.entries(schemaResource)) {
+    const keywordName = SchemaNode.value(keyNode);
+    const keywordId = keywordIdFor(keywordName, schemaResource.dialectUri);
 
     if (keywordId) {
       if (keywordId === "https://json-schema.org/keyword/comment") {
         yield { keywordInstance: keyNode.parent, tokenType: "comment" };
       } else if (toAbsoluteUri(keywordId) !== "https://json-schema.org/keyword/unknown") {
         yield { keywordInstance: keyNode, tokenType: "keyword" };
-        yield* getKeywordHandler(keywordId)(valueNode, dialectUri);
+        yield* getKeywordHandler(keywordId)(valueNode);
       }
     }
   }
@@ -158,15 +158,15 @@ const keywordIdFor = (keywordName, dialectUri) => {
   }
 };
 
-const schemaMapHandler = function* (schemaResource, dialectUri) {
-  for (const schemaNode of JsonNode.values(schemaResource)) {
-    yield* schemaHandler(schemaNode, dialectUri);
+const schemaMapHandler = function* (schemaResource) {
+  for (const schemaNode of SchemaNode.values(schemaResource)) {
+    yield* schemaHandler(schemaNode);
   }
 };
 
-const schemaArrayHandler = function* (schemaResource, dialectUri) {
-  for (const schemaNode of JsonNode.iter(schemaResource)) {
-    yield* schemaHandler(schemaNode, dialectUri);
+const schemaArrayHandler = function* (schemaResource) {
+  for (const schemaNode of SchemaNode.iter(schemaResource)) {
+    yield* schemaHandler(schemaNode);
   }
 };
 
diff --git a/language-server/src/schema-document.js b/language-server/src/schema-document.js
@@ -2,7 +2,7 @@ import { getSchema, compile, interpret, getKeywordName, hasDialect, BASIC } from
 import * as JsonPointer from "@hyperjump/json-pointer";
 import { resolveIri, toAbsoluteIri } from "@hyperjump/uri";
 import { getNodeValue, parseTree } from "jsonc-parser";
-import * as JsonNode from "./json-node.js";
+import * as SchemaNode from "./schema-node.js";
 import { uriFragment } from "./util.js";
 
 
@@ -27,16 +27,16 @@ export const fromTextDocument = async (textDocument, contextDialectUri) => {
 
     buildSchemaResources(document, root, textDocument.uri, contextDialectUri);
 
-    for (const { dialectUri, schemaResource } of document.schemaResources) {
-      if (!hasDialect(dialectUri)) {
-        const $schema = JsonNode.get("#/$schema", schemaResource);
-        if ($schema && JsonNode.typeOf($schema) === "string") {
+    for (const schemaResource of document.schemaResources) {
+      if (!hasDialect(schemaResource.dialectUri)) {
+        const $schema = SchemaNode.get("#/$schema", schemaResource);
+        if ($schema && SchemaNode.typeOf($schema) === "string") {
           document.errors.push({
             keyword: "https://json-schema.org/keyword/schema",
             instanceNode: $schema,
             message: "Unknown dialect"
           });
-        } else if (dialectUri) {
+        } else if (schemaResource.dialectUri) {
           document.errors.push({
             keyword: "https://json-schema.org/keyword/schema",
             instanceNode: schemaResource,
@@ -53,15 +53,15 @@ export const fromTextDocument = async (textDocument, contextDialectUri) => {
         continue;
       }
 
-      const schema = await getSchema(dialectUri);
+      const schema = await getSchema(schemaResource.dialectUri);
       const compiled = await compile(schema);
       const output = interpret(compiled, schemaResource, BASIC);
       if (!output.valid) {
         for (const error of output.errors) {
           document.errors.push({
             keyword: error.keyword,
             keywordNode: await getSchema(error.absoluteKeywordLocation),
-            instanceNode: JsonNode.get(error.instanceLocation, schemaResource)
+            instanceNode: SchemaNode.get(error.instanceLocation, schemaResource)
           });
         }
       }
@@ -72,13 +72,13 @@ export const fromTextDocument = async (textDocument, contextDialectUri) => {
 };
 
 const buildSchemaResources = (document, node, uri = "", dialectUri = "", pointer = "", parent = undefined, anchors = {}) => {
-  const jsonNode = JsonNode.cons(uri, pointer, getNodeValue(node), node.type, [], parent, node.offset, node.length);
+  const schemaNode = SchemaNode.cons(uri, pointer, getNodeValue(node), node.type, [], parent, node.offset, node.length, dialectUri, anchors);
 
   switch (node.type) {
     case "array":
-      jsonNode.children = node.children.map((child, index) => {
+      schemaNode.children = node.children.map((child, index) => {
         const itemPointer = JsonPointer.append(index, pointer);
-        return buildSchemaResources(document, child, uri, dialectUri, itemPointer, jsonNode, anchors);
+        return buildSchemaResources(document, child, uri, dialectUri, itemPointer, schemaNode, anchors);
       });
       break;
 
@@ -89,6 +89,7 @@ const buildSchemaResources = (document, node, uri = "", dialectUri = "", pointer
         if ($schema?.type === "string") {
           try {
             dialectUri = toAbsoluteIri(getNodeValue($schema));
+            schemaNode.dialectUri = dialectUri;
           } catch (error) {
             // Ignore
           }
@@ -98,7 +99,7 @@ const buildSchemaResources = (document, node, uri = "", dialectUri = "", pointer
         const $idNode = idToken && nodeStep(node, idToken);
         if ($idNode) {
           uri = toAbsoluteIri(resolveIri(getNodeValue($idNode), uri));
-          jsonNode.baseUri = uri;
+          schemaNode.baseUri = uri;
         }
 
         const legacyIdToken = keywordNameFor("https://json-schema.org/keyword/draft-04/id", dialectUri);
@@ -107,7 +108,7 @@ const buildSchemaResources = (document, node, uri = "", dialectUri = "", pointer
           const legacy$id = getNodeValue(legacy$idNode);
           if (legacy$id[0] !== "#") {
             uri = toAbsoluteIri(resolveIri(legacy$id, uri));
-            jsonNode.baseUri = uri;
+            schemaNode.baseUri = uri;
           }
         }
       } else {
@@ -116,7 +117,7 @@ const buildSchemaResources = (document, node, uri = "", dialectUri = "", pointer
         if (embeddedDialectUri) {
           buildSchemaResources(document, node, uri, embeddedDialectUri);
 
-          return JsonNode.cons(uri, pointer, true, "boolean", [], parent, node.offset, node.length);
+          return SchemaNode.cons(uri, pointer, true, "boolean", [], parent, node.offset, node.length, dialectUri, anchors);
         }
       }
 
@@ -138,10 +139,10 @@ const buildSchemaResources = (document, node, uri = "", dialectUri = "", pointer
 
       for (const child of node.children) {
         const propertyPointer = JsonPointer.append(getNodeValue(child.children[0]), pointer);
-        const propertyNode = buildSchemaResources(document, child, uri, dialectUri, propertyPointer, jsonNode, anchors);
+        const propertyNode = buildSchemaResources(document, child, uri, dialectUri, propertyPointer, schemaNode, anchors);
 
         if (propertyNode) {
-          jsonNode.children.push(propertyNode);
+          schemaNode.children.push(propertyNode);
         }
       }
       break;
@@ -151,22 +152,17 @@ const buildSchemaResources = (document, node, uri = "", dialectUri = "", pointer
         return;
       }
 
-      jsonNode.children = node.children.map((child) => {
-        return buildSchemaResources(document, child, uri, dialectUri, pointer, jsonNode, anchors);
+      schemaNode.children = node.children.map((child) => {
+        return buildSchemaResources(document, child, uri, dialectUri, pointer, schemaNode, anchors);
       });
       break;
   }
 
-  if (jsonNode.pointer === "") {
-    document.schemaResources.push({
-      schemaResource: jsonNode,
-      dialectUri: dialectUri,
-      baseUri: uri,
-      anchors: anchors
-    });
+  if (schemaNode.pointer === "") {
+    document.schemaResources.push(schemaNode);
   }
 
-  return jsonNode;
+  return schemaNode;
 };
 
 const getEmbeddedDialectUri = (node, dialectUri) => {
@@ -194,7 +190,7 @@ const getEmbeddedDialectUri = (node, dialectUri) => {
 };
 
 export const findNodeAtOffset = (document, offset) => {
-  for (const { schemaResource } of document.schemaResources) {
+  for (const schemaResource of document.schemaResources) {
     const node = _findNodeAtOffset(schemaResource, offset);
     if (node) {
       return node;
diff --git a/language-server/src/schema-node.js b/language-server/src/schema-node.js
@@ -0,0 +1,14 @@
+import * as JsonNode from "./json-node.js";
+
+
+// eslint-disable-next-line import/export
+export const cons = (uri, pointer, value, type, children, parent, offset, textLength, dialectUri, anchors) => {
+  const node = JsonNode.cons(uri, pointer, value, type, children, parent, offset, textLength);
+  node.dialectUri = dialectUri;
+  node.anchors = anchors;
+
+  return node;
+};
+
+// eslint-disable-next-line import/export
+export * from "./json-node.js";
