Fixes file paths

Author: diyaayay

language-server/package-lock.json

@@ -18,7 +18,8 @@
     "jsonc-parser": "^3.2.1",
     "merge-anything": "^6.0.2",
     "vscode-languageserver": "^9.0.0",
-    "vscode-languageserver-textdocument": "^1.0.8"
+    "vscode-languageserver-textdocument": "^1.0.8",
+    "vscode-uri": "^3.0.8"
   },
   "engines": {
     "node": ">=20.13.0"

language-server/package.json

@@ -1,7 +1,7 @@
 import { some } from "@hyperjump/pact";
 import * as SchemaDocument from "../schema-document.js";
 import * as SchemaNode from "../schema-node.js";
-import { getSchemaDocument } from "./schema-registry.js";
+import { getSchemaDocument, getSchemaDocumentBySchemaUri } from "./schema-registry.js";
 import { keywordNameFor } from "../util.js";
 
 /** @import { Feature } from "../build-server.js" */
@@ -25,13 +25,10 @@ export default {
       if (highlightBlockDialects.has(node.dialectUri)) {
         // Legacy reference
         const legacyRefToken = keywordNameFor("https://json-schema.org/keyword/draft-04/ref", node.dialectUri);
-        if (!node.parent) {
+        if (!node.parent || !node.parent.parent) {
           return false;
         }
 
-        if (!node.parent.parent) {
-          return false;
-        }
         const referenceNode = node.parent.parent;
         return some((keywordNode) => SchemaNode.value(keywordNode) === legacyRefToken, SchemaNode.keys(referenceNode));
       } else {
@@ -56,23 +53,27 @@ export default {
       const offset = document.offsetAt(position);
       const node = SchemaDocument.findNodeAtOffset(schemaDocument, offset);
 
-      if (!node) {
+      if (!node || !isReference(node)) {
         return [];
       }
 
-      if (!isReference(node)) {
-        return [];
-      }
       const reference = SchemaNode.value(node);
       const targetSchema = SchemaNode.get(reference, node);
+
       if (!targetSchema) {
         return [];
       }
+
+      const targetSchemaDocument = getSchemaDocumentBySchemaUri(targetSchema.baseUri);
+      if (!targetSchemaDocument) {
+        return [];
+      }
+
       const gotoDefinitions = [{
-        uri: schemaDocument.textDocument.uri,
+        uri: targetSchemaDocument.textDocument.uri,
         range: {
-          start: schemaDocument.textDocument.positionAt(targetSchema.offset),
-          end: schemaDocument.textDocument.positionAt(targetSchema.offset + targetSchema.textLength)
+          start: targetSchemaDocument.textDocument.positionAt(targetSchema.offset),
+          end: targetSchemaDocument.textDocument.positionAt(targetSchema.offset + targetSchema.textLength)
         }
       }];
 

language-server/src/features/definition.d.ts

@@ -70,4 +70,162 @@ describe("Feature - Goto Definition", () => {
       }
     }]);
   });
+
+  test("match one reference", async () => {
+    const documentUri = await client.openDocument("./subject.schema.json", `{
+  "$schema":"https://json-schema.org/draft/2020-12/schema",
+  "$ref": "#/$defs/names", 
+  "$defs":{
+    "names": {
+      
+    }
+  },
+}`);
+
+    const response = await client.sendRequest(DefinitionRequest.type, {
+      textDocument: { uri: documentUri },
+      position: {
+        line: 2,
+        character: 20
+      }
+    });
+
+    expect(response).to.eql([
+      {
+        "uri": documentUri,
+        "range": {
+          "start": { "line": 4, "character": 13 },
+          "end": { "line": 6, "character": 5 }
+        }
+      }
+    ]);
+  });
+  test("match one definition", async () => {
+    const documentUri = await client.openDocument("./subject.schema.json", `{
+  "$schema":"https://json-schema.org/draft/2020-12/schema",
+  "$ref": "#/$defs/names", 
+  "$defs":{
+    "names": {
+      
+    }
+  },
+}`);
+
+    const response = await client.sendRequest(DefinitionRequest.type, {
+      textDocument: { uri: documentUri },
+      position: {
+        line: 2,
+        character: 18
+      }
+    });
+
+    expect(response).to.eql([
+      {
+        "uri": documentUri,
+        "range": {
+          "start": { "line": 4, "character": 13 },
+          "end": { "line": 6, "character": 5 }
+        }
+      }
+    ]);
+  });
+
+  test("cross file definition", async () => {
+    const documentUriA = await client.openDocument("./subjectA.schema.json", `{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "definitions": {
+    "person": {
+
+    }
+  }
+}
+`);
+    const documentUriB = await client.openDocument("./subjectB.schema.json", `{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$ref": "./subjectA.schema.json#/definitions/person"
+}
+`);
+
+    const response = await client.sendRequest(DefinitionRequest.type, {
+      textDocument: { uri: documentUriB },
+      position: {
+        line: 2,
+        character: 20
+      }
+    });
+
+    expect(response).to.eql([
+      {
+        "uri": documentUriA,
+        "range": {
+          "start": { "line": 3, "character": 14 },
+          "end": { "line": 5, "character": 5 }
+        }
+      }
+    ]);
+  });
+
+  test("match self identified externally", async () => {
+    const documentUri = await client.openDocument("./subject.schema.json", `{
+  "$schema":"http://json-schema.org/draft-07/schema#",
+  "$ref": "https://example.com/schemas/two#/definitions/names", 
+}`);
+
+    const documentUriB = await client.openDocument("./subjectB.schema.json", `{
+  "$schema":"http://json-schema.org/draft-07/schema#", 
+  "$id": "https://example.com/schemas/two", 
+  "definitions":{
+    "names": {
+      
+    }
+  }
+}`);
+
+    const response = await client.sendRequest(DefinitionRequest.type, {
+      textDocument: { uri: documentUri },
+      position: {
+        line: 2,
+        character: 37
+      }
+    });
+
+    expect(response).to.eql([
+      {
+        "uri": documentUriB,
+        "range": {
+          "start": { "line": 4, "character": 13 },
+          "end": { "line": 6, "character": 5 }
+        }
+      }
+    ]);
+  });
+
+  test("match self identified internally", async () => {
+    const documentUri = await client.openDocument("./subject.schema.json", `{
+  "$schema":"http://json-schema.org/draft-07/schema#",
+  "$id": "https://example.com/person.json",
+  "type": "object",
+  "properties": {
+    "names": { "$ref": "https://example.com/person.json" }
+   }  
+}`);
+
+    const response = await client.sendRequest(DefinitionRequest.type, {
+      textDocument: { uri: documentUri },
+      position: {
+        line: 5,
+        character: 30
+      }
+    });
+
+    expect(response).to.eql([
+      {
+        "uri": documentUri,
+        "range": {
+          "start": { "line": 0, "character": 0 },
+          "end": { "line": 7, "character": 1 }
+        }
+      }
+    ]);
+  });
 });

language-server/src/features/definition.js

@@ -62,6 +62,7 @@ export default {
           }
         }
       }
+
       return schemaReferences;
     });
   },

language-server/src/features/definition.test.ts

@@ -45,7 +45,9 @@ export const getSchemaDocument = async (connection, textDocument) => {
   return schemaDocument;
 };
 
-export const clearSchemaDocuments = () => schemaDocuments.clear();
+export const clearSchemaDocuments = () => {
+  schemaDocuments.clear();
+};
 
 export const allSchemaDocuments = function* () {
   for (const { schemaDocument } of schemaDocuments.values()) {
@@ -63,3 +65,14 @@ export const getSchemaResource = (schemaUri) => {
     }
   }
 };
+
+/** @type (schemaUri: string) => SchemaDocumentType | undefined */
+export const getSchemaDocumentBySchemaUri = (schemaUri) => {
+  for (const schemaDocument of allSchemaDocuments()) {
+    for (const schemaResource of schemaDocument.schemaResources) {
+      if (schemaResource.baseUri === schemaUri) {
+        return schemaDocument;
+      }
+    }
+  }
+};

language-server/src/features/references.js

@@ -8,10 +8,10 @@ import {
 } from "vscode-languageserver";
 import { utimes } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
-import { resolveIri } from "@hyperjump/uri";
 import workspace from "./workspace.js";
 import documentSettings from "./document-settings.js";
 import schemaRegistry from "./schema-registry.js";
+import { resolveIri } from "../util.js";
 
 import type { DocumentSettings } from "./document-settings.js";
 

language-server/src/features/schema-registry.js

@@ -1,7 +1,7 @@
 import { watch } from "node:fs";
 import { readdir, readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import {
   DiagnosticSeverity,
   DidChangeWatchedFilesNotification,
@@ -10,6 +10,7 @@ import {
   TextDocumentSyncKind
 } from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
+import { URI } from "vscode-uri";
 import { publishAsync, subscribe, unsubscribe } from "../pubsub.js";
 import { allSchemaDocuments, getSchemaDocument } from "./schema-registry.js";
 import { getDocumentSettings } from "./document-settings.js";
@@ -260,7 +261,7 @@ const workspaceSchemas = async function* (schemaFilePatterns) {
       if (isMatchedFile(filename, schemaFilePatterns)) {
         const schemaPath = resolve(path, filename);
 
-        yield pathToFileURL(schemaPath).toString();
+        yield URI.file(schemaPath).toString();
       }
     }
   }

language-server/src/features/workspace-neovim.test.ts

@@ -7,11 +7,11 @@ import {
   WorkDoneProgress,
   WorkDoneProgressCreateRequest
 } from "vscode-languageserver";
-import { resolveIri } from "@hyperjump/uri";
 import documentSettings from "./document-settings.js";
 import semanticTokens from "./semantic-tokens.js";
 import schemaRegistry from "./schema-registry.js";
 import workspace from "./workspace.js";
+import { resolveIri } from "../util.js";
 
 import type { DocumentSettings } from "./document-settings.js";