json-schema-library 11.4.1 → 11.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.4.1",
+  "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/SchemaNode.ts

@@ -41,7 +41,7 @@ import { getNode } from "./getNode";
 import { getNodeChild } from "./getNodeChild";
 import { DataNode } from "./methods/toDataNodes";
 
-const { DYNAMIC_PROPERTIES, REGEX_FLAGS, DECLARATOR_ONEOF } = settings;
+const { DYNAMIC_PROPERTIES, REGEX_FLAGS, DECLARATOR_ONEOF, VALID_ANNOTATION_KEYWORDS } = settings;
 
 export function isSchemaNode(value: unknown): value is SchemaNode {
     return isObject(value) && Array.isArray(value?.reducers) && Array.isArray(value?.resolvers);
@@ -624,7 +624,10 @@ export function addKeywords(node: SchemaNode) {
         .map((keyword) => execKeyword(keyword, node));
 
     keys.filter(
-        (key) => !key.startsWith("x-") && node.context.keywords.find((keyword) => keyword.keyword === key) == null
+        (key) =>
+            !key.startsWith("x-") &&
+            !VALID_ANNOTATION_KEYWORDS.includes(key) &&
+            node.context.keywords.find((keyword) => keyword.keyword === key) == null
     ).forEach((keyword) => {
         errors.push(
             node.createAnnotation("unknown-keyword-warning", {

package/src/compileSchema.test.ts

@@ -84,6 +84,30 @@ describe("compileSchema draft-version", () => {
     });
 });
 
+describe("compileSchema remotes", () => {
+    it("should add list of remotes to returned SchemaNode node", () => {
+        const node = compileSchema(
+            {
+                type: "object",
+                required: ["string", "number"],
+                properties: {
+                    string: { $ref: "https://remote-a.com/schema" },
+                    number: { $ref: "https://remote-b.com/schema" }
+                }
+            },
+            {
+                drafts: [draft2020],
+                remotes: [
+                    { $id: "https://remote-a.com/schema", type: "string", default: "a" },
+                    { $id: "https://remote-b.com/schema", type: "number", default: 9 }
+                ]
+            }
+        );
+        const data = node.getData();
+        assert.deepEqual(data, { string: "a", number: 9 });
+    });
+});
+
 describe("compileSchema vocabulary", () => {
     it("should add remote schema on compile", () => {
         const remote = compileSchema({

package/src/compileSchema.ts

@@ -67,6 +67,10 @@ 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
      * the given meta-schema. Set to `false` to deactivate format validation.
@@ -94,6 +98,18 @@ function getDraft(drafts: Draft[], $schema: string) {
  * node will be reused for each task, but will create a compiledNode for bound data.
  */
 export function compileSchema(schema: JsonSchema | BooleanSchema, options: CompileOptions = {}) {
+    let remote = options.remote;
+    if (Array.isArray(options.remotes) && options.remotes.length > 0 && !options.remote) {
+        const remotes = [...options.remotes];
+        remotes.forEach((remote, index) => {
+            if (remote.$id == null) {
+                throw new Error(`required $id on remotes[${index}] is missing`);
+            }
+        });
+        remote = compileSchema(remotes.shift()!);
+        remotes.forEach((r) => remote?.addRemoteSchema(r.$id, r));
+    }
+
     let formatAssertion = options.formatAssertion ?? true;
     const drafts = options.drafts ?? defaultDrafts;
     const draft = getDraft(drafts, isJsonSchema(schema) ? (options.draft ?? schema.$schema) : undefined);
@@ -110,7 +126,7 @@ export function compileSchema(schema: JsonSchema | BooleanSchema, options: Compi
         context: {
             remotes: {},
             dynamicAnchors: {},
-            ...(options.remote?.context ?? {}),
+            ...(remote?.context ?? {}),
             anchors: {},
             refs: {},
             ...copy(pick(draft, "methods", "keywords", "version", "formats", "errors")),
@@ -125,7 +141,7 @@ export function compileSchema(schema: JsonSchema | BooleanSchema, options: Compi
     node.context.rootNode = node;
     node.context.remotes[(isJsonSchema(schema) ? schema.$id : undefined) ?? "#"] = node;
 
-    if (options.remote) {
+    if (remote) {
         const metaSchema = getRef(node, node.schema.$schema);
         if (isSchemaNode(metaSchema) && metaSchema.schema.$vocabulary) {
             const vocabs = Object.keys(metaSchema.schema.$vocabulary);

package/src/draftEditor.ts

@@ -4,6 +4,7 @@ import { oneOfFuzzyKeyword } from "./keywords/oneOf";
 import { render } from "./errors/render";
 
 /**
+ * @deprecated
  * @draft-editor https://json-schema.org/draft/2020-12/release-notes
  *
  * Uses Draft 2020-12 and changes resolveOneOf to be fuzzy

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

@@ -18,6 +18,8 @@ export default {
         "propertyDependencies"
     ],
     REGEX_FLAGS: "u",
+    /** additional keywords that should not produce an unknown-keyword-warning */
+    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
@@ -43,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"]
 };

package/src/validateSchema.test.ts

@@ -263,7 +263,7 @@ describe("validateSchema", () => {
             assert.equal(schemaAnnotations.length, 1);
             assert.equal(schemaAnnotations[0].data.pointer, "#/properties/headline/options");
         });
-        it("should return not unknown keywords starting with 'x-'", () => {
+        it("should not return unknown keywords starting with 'x-'", () => {
             const { schemaAnnotations } = compileSchema({
                 properties: {
                     headline: {
@@ -274,6 +274,15 @@ describe("validateSchema", () => {
             });
             assert.equal(schemaAnnotations.length, 0);
         });
+        it("should not return valid annotation keywords", () => {
+            const { schemaAnnotations } = compileSchema({
+                type: "string",
+                title: "input",
+                description: "any string",
+                default: "hey"
+            });
+            assert.equal(schemaAnnotations.length, 0);
+        });
         it("should return removed keywords from old drafts as annotation", () => {
             const { schemaAnnotations } = compileSchema({
                 properties: {