json-schema-library 11.2.0 → 11.3.1

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## Changelog
 
+### v11.3.0
+
+- added option 'draft' as fallback for a missing `$schema` id
+- added properties to merge when resolvinf a $ref to `settings.PROPERTIES_TO_MERGE`
+
 ### v11.2.0
 
 - introduced `throwOnInvalidRef` to abort validation when a $ref cannot be resolved

package/bowtie/BOWTIE.md

@@ -27,14 +27,14 @@ echo '{"cmd":"stop"}' | docker run -i jlib
 bowtie smoke -i localhost/jlib
 bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/blob/main/tests/draft7/type.json | bowtie summary --show failures
 
-bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft7 > draft7.json
-bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2019-09 > draft2019-09.json
-bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2020-12 > draft2020-12.json
-
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft4 | bowtie summary --show failures
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft6 | bowtie summary --show failures
 bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft7 | bowtie summary --show failures
 bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2019-09 | bowtie summary --show failures
 bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2020-12 | bowtie summary --show failures
 
+bowtie suite -i localhost/jlib https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft7 > draft7.json
+
 **Fails**
 bowtie suite $(bowtie filter-implementations | sed 's/^/-i /') https://github.com/json-schema-org/JSON-Schema-Test-Suite/tree/main/tests/draft2020-12 >draft2020-12.json
 

package/bowtie/Dockerfile

@@ -3,4 +3,4 @@ COPY . /usr/app
 WORKDIR /usr/app
 RUN npm install --omit=dev
 RUN npm -g install tsm
-CMD ["tsm", "bowtie.ts"]
+CMD ["tsm", "bowtie-jlib.ts"]

package/bowtie/{bowtie.ts → bowtie-jlib.ts}

@@ -19,6 +19,7 @@ import {
 let state: "started" | "dialect" | "testing" | "stopped" = "stopped";
 /** current JSON Schema draft version to test */
 let dialect: Dialect;
+/** all meta-schemata added as remtoes */
 let remote: SchemaNode;
 
 const cmds: CommandMap = {
@@ -26,6 +27,7 @@ const cmds: CommandMap = {
         console.assert(args.version === 1, { args });
         console.assert(state === "stopped");
         state = "started";
+
         return {
             version: 1,
             implementation: {
@@ -53,32 +55,23 @@ const cmds: CommandMap = {
     dialect: async (args) => {
         console.assert(state === "started");
         state = "dialect";
-        dialect = args.dialect;
-
-        const node = compileSchema({ $schema: dialect });
-        remotes.forEach((schema) => {
-            node.addRemoteSchema(schema.$id ?? schema.id, schema);
-        });
-        remote = node;
 
+        dialect = args.dialect;
+        remote = compileSchema({ $schema: dialect });
+        remotes.forEach((schema) => remote.addRemoteSchema(schema.$id ?? schema.id, schema));
         return { ok: true };
     },
 
     run: async (args) => {
         console.assert(state === "dialect" || state === "testing");
         state = "testing";
-        const { schema, tests, registry } = args.case;
-        if (schema != null && typeof schema === "object") {
-            schema.$schema = dialect; // set draft version to non-boolean schema
-        }
-        // compile schema
-        const node = compileSchema(schema, { remote, formatAssertion: false });
-        // add remote schemata
-        for (const id in registry) {
-            node.addRemoteSchema(id, registry[id]);
+
+        const node = compileSchema(args.case.schema, { remote, draft: dialect, formatAssertion: false });
+        for (const id in args.case.registry) {
+            node.addRemoteSchema(id, args.case.registry[id]);
         }
         // run test cases and collect results to be sent back to bowtie
-        const results: RunCmdResponse["results"] = tests.map((test) => {
+        const results: RunCmdResponse["results"] = args.case.tests.map((test) => {
             try {
                 return { valid: node.validate(test.instance).valid };
             } catch (e) {
@@ -92,6 +85,7 @@ const cmds: CommandMap = {
     stop: async (_, stdio) => {
         console.assert(state === "testing");
         state = "stopped";
+
         if (process.env.JLIB_TEST_RUN !== "true") {
             stdio?.close();
             process.exit(0);

package/bowtie/bowtie.test.ts

@@ -2,7 +2,7 @@ import { strict as assert } from "node:assert";
 import { compileSchema } from "../src/compileSchema";
 import { remotes } from "json-schema-library/remotes";
 import { JsonSchema } from "../src/types";
-import { runCommand } from "./bowtie";
+import { runCommand } from "./bowtie-jlib";
 import { ErrorResponse, RunCmdResponse } from "./bowtie-api";
 
 const isRunCmdResponse = (value: unknown): value is RunCmdResponse =>
@@ -14,6 +14,86 @@ const isErrorResponse = (value: unknown): value is ErrorResponse =>
 const remote = compileSchema({ $id: "draft2020-12" });
 remotes.map((schema: JsonSchema) => remote.addRemoteSchema(schema.$id ?? schema.id, schema));
 
+describe("bowtie (draft4)", async () => {
+    before(async () => {
+        await runCommand({ cmd: "start", version: 1 });
+        await runCommand({ cmd: "dialect", dialect: "http://json-schema.org/draft-04/schema#" });
+    });
+    after(async () => runCommand({ cmd: "stop" }));
+
+    const registry = {
+        "http://localhost:1234/draft4/name.json": {
+            definitions: { orNull: { anyOf: [{ type: "null" }, { $ref: "#" }] } },
+            type: "string"
+        },
+        "http://localhost:1234/v1/nested-absolute-ref-to-string.json": {
+            $defs: { bar: { $id: "http://localhost:1234/v1/the-nested-id.json", type: "string" } },
+            $ref: "http://localhost:1234/v1/the-nested-id.json"
+        },
+        "http://localhost:1234/nested/string.json": { type: "string" },
+        "http://localhost:1234/baseUriChange/folderInteger.json": { type: "integer" },
+        "http://localhost:1234/draft4/subSchemas.json": {
+            definitions: { integer: { type: "integer" }, refToInteger: { $ref: "#/definitions/integer" } }
+        },
+        "http://localhost:1234/v1/different-id-ref-string.json": {
+            $id: "http://localhost:1234/v1/real-id-ref-string.json",
+            $defs: { bar: { type: "string" } },
+            $ref: "#/$defs/bar"
+        },
+        "http://localhost:1234/v1/urn-ref-string.json": {
+            $id: "urn:uuid:feebdaed-ffff-0000-ff01-0000deadbeef",
+            $defs: { bar: { type: "string" } },
+            $ref: "#/$defs/bar"
+        },
+        "http://localhost:1234/integer.json": { type: "integer" },
+        "http://localhost:1234/nested/foo-ref-string.json": {
+            type: "object",
+            properties: { foo: { $ref: "string.json" } }
+        },
+        "http://localhost:1234/baseUriChangeFolder/folderInteger.json": { type: "integer" },
+        "http://localhost:1234/draft4/locationIndependentIdentifier.json": {
+            definitions: { refToInteger: { $ref: "#foo" }, A: { id: "#foo", type: "integer" } }
+        },
+        "http://localhost:1234/baseUriChangeFolderInSubschema/folderInteger.json": { type: "integer" }
+    };
+
+    it("Location-independent identifier in remote ref - additional items match schema", async () => {
+        const response = await runCommand({
+            cmd: "run",
+            seq: 1,
+            case: {
+                description: "Location-independent identifier in remote ref",
+                schema: {
+                    $ref: "http://localhost:1234/draft4/locationIndependentIdentifier.json#/definitions/refToInteger"
+                },
+                registry,
+                tests: [{ description: "integer is valid", instance: 1, valid: true }]
+            }
+        });
+        assert(isRunCmdResponse(response));
+        assert(!isErrorResponse(response.results[0]));
+        assert.equal(response.results[0].valid, true);
+    });
+
+    it("Location-independent identifier in remote ref - additional items do not match schema", async () => {
+        const response = await runCommand({
+            cmd: "run",
+            seq: 1,
+            case: {
+                description: "Location-independent identifier in remote ref",
+                schema: {
+                    $ref: "http://localhost:1234/draft4/locationIndependentIdentifier.json#/definitions/refToInteger"
+                },
+                registry,
+                tests: [{ description: "string is invalid", instance: "foo", valid: false }]
+            }
+        });
+        assert(isRunCmdResponse(response));
+        assert(!isErrorResponse(response.results[0]));
+        assert.equal(response.results[0].valid, false);
+    });
+});
+
 describe("bowtie (draft7)", async () => {
     before(async () => {
         await runCommand({ cmd: "start", version: 1 });
@@ -54,23 +134,214 @@ describe("bowtie (draft7)", async () => {
     });
 });
 
-describe("bowtie (2020-12)", () => {
-    describe("validate definition against metaschema", () => {
-        const node = compileSchema(
-            {
-                $schema: "https://json-schema.org/draft/2020-12/schema",
-                $ref: "https://json-schema.org/draft/2020-12/schema"
-            },
-            { remote }
-        );
+describe("bowtie (2019-09)", () => {
+    const testCase = {
+        description: "schema that uses custom metaschema with with no validation vocabulary",
+        schema: {
+            $id: "https://schema/using/no/validation",
+            $schema: "http://localhost:1234/draft2019-09/metaschema-no-validation.json",
+            properties: { badProperty: false, numberProperty: { minimum: 10 } }
+        },
+        registry: {
+            "http://localhost:1234/draft2019-09/integer.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                type: "integer"
+            },
+            "http://localhost:1234/draft2019-09/dependentRequired.json": {
+                $id: "http://localhost:1234/draft2019-09/dependentRequired.json",
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                dependentRequired: { foo: ["bar"] }
+            },
+            "http://localhost:1234/draft2019-09/detached-ref.json": {
+                $id: "http://localhost:1234/draft2019-09/detached-ref.json",
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                $defs: { foo: { $ref: "#detached" }, detached: { $anchor: "detached", type: "integer" } }
+            },
+            "http://localhost:1234/integer.json": { type: "integer" },
+            "http://localhost:1234/draft2019-09/nested/foo-ref-string.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                type: "object",
+                properties: { foo: { $ref: "string.json" } }
+            },
+            "http://localhost:1234/draft2019-09/urn-ref-string.json": {
+                $id: "urn:uuid:feebdaed-ffff-0000-2019-0900deadbeef",
+                $defs: { bar: { type: "string" } },
+                $ref: "#/$defs/bar"
+            },
+            "http://localhost:1234/draft2019-09/locationIndependentIdentifier.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                $defs: { refToInteger: { $ref: "#foo" }, A: { $anchor: "foo", type: "integer" } }
+            },
+            "http://localhost:1234/baseUriChangeFolder/folderInteger.json": { type: "integer" },
+            "http://localhost:1234/draft2019-09/baseUriChange/folderInteger.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                type: "integer"
+            },
+            "http://localhost:1234/draft2019-09/ref-and-defs.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                $id: "http://localhost:1234/draft2019-09/ref-and-defs.json",
+                $defs: { inner: { properties: { bar: { type: "string" } } } },
+                $ref: "#/$defs/inner"
+            },
+            "http://localhost:1234/baseUriChangeFolderInSubschema/folderInteger.json": { type: "integer" },
+            "http://localhost:1234/draft2019-09/baseUriChangeFolder/folderInteger.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                type: "integer"
+            },
+            "http://localhost:1234/nested/foo-ref-string.json": {
+                type: "object",
+                properties: { foo: { $ref: "string.json" } }
+            },
+            "http://localhost:1234/nested/string.json": { type: "string" },
+            "http://localhost:1234/draft2019-09/baseUriChangeFolderInSubschema/folderInteger.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                type: "integer"
+            },
+            "http://localhost:1234/draft2019-09/name-defs.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                $defs: { orNull: { anyOf: [{ type: "null" }, { $ref: "#" }] } },
+                type: "string"
+            },
+            "http://localhost:1234/v1/different-id-ref-string.json": {
+                $id: "http://localhost:1234/v1/real-id-ref-string.json",
+                $defs: { bar: { type: "string" } },
+                $ref: "#/$defs/bar"
+            },
+            "http://localhost:1234/v1/nested-absolute-ref-to-string.json": {
+                $defs: { bar: { $id: "http://localhost:1234/v1/the-nested-id.json", type: "string" } },
+                $ref: "http://localhost:1234/v1/the-nested-id.json"
+            },
+            "http://localhost:1234/v1/urn-ref-string.json": {
+                $id: "urn:uuid:feebdaed-ffff-0000-ff01-0000deadbeef",
+                $defs: { bar: { type: "string" } },
+                $ref: "#/$defs/bar"
+            },
+            "http://localhost:1234/draft2019-09/ignore-prefixItems.json": {
+                $id: "http://localhost:1234/draft2019-09/ignore-prefixItems.json",
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                prefixItems: [{ type: "string" }]
+            },
+            "http://localhost:1234/draft2019-09/subSchemas.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                $defs: { integer: { type: "integer" }, refToInteger: { $ref: "#/$defs/integer" } }
+            },
+            "http://localhost:1234/draft2019-09/nested-absolute-ref-to-string.json": {
+                $defs: { bar: { $id: "http://localhost:1234/draft2019-09/the-nested-id.json", type: "string" } },
+                $ref: "http://localhost:1234/draft2019-09/the-nested-id.json"
+            },
+            "http://localhost:1234/draft2019-09/nested/string.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                type: "string"
+            },
+            "http://localhost:1234/draft2019-09/metaschema-optional-vocabulary.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                $id: "http://localhost:1234/draft2019-09/metaschema-optional-vocabulary.json",
+                $vocabulary: {
+                    "https://json-schema.org/draft/2019-09/vocab/validation": true,
+                    "https://json-schema.org/draft/2019-09/vocab/core": true,
+                    "http://localhost:1234/draft/2019-09/vocab/custom": false
+                },
+                $recursiveAnchor: true,
+                allOf: [
+                    { $ref: "https://json-schema.org/draft/2019-09/meta/validation" },
+                    { $ref: "https://json-schema.org/draft/2019-09/meta/core" }
+                ]
+            },
+            "http://localhost:1234/draft2019-09/different-id-ref-string.json": {
+                $id: "http://localhost:1234/draft2019-09/real-id-ref-string.json",
+                $defs: { bar: { type: "string" } },
+                $ref: "#/$defs/bar"
+            },
+            "http://localhost:1234/draft2019-09/extendible-dynamic-ref.json": {
+                description: "extendible array",
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                $id: "http://localhost:1234/draft2019-09/extendible-dynamic-ref.json",
+                type: "object",
+                properties: { elements: { type: "array", items: { $dynamicRef: "#elements" } } },
+                required: ["elements"],
+                additionalProperties: false,
+                $defs: { elements: { $dynamicAnchor: "elements" } }
+            },
+            "http://localhost:1234/draft2019-09/metaschema-no-validation.json": {
+                $schema: "https://json-schema.org/draft/2019-09/schema",
+                $id: "http://localhost:1234/draft2019-09/metaschema-no-validation.json",
+                $vocabulary: {
+                    "https://json-schema.org/draft/2019-09/vocab/applicator": true,
+                    "https://json-schema.org/draft/2019-09/vocab/core": true
+                },
+                $recursiveAnchor: true,
+                allOf: [
+                    { $ref: "https://json-schema.org/draft/2019-09/meta/applicator" },
+                    { $ref: "https://json-schema.org/draft/2019-09/meta/core" }
+                ]
+            },
+            "http://localhost:1234/baseUriChange/folderInteger.json": { type: "integer" }
+        }
+    };
+
+    before(async () => {
+        await runCommand({ cmd: "start", version: 1 });
+        await runCommand({ cmd: "dialect", dialect: "https://json-schema.org/draft/2019-09/schema" });
+    });
+    after(async () => runCommand({ cmd: "stop" }));
 
-        it("valid definition schema", () => {
-            const first = node.validate({ $defs: { foo: { type: "integer" } } });
-            assert.deepEqual(first.valid, true);
+    it(`${testCase.description} - applicator vocabulary still works`, async () => {
+        const response = await runCommand({
+            cmd: "run",
+            seq: 1,
+            case: {
+                ...testCase,
+                tests: [
+                    {
+                        description: "applicator vocabulary still works",
+                        instance: { badProperty: "this property should not exist" },
+                        valid: false
+                    }
+                ]
+            }
         });
-        it("invalid definition schema", () => {
-            const second = node.validate({ $defs: { foo: { type: 1 } } });
-            assert.deepEqual(second.valid, false);
+        assert(isRunCmdResponse(response));
+        assert(!isErrorResponse(response.results[0]));
+        assert.equal(response.results[0].valid, false);
+    });
+
+    it(`${testCase.description} - no validation: valid number`, async () => {
+        const response = await runCommand({
+            cmd: "run",
+            seq: 1,
+            case: {
+                ...testCase,
+                tests: [
+                    {
+                        description: "no validation: valid number",
+                        instance: { numberProperty: 20 },
+                        valid: true
+                    }
+                ]
+            }
         });
+        assert(isRunCmdResponse(response));
+        assert(!isErrorResponse(response.results[0]));
+        assert.equal(response.results[0].valid, true);
+    });
+
+    it(`${testCase.description} - no validation: invalid number, but it still validates`, async () => {
+        const response = await runCommand({
+            cmd: "run",
+            seq: 1,
+            case: {
+                ...testCase,
+                tests: [
+                    {
+                        description: "no validation: invalid number, but it still validates",
+                        instance: { numberProperty: 1 },
+                        valid: true
+                    }
+                ]
+            }
+        });
+        assert(isRunCmdResponse(response));
+        assert(!isErrorResponse(response.results[0]));
+        assert.equal(response.results[0].valid, true);
     });
 });

package/bowtie/package.json

@@ -5,7 +5,7 @@
     "format": "prettier -w ."
   },
   "dependencies": {
-    "json-schema-library": "*",
+    "json-schema-library": ">=11.3.1",
     "prettier": "^3.8.1"
   }
 }