Update to latest vscode-json-languageservice

The primary motivation for doing this is to allow warnings to be
reported on schemas.
I would like to report warnings on schemas as a part of
#1065.

When updating the json language service,
there were many API changes that I needed to adapt to,
and some tests that I changed.

Notably, I needed to copy a lot of the implementation of
`JSONSchemaService` into our subclass of `JSONSchemaService`.
`JSONSchemaService` turns all schema identifiers into URIs and escapes all
`/` in the fragment,
and does this in the private `normalizeId` method that we can't override
Combined, these behaviours cause many tests to fail.

Closes #1069

Signed-off-by: David Thompson <[email protected]>

Author: datho7561

package.json

@@ -30,7 +30,7 @@
     "lodash": "4.17.21",
     "prettier": "^3.5.0",
     "request-light": "^0.5.7",
-    "vscode-json-languageservice": "4.1.8",
+    "vscode-json-languageservice": "5.5.0",
     "vscode-languageserver": "^9.0.0",
     "vscode-languageserver-textdocument": "^1.0.1",
     "vscode-languageserver-types": "^3.16.0",

src/languageservice/services/yamlSchemaService.ts

@@ -12,7 +12,6 @@ import {
   JSONSchemaService,
   SchemaDependencies,
   ISchemaContributions,
-  SchemaHandle,
 } from 'vscode-json-languageservice/lib/umd/services/jsonSchemaService';
 
 import { URI } from 'vscode-uri';
@@ -29,6 +28,7 @@ import { SchemaVersions } from '../yamlTypes';
 
 import Ajv, { DefinedError } from 'ajv';
 import { getSchemaTitle } from '../utils/schemaUtils';
+import { SchemaConfiguration } from 'vscode-json-languageservice';
 
 const ajv = new Ajv();
 
@@ -155,11 +155,9 @@ export class YAMLSchemaService extends JSONSchemaService {
     return result;
   }
 
-  async resolveSchemaContent(
-    schemaToResolve: UnresolvedSchema,
-    schemaURL: string,
-    dependencies: SchemaDependencies
-  ): Promise<ResolvedSchema> {
+  async resolveSchemaContent(schemaToResolve: UnresolvedSchema, schemaHandle: SchemaHandle): Promise<ResolvedSchema> {
+    const schemaURL: string = normalizeId(schemaHandle.uri);
+    const dependencies: SchemaDependencies = schemaHandle.dependencies;
     const resolveErrors: string[] = schemaToResolve.errors.slice(0);
     let schema: JSONSchema = schemaToResolve.schema;
     const contextService = this.contextService;
@@ -374,7 +372,7 @@ export class YAMLSchemaService extends JSONSchemaService {
       const schemaHandle = super.createCombinedSchema(resource, schemas);
       return schemaHandle.getResolvedSchema().then((schema) => {
         if (schema.schema && typeof schema.schema === 'object') {
-          schema.schema.url = schemaHandle.url;
+          schema.schema.url = schemaHandle.uri;
         }
 
         if (
@@ -431,6 +429,7 @@ export class YAMLSchemaService extends JSONSchemaService {
               (schemas) => {
                 return {
                   errors: [],
+                  warnings: [],
                   schema: {
                     allOf: schemas.map((schemaObj) => {
                       return schemaObj.schema;
@@ -503,7 +502,7 @@ export class YAMLSchemaService extends JSONSchemaService {
 
   private async resolveCustomSchema(schemaUri, doc): ResolvedSchema {
     const unresolvedSchema = await this.loadSchema(schemaUri);
-    const schema = await this.resolveSchemaContent(unresolvedSchema, schemaUri, []);
+    const schema = await this.resolveSchemaContent(unresolvedSchema, new SchemaHandle(this, schemaUri));
     if (schema.schema && typeof schema.schema === 'object') {
       schema.schema.url = schemaUri;
     }
@@ -614,8 +613,18 @@ export class YAMLSchemaService extends JSONSchemaService {
 
   normalizeId(id: string): string {
     // The parent's `super.normalizeId(id)` isn't visible, so duplicated the code here
+    if (!id.includes(':')) {
+      return id;
+    }
     try {
-      return URI.parse(id).toString();
+      const uri = URI.parse(id);
+      if (!id.includes('#')) {
+        return uri.toString();
+      }
+      // fragment should be verbatim, but vscode-uri converts `/` to the escaped version (annoyingly, needlessly)
+      const [first, second] = uri.toString().split('#', 2);
+      const secondCleaned = second.replace('%2F', '/');
+      return first + '#' + secondCleaned;
     } catch (e) {
       return id;
     }
@@ -684,25 +693,44 @@ export class YAMLSchemaService extends JSONSchemaService {
   }
 
   registerExternalSchema(
-    uri: string,
-    filePatterns?: string[],
-    unresolvedSchema?: JSONSchema,
+    schemaConfig: SchemaConfiguration,
     name?: string,
     description?: string,
     versions?: SchemaVersions
   ): SchemaHandle {
     if (name || description) {
-      this.schemaUriToNameAndDescription.set(uri, { name, description, versions });
+      this.schemaUriToNameAndDescription.set(schemaConfig.uri, { name, description, versions });
     }
-    return super.registerExternalSchema(uri, filePatterns, unresolvedSchema);
+    this.registeredSchemasIds[schemaConfig.uri] = true;
+    this.cachedSchemaForResource = undefined;
+    if (schemaConfig.fileMatch && schemaConfig.fileMatch.length) {
+      this.addFilePatternAssociation(schemaConfig.fileMatch, schemaConfig.folderUri, [schemaConfig.uri]);
+    }
+    return schemaConfig.schema
+      ? this.addSchemaHandle(schemaConfig.uri, schemaConfig.schema)
+      : this.getOrAddSchemaHandle(schemaConfig.uri);
   }
 
   clearExternalSchemas(): void {
     super.clearExternalSchemas();
   }
 
   setSchemaContributions(schemaContributions: ISchemaContributions): void {
-    super.setSchemaContributions(schemaContributions);
+    if (schemaContributions.schemas) {
+      const schemas = schemaContributions.schemas;
+      for (const id in schemas) {
+        const normalizedId = normalizeId(id);
+        this.contributionSchemas[normalizedId] = this.addSchemaHandle(normalizedId, schemas[id]);
+      }
+    }
+    if (Array.isArray(schemaContributions.schemaAssociations)) {
+      const schemaAssociations = schemaContributions.schemaAssociations;
+      for (const schemaAssociation of schemaAssociations) {
+        const uris = schemaAssociation.uris.map(normalizeId);
+        const association = this.addFilePatternAssociation(schemaAssociation.pattern, schemaAssociation.folderUri, uris);
+        this.contributionAssociations.push(association);
+      }
+    }
   }
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -711,14 +739,62 @@ export class YAMLSchemaService extends JSONSchemaService {
   }
 
   getResolvedSchema(schemaId: string): Promise<ResolvedSchema> {
-    return super.getResolvedSchema(schemaId);
+    const id = normalizeId(schemaId);
+    const schemaHandle = this.schemasById[id];
+    if (schemaHandle) {
+      return schemaHandle.getResolvedSchema();
+    }
+    return this.promise.resolve(undefined);
   }
 
   onResourceChange(uri: string): boolean {
-    return super.onResourceChange(uri);
+    // always clear this local cache when a resource changes
+    this.cachedSchemaForResource = undefined;
+    let hasChanges = false;
+    uri = normalizeId(uri);
+    const toWalk = [uri];
+    const all = Object.keys(this.schemasById).map((key) => this.schemasById[key]);
+    while (toWalk.length) {
+      const curr = toWalk.pop();
+      for (let i = 0; i < all.length; i++) {
+        const handle = all[i];
+        if (handle && (handle.uri === curr || handle.dependencies.has(curr))) {
+          if (handle.uri !== curr) {
+            toWalk.push(handle.uri);
+          }
+          if (handle.clearSchema()) {
+            hasChanges = true;
+          }
+          all[i] = undefined;
+        }
+      }
+    }
+    return hasChanges;
   }
 }
 
+/**
+ * Our version of normalize id, which doesn't prepend `file:///` to anything without a scheme.
+ *
+ * @param id the id to normalize
+ * @returns the normalized id.
+ */
+function normalizeId(id: string): string {
+  if (id.includes(':')) {
+    try {
+      if (id.includes('#')) {
+        const [mostOfIt, fragment] = id.split('#', 2);
+        return URI.parse(mostOfIt) + '#' + fragment;
+      } else {
+        return URI.parse(id).toString();
+      }
+    } catch {
+      return id;
+    }
+  }
+  return id;
+}
+
 function toDisplayString(url: string): string {
   try {
     const uri = URI.parse(url);
@@ -730,3 +806,47 @@ function toDisplayString(url: string): string {
   }
   return url;
 }
+
+class SchemaHandle {
+  public readonly uri: string;
+  public readonly dependencies: SchemaDependencies;
+  public anchors: Map<string, JSONSchema> | undefined;
+  private resolvedSchema: Promise<ResolvedSchema> | undefined;
+  private unresolvedSchema: Promise<UnresolvedSchema> | undefined;
+  private readonly service: JSONSchemaService;
+
+  constructor(service: JSONSchemaService, uri: string, unresolvedSchemaContent?: JSONSchema) {
+    this.service = service;
+    this.uri = uri;
+    this.dependencies = new Set();
+    this.anchors = undefined;
+    if (unresolvedSchemaContent) {
+      this.unresolvedSchema = this.service.promise.resolve(new UnresolvedSchema(unresolvedSchemaContent));
+    }
+  }
+
+  public getUnresolvedSchema(): Promise<UnresolvedSchema> {
+    if (!this.unresolvedSchema) {
+      this.unresolvedSchema = this.service.loadSchema(this.uri);
+    }
+    return this.unresolvedSchema;
+  }
+
+  public getResolvedSchema(): Promise<ResolvedSchema> {
+    if (!this.resolvedSchema) {
+      this.resolvedSchema = this.getUnresolvedSchema().then((unresolved) => {
+        return this.service.resolveSchemaContent(unresolved, this);
+      });
+    }
+    return this.resolvedSchema;
+  }
+
+  public clearSchema(): boolean {
+    const hasChanges = !!this.unresolvedSchema;
+    this.resolvedSchema = undefined;
+    this.unresolvedSchema = undefined;
+    this.dependencies.clear();
+    this.anchors = undefined;
+    return hasChanges;
+  }
+}

src/languageservice/yamlLanguageService.ts

@@ -212,9 +212,11 @@ export function getLanguageService(params: {
           const currPriority = settings.priority ? settings.priority : 0;
           schemaService.addSchemaPriority(settings.uri, currPriority);
           schemaService.registerExternalSchema(
-            settings.uri,
-            settings.fileMatch,
-            settings.schema,
+            {
+              uri: settings.uri,
+              fileMatch: settings.fileMatch,
+              schema: settings.schema,
+            },
             settings.name,
             settings.description,
             settings.versions

test/jsonParser.test.ts

@@ -1421,6 +1421,7 @@ describe('JSON Parser', () => {
 
   it('items as array', function () {
     const schema: JsonSchema.JSONSchema = {
+      $schema: 'http://json-schema.org/draft-07/schema#',
       type: 'array',
       items: [
         {
@@ -1456,6 +1457,7 @@ describe('JSON Parser', () => {
 
   it('additionalItems', function () {
     let schema: JsonSchema.JSONSchema = {
+      $schema: 'http://json-schema.org/draft-07/schema#',
       type: 'array',
       items: [
         {
@@ -1483,6 +1485,7 @@ describe('JSON Parser', () => {
       assert.strictEqual(semanticErrors.length, 1);
     }
     schema = {
+      $schema: 'http://json-schema.org/draft-07/schema#',
       type: 'array',
       items: [
         {

test/schema.test.ts

@@ -337,7 +337,7 @@ describe('JSON Schema', () => {
       },
     };
 
-    service.registerExternalSchema(id, ['*.json'], schema);
+    service.registerExternalSchema({ uri: id, fileMatch: ['*.json'], schema });
 
     service
       .getSchemaForResource('test.json', undefined)
@@ -373,7 +373,7 @@ describe('JSON Schema', () => {
       },
     };
 
-    service.registerExternalSchema(id, ['*.json'], schema);
+    service.registerExternalSchema({ uri: id, fileMatch: ['*.json'], schema });
 
     const result = await service.getSchemaForResource('test.json', undefined);
 
@@ -419,11 +419,15 @@ describe('JSON Schema', () => {
   it('Schema with non uri registers correctly', function (testDone) {
     const service = new SchemaService.YAMLSchemaService(requestServiceMock, workspaceContext);
     const non_uri = 'non_uri';
-    service.registerExternalSchema(non_uri, ['*.yml', '*.yaml'], {
-      properties: {
-        test_node: {
-          description: 'my test_node description',
-          enum: ['test 1', 'test 2'],
+    service.registerExternalSchema({
+      uri: non_uri,
+      fileMatch: ['*.yml', '*.yaml'],
+      schema: {
+        properties: {
+          test_node: {
+            description: 'my test_node description',
+            enum: ['test 1', 'test 2'],
+          },
         },
       },
     });
@@ -529,7 +533,7 @@ describe('JSON Schema', () => {
 
   it('Modifying schema works with kubernetes resolution', async () => {
     const service = new SchemaService.YAMLSchemaService(schemaRequestServiceForURL, workspaceContext);
-    service.registerExternalSchema(KUBERNETES_SCHEMA_URL);
+    service.registerExternalSchema({ uri: KUBERNETES_SCHEMA_URL });
 
     await service.addContent({
       action: MODIFICATION_ACTIONS.add,
@@ -545,7 +549,7 @@ describe('JSON Schema', () => {
 
   it('Deleting schema works with Kubernetes resolution', async () => {
     const service = new SchemaService.YAMLSchemaService(schemaRequestServiceForURL, workspaceContext);
-    service.registerExternalSchema(KUBERNETES_SCHEMA_URL);
+    service.registerExternalSchema({ uri: KUBERNETES_SCHEMA_URL });
 
     await service.deleteContent({
       action: MODIFICATION_ACTIONS.delete,

test/schemaSelectionHandlers.test.ts

@@ -40,7 +40,11 @@ describe('Schema Selection Handlers', () => {
   });
 
   it('getAllSchemas should return all schemas', async () => {
-    service.registerExternalSchema('https://some.com/some.json', ['foo.yaml'], undefined, 'Schema name', 'Schema description');
+    service.registerExternalSchema(
+      { uri: 'https://some.com/some.json', fileMatch: ['foo.yaml'] },
+      'Schema name',
+      'Schema description'
+    );
     const settings = new SettingsState();
     const testTextDocument = setupSchemaIDTextDocument('');
     settings.documents = new TextDocumentTestManager();
@@ -61,7 +65,11 @@ describe('Schema Selection Handlers', () => {
   });
 
   it('getAllSchemas should return all schemas and mark used for current file', async () => {
-    service.registerExternalSchema('https://some.com/some.json', [SCHEMA_ID], undefined, 'Schema name', 'Schema description');
+    service.registerExternalSchema(
+      { uri: 'https://some.com/some.json', fileMatch: [SCHEMA_ID] },
+      'Schema name',
+      'Schema description'
+    );
     const settings = new SettingsState();
     const testTextDocument = setupSchemaIDTextDocument('');
     settings.documents = new TextDocumentTestManager();
@@ -82,7 +90,11 @@ describe('Schema Selection Handlers', () => {
   });
 
   it('getSchemas should return all schemas', async () => {
-    service.registerExternalSchema('https://some.com/some.json', [SCHEMA_ID], undefined, 'Schema name', 'Schema description');
+    service.registerExternalSchema(
+      { uri: 'https://some.com/some.json', fileMatch: [SCHEMA_ID] },
+      'Schema name',
+      'Schema description'
+    );
     const settings = new SettingsState();
     const testTextDocument = setupSchemaIDTextDocument('');
     settings.documents = new TextDocumentTestManager();

test/yamlSchemaService.test.ts

@@ -33,7 +33,8 @@ describe('YAML Schema Service', () => {
       const service = new SchemaService.YAMLSchemaService(requestServiceMock);
       service.getSchemaForResource('', yamlDock.documents[0]);
 
-      expect(requestServiceMock).calledOnceWith('http://json-schema.org/draft-07/schema#');
+      // vscode-json-languageserver converts the http to https for all json schema URIs
+      expect(requestServiceMock).calledOnceWith('https://json-schema.org/draft-07/schema#');
     });
 
     it('should handle inline schema https url', () => {