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

damioune123 · damioune123 · commit c2874e53a68d · 2025-07-23T00:39:20.000+02:00
diff --git a/README.md b/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
diff --git a/src/languageservice/services/yamlSchemaService.ts b/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 {
@@ -154,12 +160,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 => {
@@ -268,16 +296,16 @@ export class YAMLSchemaService extends JSONSchemaService {
         const seenRefs = new Set();
         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.
+          const segments = ref.split('#', 2);
           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);
             }
           }
@@ -475,7 +503,6 @@ export class YAMLSchemaService extends JSONSchemaService {
         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) {
@@ -620,10 +647,10 @@ export class YAMLSchemaService extends JSONSchemaService {
 
   loadSchema(schemaUri: string): Promise<UnresolvedSchema> {
     const requestService = this.requestService;
+    // 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.
     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')
@@ -656,9 +683,9 @@ export class YAMLSchemaService extends JSONSchemaService {
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           (error: any) => {
             let errorMessage = error.toString();
+            // more concise error message, URL and context are attached by caller anyways
             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 +752,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 {
diff --git a/src/languageservice/utils/schemaUtils.ts b/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) {
diff --git a/test/fixtures/schema-2019-09.json b/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
+}
diff --git a/test/fixtures/schema-2020-12.json b/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
+}
diff --git a/test/fixtures/schema-draft-04.json b/test/fixtures/schema-draft-04.json
@@ -0,0 +1,59 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "id": "https://example.com/product-draft-04.schema.json",
+    "title": "Product Schema Draft 04",
+    "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,
+            "description": "The price of the product"
+        },
+        "tags": {
+            "type": "array",
+            "items": {
+                "type": "string"
+            },
+            "minItems": 1,
+            "uniqueItems": true
+        },
+        "dimensions": {
+            "$ref": "#/definitions/dimensions"
+        }
+    },
+    "required": [
+        "productId",
+        "productName",
+        "price"
+    ],
+    "definitions": {
+        "dimensions": {
+            "type": "object",
+            "properties": {
+                "length": {
+                    "type": "number"
+                },
+                "width": {
+                    "type": "number"
+                },
+                "height": {
+                    "type": "number"
+                }
+            },
+            "required": [
+                "length",
+                "width",
+                "height"
+            ]
+        }
+    }
+}
diff --git a/test/fixtures/schema-draft-07.json b/test/fixtures/schema-draft-07.json
diff --git a/test/yamlSchemaService.test.ts b/test/yamlSchemaService.test.ts
