feat: Add comprehensive test support for JSON Schema 2019-09 and 2020-12

Author: damioune123

README.md

@@ -2,7 +2,7 @@
 
 # YAML Language Server
 
-Supports JSON Schema 7 and below.
+Supports JSON Schema draft-04, draft-07, 2019-09, and 2020-12.
 Starting from `1.0.0` the language server uses [eemeli/yaml](https://github.com/eemeli/yaml) as the new YAML parser, which strictly enforces the specified YAML spec version. Default YAML spec version is `1.2`, it can be changed with `yaml.yamlVersion` setting.
 
 ## Features

src/languageservice/services/yamlSchemaService.ts

@@ -29,6 +29,12 @@ import { parse } from 'yaml';
 import * as Json from 'jsonc-parser';
 import { getSchemaTitle } from '../utils/schemaUtils';
 
+import * as Draft04 from '@hyperjump/json-schema/draft-04';
+import * as Draft07 from '@hyperjump/json-schema/draft-07';
+import * as Draft201909 from '@hyperjump/json-schema/draft-2019-09';
+import * as Draft202012 from '@hyperjump/json-schema/draft-2020-12';
+
+type SupportedSchemaVersions = '2020-12' | '2019-09' | 'draft-07' | 'draft-04';
 export declare type CustomSchemaProvider = (uri: string) => Promise<string | string[]>;
 
 export enum MODIFICATION_ACTIONS {
@@ -90,7 +96,6 @@ interface SchemaStoreSchema {
   versions?: SchemaVersions;
 }
 export class YAMLSchemaService extends JSONSchemaService {
-  // To allow to use schemasById from super.
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   [x: string]: any;
 
@@ -154,12 +159,34 @@ export class YAMLSchemaService extends JSONSchemaService {
     let schema: JSONSchema = schemaToResolve.schema;
     const contextService = this.contextService;
 
-    // Basic schema validation - check if schema is a valid object
     if (typeof schema !== 'object' || schema === null || Array.isArray(schema)) {
       const invalidSchemaType = Array.isArray(schema) ? 'array' : typeof schema;
       resolveErrors.push(
         `Schema '${getSchemaTitle(schemaToResolve.schema, schemaURL)}' is not valid:\nWrong schema: "${invalidSchemaType}", it MUST be an Object or Boolean`
       );
+    } else {
+      try {
+        const schemaVersion = this.detectSchemaVersion(schema);
+        const validator = this.getValidatorForVersion(schemaVersion);
+        const metaSchemaUrl = this.getSchemaMetaSchema(schemaVersion);
+
+        // Validate the schema against its meta-schema using the URL directly
+        const result = await validator.validate(metaSchemaUrl, schema, 'BASIC');
+        if (!result.valid && result.errors) {
+          const errs: string[] = [];
+          for (const error of result.errors) {
+            if (error.instanceLocation && error.keyword) {
+              errs.push(`${error.instanceLocation}: ${this.extractKeywordName(error.keyword)} constraint violation`);
+            }
+          }
+          if (errs.length > 0) {
+            resolveErrors.push(`Schema '${getSchemaTitle(schemaToResolve.schema, schemaURL)}' is not valid:\n${errs.join('\n')}`);
+          }
+        }
+      } catch (error) {
+        // If meta-schema validation fails, log but don't block schema loading
+        console.error(`Failed to validate schema meta-schema: ${error.message}`);
+      }
     }
 
     const findSection = (schema: JSONSchema, path: string): JSONSchema => {
@@ -269,15 +296,14 @@ export class YAMLSchemaService extends JSONSchemaService {
         while (next.$ref) {
           const ref = decodeURIComponent(next.$ref);
           const segments = ref.split('#', 2);
-          //return back removed $ref. We lost info about referenced type without it.
           next._$ref = next.$ref;
           delete next.$ref;
           if (segments[0].length > 0) {
             openPromises.push(resolveExternalLink(next, segments[0], segments[1], parentSchemaURL, parentSchemaDependencies));
             return;
           } else {
             if (!seenRefs.has(ref)) {
-              merge(next, parentSchema, parentSchemaURL, segments[1]); // can set next.$ref again, use seenRefs to avoid circle
+              merge(next, parentSchema, parentSchemaURL, segments[1]);
               seenRefs.add(ref);
             }
           }
@@ -335,9 +361,6 @@ export class YAMLSchemaService extends JSONSchemaService {
       let schemaFromModeline = getSchemaFromModeline(doc);
       if (schemaFromModeline !== undefined) {
         if (!schemaFromModeline.startsWith('file:') && !schemaFromModeline.startsWith('http')) {
-          // If path contains a fragment and it is left intact, "#" will be
-          // considered part of the filename and converted to "%23" by
-          // path.resolve() -> take it out and add back after path.resolve
           let appendix = '';
           if (schemaFromModeline.indexOf('#') > 0) {
             const segments = schemaFromModeline.split('#', 2);
@@ -393,7 +416,6 @@ export class YAMLSchemaService extends JSONSchemaService {
       }
 
       if (schemas.length > 0) {
-        // Join all schemas with the highest priority.
         const highestPrioSchemas = this.highestPrioritySchemas(schemas);
         return resolveSchemaForResource(highestPrioSchemas);
       }
@@ -469,14 +491,12 @@ export class YAMLSchemaService extends JSONSchemaService {
     let highestPrio = 0;
     const priorityMapping = new Map<SchemaPriority, string[]>();
     schemas.forEach((schema) => {
-      // If the schema does not have a priority then give it a default one of [0]
       const priority = this.schemaPriorityMapping.get(schema) || [0];
       priority.forEach((prio) => {
         if (prio > highestPrio) {
           highestPrio = prio;
         }
 
-        // Build up a mapping of priority to schemas so that we can easily get the highest priority schemas easier
         let currPriorityArray = priorityMapping.get(prio);
         if (currPriorityArray) {
           currPriorityArray = (currPriorityArray as string[]).concat(schema);
@@ -601,7 +621,6 @@ export class YAMLSchemaService extends JSONSchemaService {
    */
 
   normalizeId(id: string): string {
-    // The parent's `super.normalizeId(id)` isn't visible, so duplicated the code here
     try {
       return URI.parse(id).toString();
     } catch (e) {
@@ -621,9 +640,6 @@ export class YAMLSchemaService extends JSONSchemaService {
   loadSchema(schemaUri: string): Promise<UnresolvedSchema> {
     const requestService = this.requestService;
     return super.loadSchema(schemaUri).then(async (unresolvedJsonSchema: UnresolvedSchema) => {
-      // If json-language-server failed to parse the schema, attempt to parse it as YAML instead.
-      // If the YAML file starts with %YAML 1.x or contains a comment with a number the schema will
-      // contain a number instead of being undefined, so we need to check for that too.
       if (
         unresolvedJsonSchema.errors &&
         (unresolvedJsonSchema.schema === undefined || typeof unresolvedJsonSchema.schema === 'number')
@@ -658,7 +674,6 @@ export class YAMLSchemaService extends JSONSchemaService {
             let errorMessage = error.toString();
             const errorSplit = error.toString().split('Error: ');
             if (errorSplit.length > 1) {
-              // more concise error message, URL and context are attached by caller anyways
               errorMessage = errorSplit[1];
             }
             return new UnresolvedSchema(<JSONSchema>{}, [errorMessage]);
@@ -725,6 +740,79 @@ export class YAMLSchemaService extends JSONSchemaService {
   onResourceChange(uri: string): boolean {
     return super.onResourceChange(uri);
   }
+
+  /**
+   * Detect the JSON Schema version from the $schema property
+   */
+  private detectSchemaVersion(schema: JSONSchema): SupportedSchemaVersions {
+    const schemaProperty = schema.$schema;
+    if (typeof schemaProperty === 'string') {
+      if (schemaProperty.includes('2020-12')) {
+        return '2020-12';
+      } else if (schemaProperty.includes('2019-09')) {
+        return '2019-09';
+      } else if (schemaProperty.includes('draft-07') || schemaProperty.includes('draft/7')) {
+        return 'draft-07';
+      } else if (schemaProperty.includes('draft-04') || schemaProperty.includes('draft/4')) {
+        return 'draft-04';
+      }
+    }
+    return 'draft-07';
+  }
+
+  /**
+   * Get the appropriate validator module for a schema version
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private getValidatorForVersion(version: SupportedSchemaVersions): any {
+    switch (version) {
+      case '2020-12':
+        return Draft202012;
+      case '2019-09':
+        return Draft201909;
+      case 'draft-07':
+        return Draft07;
+      case 'draft-04':
+      default:
+        return Draft04;
+    }
+  }
+
+  /**
+   * Get the correct schema meta URI for a given version
+   */
+  private getSchemaMetaSchema(version: SupportedSchemaVersions): string {
+    switch (version) {
+      case '2020-12':
+        return 'https://json-schema.org/draft/2020-12/schema';
+      case '2019-09':
+        return 'https://json-schema.org/draft/2019-09/schema';
+      case 'draft-07':
+        return 'http://json-schema.org/draft-07/schema';
+      case 'draft-04':
+        return 'http://json-schema.org/draft-04/schema';
+      default:
+        return 'http://json-schema.org/draft-07/schema';
+    }
+  }
+
+  /**
+   * Extract a human-readable keyword name from a keyword URI
+   */
+  private extractKeywordName(keywordUri: string): string {
+    if (typeof keywordUri !== 'string') {
+      return 'validation';
+    }
+
+    const parts = keywordUri.split('/');
+    const lastPart = parts[parts.length - 1];
+
+    if (lastPart === 'validate') {
+      return 'schema validation';
+    }
+
+    return lastPart || 'validation';
+  }
 }
 
 function toDisplayString(url: string): string {
@@ -741,7 +829,7 @@ function toDisplayString(url: string): string {
 
 function getLineAndColumnFromOffset(text: string, offset: number): { line: number; column: number } {
   const lines = text.slice(0, offset).split(/\r?\n/);
-  const line = lines.length; // 1-based line number
-  const column = lines[lines.length - 1].length + 1; // 1-based column number
+  const line = lines.length;
+  const column = lines[lines.length - 1].length + 1;
   return { line, column };
 }

src/languageservice/utils/schemaUtils.ts

@@ -49,6 +49,12 @@ export function getSchemaTitle(schema: JSONSchema, url: string): string {
   if (!path.extname(uri.fsPath)) {
     baseName += '.json';
   }
+
+  // Handle null or undefined schemas
+  if (!schema || typeof schema !== 'object') {
+    return baseName;
+  }
+
   if (Object.getOwnPropertyDescriptor(schema, 'name')) {
     return Object.getOwnPropertyDescriptor(schema, 'name').value + ` (${baseName})`;
   } else if (schema.title) {

test/fixtures/schema-2019-09.json

@@ -0,0 +1,54 @@
+{
+    "$schema": "https://json-schema.org/draft/2019-09/schema",
+    "$id": "https://example.com/person.schema.json",
+    "title": "Person Schema 2019-09",
+    "type": "object",
+    "properties": {
+        "firstName": {
+            "type": "string",
+            "description": "The person's first name."
+        },
+        "lastName": {
+            "type": "string",
+            "description": "The person's last name."
+        },
+        "age": {
+            "description": "Age in years which must be equal to or greater than zero.",
+            "type": "integer",
+            "minimum": 0
+        },
+        "email": {
+            "type": "string",
+            "format": "email"
+        },
+        "address": {
+            "$ref": "#/$defs/address"
+        }
+    },
+    "required": [
+        "firstName",
+        "lastName"
+    ],
+    "$defs": {
+        "address": {
+            "type": "object",
+            "properties": {
+                "street": {
+                    "type": "string"
+                },
+                "city": {
+                    "type": "string"
+                },
+                "country": {
+                    "type": "string"
+                }
+            },
+            "required": [
+                "street",
+                "city",
+                "country"
+            ]
+        }
+    },
+    "unevaluatedProperties": false
+}

test/fixtures/schema-2020-12.json

@@ -0,0 +1,67 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "https://example.com/product.schema.json",
+    "title": "Product Schema 2020-12",
+    "type": "object",
+    "properties": {
+        "productId": {
+            "type": "integer",
+            "description": "The unique identifier for a product"
+        },
+        "productName": {
+            "type": "string",
+            "description": "Name of the product"
+        },
+        "price": {
+            "type": "number",
+            "minimum": 0,
+            "exclusiveMinimum": true
+        },
+        "tags": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            },
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "dimensions": {
+            "$ref": "#/$defs/dimensions"
+        },
+        "category": {
+            "enum": [
+                "electronics",
+                "clothing",
+                "books",
+                "home"
+            ]
+        }
+    },
+    "required": [
+        "productId",
+        "productName",
+        "price"
+    ],
+    "$defs": {
+        "dimensions": {
+            "type": "object",
+            "properties": {
+                "length": {
+                    "type": "number"
+                },
+                "width": {
+                    "type": "number"
+                },
+                "height": {
+                    "type": "number"
+                }
+            },
+            "required": [
+                "length",
+                "width",
+                "height"
+            ]
+        }
+    },
+    "unevaluatedProperties": false
+}