json-schema-library 11.5.0 → 11.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.5.0",
+  "version": "11.5.1",
   "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
   "types": "./dist/index.d.cts",
   "exports": {

package/src/compileSchema.ts

@@ -67,6 +67,9 @@ export type CompileOptions = {
      * Set node and its remote schemata as remote schemata for this node and schema to resolve $ref
      */
     remote?: SchemaNode;
+    /**
+     * a list of remotes to add, requires a unique $id for each schema. Will be ignored if `remote` is set
+     */
     remotes?: JsonSchema[];
     /**
      * Enables `format`-keyword assertions when this is set tor `true` or sets assertion as defined by

package/src/keywords/unevaluatedProperties.test.ts

@@ -1,4 +1,5 @@
 import { compileSchema } from "../compileSchema";
+import { draft2020 } from "../draft2020";
 import { strict as assert } from "assert";
 
 describe("keyword : unevaluatedProperties : validation", () => {
@@ -13,4 +14,60 @@ describe("keyword : unevaluatedProperties : validation", () => {
         });
         assert.equal(errors.length, 0);
     });
+
+    it("should not return unevaluated-property-error for a property that fails format validation", () => {
+        const node = compileSchema(
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    email: { type: "string", format: "email" }
+                },
+                unevaluatedProperties: false
+            },
+            { drafts: [draft2020] }
+        );
+
+        const { errors } = node.validate({ name: "Alice", email: "not-an-email" });
+
+        const unevaluatedErrors = errors.filter((e) => e.code === "unevaluated-property-error");
+        assert.equal(unevaluatedErrors.length, 0, "should not flag email as unevaluated");
+    });
+
+    it("should not return unevaluated-property-error for a property that fails type validation", () => {
+        const node = compileSchema(
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    age: { type: "number" }
+                },
+                unevaluatedProperties: false
+            },
+            { drafts: [draft2020] }
+        );
+
+        const { errors } = node.validate({ name: "Alice", age: "not-a-number" });
+
+        const unevaluatedErrors = errors.filter((e) => e.code === "unevaluated-property-error");
+        assert.equal(unevaluatedErrors.length, 0, "should not flag age as unevaluated");
+    });
+
+    it("should still return unevaluated-property-error for truly unknown properties", () => {
+        const node = compileSchema(
+            {
+                type: "object",
+                properties: {
+                    name: { type: "string" }
+                },
+                unevaluatedProperties: false
+            },
+            { drafts: [draft2020] }
+        );
+
+        const { errors } = node.validate({ name: "Alice", unknown: "value" });
+
+        const unevaluatedErrors = errors.filter((e) => e.code === "unevaluated-property-error");
+        assert.equal(unevaluatedErrors.length, 1, "should flag unknown as unevaluated");
+    });
 });

package/src/keywords/unevaluatedProperties.ts

@@ -56,6 +56,13 @@ function validateUnevaluatedProperties({ node, data, pointer, path }: JsonSchema
 
     const errors: ValidationReturnType = [];
     for (const propertyName of unevaluated) {
+        // Properties defined directly on this schema object are always
+        // evaluated by the "properties" keyword, regardless of whether the
+        // value passes validation (per JSON Schema spec, annotations from
+        // adjacent keywords are always collected)
+        if (node.properties?.[propertyName]) {
+            continue;
+        }
         if (isPropertyEvaluated({ node, data, key: propertyName, pointer, path })) {
             continue;
         }

package/src/settings.ts

@@ -19,7 +19,7 @@ export default {
     ],
     REGEX_FLAGS: "u",
     /** additional keywords that should not produce an unknown-keyword-warning */
-    VALID_ANNOTATION_KEYWORDS: ["title", "description", "default"],
+    VALID_ANNOTATION_KEYWORDS: ["$id", "$schema", "title", "description", "default", "oneOfProperty"],
     /**
      * properties to keep from a $ref-schema when resolving a $ref (recursively)
      * this allows to overwrite specified properties locally on a $ref-definition
@@ -45,5 +45,5 @@ export default {
      *   type: "object"
      * }
      */
-    PROPERTIES_TO_MERGE: ["title", "description", "options", "x-options", "readOnly", "writeOnly"]
+    PROPERTIES_TO_MERGE: ["title", "description", "default", "options", "x-options", "readOnly", "writeOnly"]
 };