feat: validate local and external references

language-server/src/documents.js

@@ -0,0 +1,38 @@
+import { readFile } from "fs/promises";
+import { fileURLToPath } from "url";
+import { TextDocument } from "vscode-languageserver-textdocument";
+
+/**
+ * documentStore for inactive documents
+ *
+ * `uri` => `TextDocument`
+ * @type {Map<string, TextDocument}
+ */
+const inactiveDocumentStore = new Map();
+
+/**
+ * @param {import("vscode-languageserver").TextDocuments<TextDocument>} documents
+ * @param {string} uri
+ * @returns {Promise<TextDocument>}
+ */
+export const fetchDocument = async (documents, uri) => {
+  if (inactiveDocumentStore.has(uri)) {
+    return inactiveDocumentStore.get(uri);
+  }
+
+  let textDocument = documents.get(uri);
+
+  if (!textDocument) {
+    const instanceJson = await readFile(fileURLToPath(uri), "utf8");
+    textDocument = TextDocument.create(uri, "json", -1, instanceJson);
+    inactiveDocumentStore.set(uri, textDocument);
+  }
+  return textDocument;
+};
+
+/**
+ * @param {string} uri
+ */
+export const deleteFromInactiveDocumentStore = (uri) => {
+  return inactiveDocumentStore.delete(uri);
+};

language-server/src/identifiers.js

@@ -0,0 +1,63 @@
+import { keywordNameFor } from "./json-schema.js";
+
+/**
+ * `$id` -> `document uri`
+ * @type {Map<string, string>}
+ */
+const identifiers = new Map();
+
+/**
+ * `uri` -> `$id -> instance`
+ * @type {Map<string, Map<string, import("./jsonc-instance").JsoncInstance>}
+ */
+const embeddedSchemaIdentifiers = new Map();
+
+export const deleteIdentifiersForDocument = (uri) => {
+  embeddedSchemaIdentifiers.delete(uri);
+  identifiers.forEach((docUri) => {
+    if (docUri === uri) {
+      identifiers.delete(docUri);
+      return;
+    }
+  });
+};
+
+/**
+ * @param {import("./jsonc-instance").JsoncInstance} instance
+ * @param {string} dialectUri
+ */
+export const addIdentifierForInstance = (instance, dialectUri) => {
+  const idKeywordUri = "https://json-schema.org/keyword/id";
+  const $id = instance.get(`#/${keywordNameFor(idKeywordUri, dialectUri)}`).node?.value;
+
+  const { textDocument, node } = instance;
+
+  if (node && node.offset !== 0) {
+    if (!embeddedSchemaIdentifiers.has(textDocument.uri)) {
+      embeddedSchemaIdentifiers.set(textDocument.uri, new Map());
+    }
+    embeddedSchemaIdentifiers.get(textDocument.uri).set($id, instance);
+    return;
+  }
+
+  if ($id) {
+    identifiers.set($id, textDocument.uri);
+  } else {
+    identifiers.set(textDocument.uri, textDocument.uri);
+  }
+};
+
+/**
+ * @param {string} $id
+ */
+export const getIdentifier = ($id) => {
+  return identifiers.get($id);
+};
+
+/**
+ * @param {string} uri
+ * @param {string} $id
+ */
+export const getEmbeddedIdentifer = (uri, $id) => {
+  return embeddedSchemaIdentifiers.get(uri)?.get($id);
+};

language-server/src/json-schema.js

@@ -63,7 +63,13 @@ const getEmbeddedDialectUri = (schemaInstance, contextDialectUri) => {
   }
 };
 
-const keywordNameFor = (keywordUri, dialectUri) => {
+/**
+ *
+ * @param {string} keywordUri
+ * @param {string} dialectUri
+ * @returns {string | undefined}
+ */
+export const keywordNameFor = (keywordUri, dialectUri) => {
   try {
     return getKeywordName(dialectUri, keywordUri);
   } catch (error) {

language-server/src/jsonc-instance.js

@@ -6,6 +6,13 @@ import { toAbsoluteUri, uriFragment } from "./util.js";
 
 
 export class JsoncInstance {
+  /**
+   * @param {import("vscode-languageserver-textdocument").TextDocument} textDocument
+   * @param {import("jsonc-parser").Node | undefined} root
+   * @param {import("jsonc-parser").Node | undefined} node
+   * @param {string} pointer
+   * @param {*} annotations
+   */
   constructor(textDocument, root, node, pointer, annotations) {
     this.textDocument = textDocument;
     this.root = root;
@@ -14,6 +21,10 @@ export class JsoncInstance {
     this.annotations = annotations;
   }
 
+  /**
+   * @param {import("vscode-languageserver-textdocument").TextDocument} textDocument
+   * @returns {JsoncInstance}
+   */
   static fromTextDocument(textDocument) {
     const json = textDocument.getText();
     const root = parseTree(json, [], {

language-server/src/references.js

@@ -0,0 +1,174 @@
+import { fetchDocument } from "./documents.js";
+import { getEmbeddedIdentifer, getIdentifier } from "./identifiers.js";
+import { keywordNameFor } from "./json-schema.js";
+import { JsoncInstance } from "./jsonc-instance.js";
+import { getSemanticTokens } from "./semantic-tokens.js";
+import { getSchemaResources, workspaceUri } from "./server.js";
+import { isAbsoluteUrl, isAnchor } from "./util.js";
+import { dirname, join } from "node:path";
+import { pathToFileURL, resolve } from "node:url";
+
+/**
+ * `documentUri` -> `ref -> instance`
+ * @type {Map<string, Map<string, import("./jsonc-instance.js").JsoncInstance>}
+ */
+export const references = new Map();
+
+/**
+ * @param {string} uri
+ */
+export const getReferenceForDocument = (uri) => {
+  return references.get(uri);
+};
+
+export const deleteReferencesForDocument = (uri) => {
+  references.delete(uri);
+};
+
+/**
+ * @param {import("./jsonc-instance.js").JsoncInstance} keywordInstance
+ * @param {string} dialectUri
+ */
+export const addReference = (keywordInstance, dialectUri) => {
+  const referenceKeywordIds = [
+    "https://json-schema.org/keyword/ref",
+    "https://json-schema.org/keyword/draft-04/ref"
+  ];
+  const referenceKeywordNames = referenceKeywordIds.map((keywordId) => keywordNameFor(keywordId, dialectUri));
+  if (!referenceKeywordNames.includes(keywordInstance.value()) || keywordInstance?.node?.parent?.children?.length < 2) {
+    return;
+  }
+  const { pointer, textDocument, node } = keywordInstance;
+
+  const valueInstance = keywordInstance._fromNode(node.parent.children[1], keywordInstance.pointer);
+  if (typeof valueInstance.value() !== "string") {
+    return;
+  }
+
+  if (!references.has(textDocument.uri)) {
+    references.set(textDocument.uri, new Map());
+  }
+  references.get(textDocument.uri).set(pointer, valueInstance);
+};
+
+/**
+ * @param {import("vscode-languageserver").TextDocuments} documents
+ * @param {import("vscode-languageserver-textdocument").TextDocument} textDocument
+ * @param {string} ref
+ */
+export const validateReference = async (documents, textDocument, ref) => {
+  const referenceData = await getReferenceData(documents, textDocument.uri, getReferenceForDocument(textDocument.uri).get(ref).value());
+  if (typeof referenceData === "boolean") {
+    return referenceData;
+  }
+  const { jsonInstance, anchorFragment, localJsonPointer } = referenceData;
+  if (anchorFragment && (
+    !isAnchor(anchorFragment) || !await searchAnchorFragment(jsonInstance.textDocument, anchorFragment)
+  )
+  ) {
+    return false;
+  }
+  if (localJsonPointer && jsonInstance.get(localJsonPointer).value() === undefined) {
+    return false;
+  }
+  return true;
+};
+
+/**
+ * @param {import("vscode-languageserver").TextDocuments} documents
+ * @param {string} uri
+ * @param {string} ref
+ * @returns {Promise<boolean | {
+ * jsonInstance: JsoncInstance;
+ * anchorFragment?: string;
+ * localJsonPointer?: string;
+ * }>}
+ */
+const getReferenceData = async (documents, uri, ref) => {
+  const [$id, fragment] = ref.startsWith("#") ? ref.slice(1).split("#") : ref.split("#");
+  const embeddedSchema = getEmbeddedIdentifer(uri, $id);
+
+  if (ref.startsWith("#")) {
+    const textDocument = await fetchDocument(documents, uri);
+    const jsonInstance = JsoncInstance.fromTextDocument(textDocument);
+    return extractPointers($id, jsonInstance);
+  }
+  if (embeddedSchema) {
+    if (!fragment) {
+      return true;
+    }
+    const jsonInstance = embeddedSchema;
+    return extractPointers(fragment, jsonInstance);
+  }
+  if (!workspaceUri) {
+    return false;
+  }
+  if (isAbsoluteUrl($id)) {
+    const documentUri = getIdentifier($id);
+    if (!documentUri) {
+      return false;
+    }
+    if (!fragment) {
+      return true;
+    }
+    const textDocument = await fetchDocument(documents, documentUri);
+    const jsonInstance = JsoncInstance.fromTextDocument(textDocument);
+    return extractPointers(fragment, jsonInstance);
+  }
+
+
+  const currDocument = await fetchDocument(documents, uri);
+  const schemaResources = await getSchemaResources(currDocument);
+  const { dialectUri } = schemaResources[0];
+  const idKeywordName = keywordNameFor("https://json-schema.org/keyword/id", dialectUri);
+  const jsonInstance = JsoncInstance.fromTextDocument(currDocument);
+
+  let fullReferenceUri;
+  const baseUri = jsonInstance.get(`#/${idKeywordName}`).value();
+  if (baseUri !== undefined) {
+    fullReferenceUri = resolve(baseUri, $id);
+  } else {
+    fullReferenceUri = pathToFileURL(join(dirname(uri), $id)).toString();
+  }
+  const referenceDocumentUri = getIdentifier(fullReferenceUri);
+  if (!referenceDocumentUri) {
+    return false;
+  }
+  const referenceDocument = await fetchDocument(documents, referenceDocumentUri);
+  const referenceInstance = JsoncInstance.fromTextDocument(referenceDocument);
+  if (!fragment) {
+    return true;
+  }
+  return extractPointers(fragment, referenceInstance);
+};
+
+const extractPointers = (fragment, jsonInstance) => {
+  if (!fragment.startsWith("/")) {
+    const anchorFragment = fragment;
+    return { jsonInstance, anchorFragment };
+  } else {
+    const localJsonPointer = `#${fragment}`;
+    return { jsonInstance, localJsonPointer };
+  }
+};
+
+/**
+ *
+ * @param {TextDocument} textDocument
+ * @param {string} anchorValue
+ */
+const searchAnchorFragment = async (textDocument, anchorValue) => {
+  const schemaResources = await getSchemaResources(textDocument);
+  for (const { dialectUri } of schemaResources) {
+    const anchorKeywordName = keywordNameFor("https://json-schema.org/keyword/anchor", dialectUri);
+    for (const { keywordInstance } of getSemanticTokens(schemaResources)) {
+      if (keywordInstance.value() === anchorKeywordName) {
+        const valueInstance = keywordInstance._fromNode(keywordInstance.node.parent.children[1], keywordInstance.pointer);
+        if (valueInstance.value() === anchorValue && typeof valueInstance.value() === "string") {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};