@hyperjump/json-schema 1.6.5 → 1.6.7

package/bundle/README.md

@@ -0,0 +1,134 @@
+# Bundler Tests
+
+The testing strategy used by this Test Suite is based on the concept that it
+should be indistinguishable whether the user evaluated the schema using the
+bundle or using individually loaded schemas. Test Runners should validate each
+Test twice, once with all schemas loaded individually and again using just the
+bundle. The Test passes if both evaluations produce identical output.
+
+The accuracy of this testing approach is dependent on how detailed the output
+is. It's recommended that Test Runner use a validator implementation that
+supports the
+["verbose"](https://json-schema.org/draft/2020-12/json-schema-core#name-verbose)
+official output format or something similarly detailed that can be used for
+comparison.
+
+## Supported Dialects
+
+Although the topic of bundling didn't appear in the spec until 2020-12, the
+process described is applicable since `id` (now `$id`) was introduced in
+draft-03. Test Cases in this Test Suite are designed to be compatible with as
+many releases of JSON Schema as possible. They do not include a `$schema`
+keyword so that implementations can run the same Test Suite for each dialect
+they support. The Test Runner should define what dialect it's using to run the
+Test Suite.
+
+Since this Test Suite can be used for a variety of dialects, there are a couple
+of options that can be used by Test Runners to filter out Test Cases that don't
+apply to the dialect under test.
+
+## Test Case Components
+
+### description
+
+A short description of what behavior the Test Case is covering.
+
+### compatibility
+
+The `compatibility` option allows you to set which dialects the Test Case is
+compatible with. Test Runners can use this value to filter out Test Cases that
+don't apply the to dialect currently under test. Dialects are indicated by the
+number corresponding to their release. Date-based releases use just the year.
+
+If this option isn't present, it means the Test Case is compatible with draft-03
+and above.
+
+If this option is present with a number, the number indicates the minimum
+release the Test Case is compatible with. This example indicates that the Test
+Case is compatible with draft-07 and up.
+
+**Example**: `"compatibility": "7"`
+
+You can use a `<=` operator to indicate that the Test Case is compatible with
+releases less then or equal to the given release. This example indicates that
+the Test Case is compatible with 2019-09 and under.
+
+**Example**: `"compatibility": "<=2019"`
+
+You can use comma-separated values to indicate multiple constraints if needed.
+This example indicates that the Test Case is compatible with releases between
+draft-06 and 2019-09.
+
+**Example**: `"compatibility": "6,<=2019"`
+
+For convenience, you can use the `=` operator to indicate a Test Case is only
+compatible with a single release. This example indicates that the Test Case is
+compatible only with 2020-12.
+
+**Example**: `"compatibility": "=2020"`
+
+### requiredDialects
+
+Since 2020-12, it's been allowed to have bundles that include schemas using
+dialects different from the parent schema. In order to test this, it's necessary
+to have an external schema that declares a dialect with `$schema`. The
+`requiredDialects` option can be included to tell the Test Runner which dialects
+are required to run the Test Case other than the dialect under test. This option
+is an array of numbers corresponding to release numbers. Date-based releases use
+just the year.
+
+**Example**: `"requiredDialects": [2019]`
+
+### schema
+
+The schema that will serve as the entry point of the bundle. This schema
+shouldn't include `$schema` or `id`/`$id` because Test Cases should be designed
+to work with as many releases as possible.
+
+### externalSchemas
+
+`externalSchemas` is where you define the schemas that the schema in `schema`
+references and you expect to get embedded into the bundled schema. The value is
+an object where the keys are retrieval URIs and values are schemas. Most
+external schemas aren't self identifying (using `id`/`$id`) and rely solely on
+the retrieval URI for identification. This is done to increase the number of
+dialects that the test is compatible with. Because `id` changed to `$id` in
+draft-06, if you use `$id`, the test becomes incompatible with draft-03/4 and in
+most cases, that's not necessary.
+
+### tests
+
+`tests` are a collection of Tests to run to verify the Test Case. Tests don't
+include an expected pass/fail for the instance because we don't care if the
+instance is valid or not, we care only whether the bundle produces the same
+results as its unbundled equivalent.
+
+Tests should be designed to expose potential differences between the bundled and
+unbundled evaluations. You should have at least one Test that's expected to pass
+to ensure that annotations are equivalent and at least one Test that's expected
+to fail to ensure errors are equivalent.
+
+## Fixtures
+
+Often we don't care what's in the externally referenced schemas and end up using
+the same simple and generic schemas in a lot of tests. In order to reduce
+duplication, there are a couple of generic schemas defined that test runners
+should load in addition to `externalSchemas` for each Test Case.
+
+Fixtures are expected to be simple, compatible with all dialects, and not
+critical to understanding what is being tested. Anything that doesn't meet those
+criteria is better off declared in `externalSchemas`.
+
+## Directory Structure
+
+* tests - A directory containing the full Test Suite.
+  * tests.json - A Test Suite covering functionality in the latest spec release.
+  * legacy-tests.json - A Test Suite covering functionality that was removed in
+    a previous release. This is mostly adaptations of Test Cases that use `$id`
+    or `$defs` to cover the same functionality for older releases that use `id`
+    or `definitions`. Test Cases involving other removed keywords such as
+    `dependencies` and `recursiveRef` can be found here as well.
+* fixtures - A collection of simple and reusable schemas
+  * string.schema.json
+  * number.schema.json
+  * ... etc

package/bundle/index.js

@@ -223,8 +223,8 @@ const loadKeywordSupport = () => {
 
   const dependencies = getKeyword("https://json-schema.org/keyword/draft-04/dependencies");
   if (dependencies) {
-    dependencies.collectExternalIds = (dependentSchemas, externalIds, ast, dynamicAnchors) => {
-      Object.values(dependentSchemas).forEach(([, dependency]) => {
+    dependencies.collectExternalIds = (dependencies, externalIds, ast, dynamicAnchors) => {
+      Object.values(dependencies).forEach(([, dependency]) => {
         if (typeof dependency === "string") {
           Validation.collectExternalIds(dependency, externalIds, ast, dynamicAnchors);
         }
@@ -265,4 +265,52 @@ const loadKeywordSupport = () => {
       Validation.collectExternalIds(contains, externalIds, ast, dynamicAnchors);
     };
   }
+
+  // Experimental
+
+  const propertyDependencies = getKeyword("https://json-schema.org/keyword/propertyDependencies");
+  if (propertyDependencies) {
+    propertyDependencies.collectExternalIds = (propertyDependencies, externalIds, ast, dynamicAnchors) => {
+      for (const key in propertyDependencies) {
+        for (const value in propertyDependencies[key]) {
+          Validation.collectExternalIds(propertyDependencies[key][value], externalIds, ast, dynamicAnchors);
+        }
+      }
+    };
+  }
+
+  const conditional = getKeyword("https://json-schema.org/keyword/conditional");
+  if (conditional) {
+    conditional.collectExternalIds = (conditional, externalIds, ast, dynamicAnchors) => {
+      for (const schema of conditional) {
+        Validation.collectExternalIds(schema, externalIds, ast, dynamicAnchors);
+      }
+    };
+  }
+
+  const itemPattern = getKeyword("https://json-schema.org/keyword/itemPattern");
+  if (itemPattern) {
+    itemPattern.collectExternalIds = (nfa, externalIds, ast, dynamicAnchors) => {
+      for (const itemSchema of collectNfaSchemas(nfa.start)) {
+        Validation.collectExternalIds(itemSchema, externalIds, ast, dynamicAnchors);
+      }
+    };
+  }
+
+  const collectNfaSchemas = function* (node, visited = new Set()) {
+    if (visited.has(node)) {
+      return;
+    }
+
+    visited.add(node);
+
+    for (const schema in node.transition) {
+      yield schema;
+      yield* collectNfaSchemas(node.transition[schema], visited);
+    }
+
+    for (const epsilon of node.epsilonTransitions) {
+      yield* collectNfaSchemas(epsilon, visited);
+    }
+  };
 };

package/lib/keywords/enum.js

@@ -1,3 +1,4 @@
+import { pipe, asyncMap, asyncCollectArray } from "@hyperjump/pact";
 import jsonStringify from "fastest-stable-stringify";
 import * as Schema from "../schema.js";
 import * as Instance from "../instance.js";
@@ -5,7 +6,13 @@ import * as Instance from "../instance.js";
 
 const id = "https://json-schema.org/keyword/enum";
 
-const compile = (schema) => Schema.value(schema).map(jsonStringify);
+const compile = (schema) => pipe(
+  Schema.iter(schema),
+  asyncMap(Schema.value),
+  asyncMap(jsonStringify),
+  asyncCollectArray
+);
+
 const interpret = (enum_, instance) => enum_.some((enumValue) => jsonStringify(Instance.value(instance)) === enumValue);
 
 export default { id, compile, interpret };

package/lib/keywords.js

@@ -15,9 +15,22 @@ export const defineVocabulary = (id, keywords) => {
 
 const _dialects = {};
 const _allowUnknownKeywords = {};
-export const getKeywordId = (dialectId, keyword) => _dialects[dialectId]?.[keyword]
-  || (_allowUnknownKeywords[dialectId] || keyword[0] === "@") && `https://json-schema.org/keyword/unknown#${keyword}`;
+
+export const getKeywordId = (dialectId, keyword) => {
+  if (!hasDialect(dialectId)) {
+    throw Error(`Encountered unknown dialect '${dialectId}'`);
+  }
+
+  return _dialects[dialectId]?.[keyword]
+    || (_allowUnknownKeywords[dialectId] || keyword.startsWith("x-"))
+    && `https://json-schema.org/keyword/unknown#${keyword}`;
+};
+
 export const getKeywordName = (dialectId, keywordId) => {
+  if (!hasDialect(dialectId)) {
+    throw Error(`Encountered unknown dialect '${dialectId}'`);
+  }
+
   for (const keyword in _dialects[dialectId]) {
     if (_dialects[dialectId][keyword] === keywordId) {
       return keyword;

package/lib/schema.js

@@ -22,14 +22,10 @@ export const add = (schema, retrievalUri = undefined, contextDialectId = undefin
   const dialectId = toAbsoluteIri(schema.$schema || contextDialectId);
   delete schema.$schema;
 
-  if (!hasDialect(dialectId)) {
-    throw Error(`Encountered unknown dialect '${dialectId}'`);
-  }
-
   // Identifiers
   const idToken = getKeywordName(dialectId, "https://json-schema.org/keyword/id")
     || getKeywordName(dialectId, "https://json-schema.org/keyword/draft-04/id");
-  if (retrievalUri === undefined && !(idToken in schema)) {
+  if (!retrievalUri && typeof schema?.[idToken] !== "string") {
     throw Error(`Unable to determine an identifier for the schema. Use the '${idToken}' keyword or pass a retrievalUri when loading the schema.`);
   }
   const internalUrl = resolveUri(schema[idToken] || retrievalUri, retrievalUri);
@@ -77,9 +73,6 @@ const processSchema = (subject, id, dialectId, pointer, anchors, dynamicAnchors)
   if (jsonTypeOf(subject, "object")) {
     // Embedded Schema
     const embeddedDialectId = typeof subject.$schema === "string" ? toAbsoluteIri(subject.$schema) : dialectId;
-    if (!hasDialect(embeddedDialectId)) {
-      throw Error(`Encountered unknown dialect '${embeddedDialectId}'`);
-    }
 
     const idToken = getKeywordName(embeddedDialectId, "https://json-schema.org/keyword/id");
     if (typeof subject[idToken] === "string") {
@@ -259,6 +252,7 @@ export const toSchema = (schemaDoc, options = {}) => {
   const idToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/id")
     || getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-04/id");
   const anchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/anchor");
+  const legacyAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-04/id");
   const dynamicAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/dynamicAnchor");
   const legacyDynamicAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/draft-2020-12/dynamicAnchor");
   const recursiveAnchorToken = getKeywordName(schemaDoc.dialectId, "https://json-schema.org/keyword/recursiveAnchor");
@@ -284,7 +278,14 @@ export const toSchema = (schemaDoc, options = {}) => {
       }
     } else {
       if (pointer in anchors) {
-        value = { [anchorToken]: anchors[pointer], ...value };
+        if (anchorToken) {
+          value = { [anchorToken]: anchors[pointer], ...value };
+        }
+
+        // Legacy anchor
+        if (legacyAnchorToken) {
+          value = { [legacyAnchorToken]: `#${anchors[pointer]}`, ...value };
+        }
       }
       if (pointer in dynamicAnchors) {
         if (dynamicAnchorToken) {

package/openapi-3-0/index.js

@@ -1,5 +1,5 @@
 import { addKeyword, defineVocabulary, loadDialect } from "../lib/keywords.js";
-import { addSchema } from "../lib/core.js";
+import { addSchema } from "../lib/index.js";
 import "../lib/openapi.js";
 
 import dialectSchema from "./dialect.js";

package/openapi-3-1/index.d.ts

@@ -244,7 +244,7 @@ type Header = {
   description?: string;
   required?: boolean;
   deprecated?: boolean;
-  schema?: OpenApi31;
+  schema?: OasSchema31;
   style?: "simple";
   explode?: boolean;
   content?: Content;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperjump/json-schema",
-  "version": "1.6.5",
+  "version": "1.6.7",
   "description": "A JSON Schema validator with support for custom keywords, vocabularies, and dialects",
   "type": "module",
   "main": "./stable/index.js",
@@ -27,7 +27,7 @@
   "scripts": {
     "clean": "xargs -a .gitignore rm -rf",
     "lint": "eslint lib stable draft-* openapi-* bundle annotations",
-    "test": "mocha 'lib/**/*.spec.ts' 'stable/**/*.spec.ts' 'draft-*/**/*.spec.ts' 'openapi-*/**/*.spec.ts' 'bundle/**/*.spec.ts' 'annotations/**/*.spec.ts'"
+    "test": "vitest --watch=false"
   },
   "repository": "github:hyperjump-io/json-schema",
   "keywords": [
@@ -51,20 +51,18 @@
     "url": "https://github.com/sponsors/jdesrosiers"
   },
   "devDependencies": {
-    "@types/chai": "*",
-    "@types/mocha": "*",
     "@types/node": "*",
     "@typescript-eslint/eslint-plugin": "*",
     "@typescript-eslint/parser": "*",
-    "chai": "*",
+    "@vitest/coverage-v8": "^1.0.4",
     "eslint": "*",
+    "eslint-import-resolver-exports": "*",
     "eslint-import-resolver-node": "*",
     "eslint-import-resolver-typescript": "*",
     "eslint-plugin-import": "*",
     "json-schema-test-suite": "github:json-schema-org/JSON-Schema-Test-Suite",
-    "mocha": "*",
-    "ts-node": "*",
     "typescript": "*",
+    "vitest": "*",
     "yaml": "*"
   },
   "dependencies": {