json-schema-library 11.4.0 → 11.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.4.0",
+  "version": "11.5.0",
   "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
   "types": "./dist/index.d.cts",
   "exports": {
@@ -18,6 +18,16 @@
     },
     "./package.json": "./package.json"
   },
+  "typesVersions": {
+    "*": {
+      "formats": [
+        "./dist/formats.d.cts"
+      ],
+      "remotes": [
+        "./dist/remotes.d.cts"
+      ]
+    }
+  },
   "scripts": {
     "coverage": "nyc npm run test --reporter=lcov",
     "dist": "tsdown -f esm -f cjs --minify --report --attw --unused; pnpm run dist:iife;",

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,7 @@ export type CompileOptions = {
      * Set node and its remote schemata as remote schemata for this node and schema to resolve $ref
      */
     remote?: SchemaNode;
+    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 +95,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 +123,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 +138,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/type.test.ts

@@ -20,3 +20,16 @@ describe("keyword : type : validation", () => {
         });
     });
 });
+
+describe("keyword : type : reduce", () => {
+    it("should reduce array-type to the last matching data-type", () => {
+        const { node } = compileSchema({ type: ["null", "integer"] }).reduceNode(123);
+        assert.equal(node?.type, "integer");
+        assert.equal(node?.schema.type, "integer");
+    });
+    it("should reduce array-type to the first matching data-type", () => {
+        const { node } = compileSchema({ type: ["null", "integer"] }).reduceNode(null);
+        assert.equal(node?.type, "null");
+        assert.equal(node?.schema.type, "null");
+    });
+});

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: ["title", "description", "default"],
     /**
      * properties to keep from a $ref-schema when resolving a $ref (recursively)
      * this allows to overwrite specified properties locally on a $ref-definition

package/src/utils/mergeSchema.test.ts

@@ -78,4 +78,41 @@ describe("mergeSchema", () => {
         );
         assert.deepEqual(schema.items.anyOf, [{ type: "string" }, { type: "number" }]);
     });
+
+    describe("type", () => {
+        it("should return last type if they conflict", () => {
+            const schema = mergeSchema({ type: "array" }, { type: "integer" });
+            assert.deepEqual(schema.type, "integer");
+        });
+
+        it("should not merge mixed data types with string first", () => {
+            const schema = mergeSchema({ type: "array" }, { type: ["array", "object"] });
+            assert.deepEqual(schema.type, "array");
+        });
+
+        it("should not merge mixed data types with string second", () => {
+            const schema = mergeSchema({ type: ["array", "object"] }, { type: "array" });
+            assert.deepEqual(schema.type, "array");
+        });
+
+        it("should  merge mixed data types if they have no type in common", () => {
+            const schema = mergeSchema({ type: ["array", "object"] }, { type: "integer" });
+            assert.deepEqual(schema.type, ["array", "object", "integer"]);
+        });
+
+        it("should merge return last type if they do not match", () => {
+            const schema = mergeSchema({ type: "object" }, { type: "array" });
+            assert.deepEqual(schema.type, "array");
+        });
+
+        it("should merge array types", () => {
+            const schema = mergeSchema({ type: ["object"] }, { type: ["array"] });
+            assert.deepEqual(schema.type, ["object", "array"]);
+        });
+
+        it("should merge array types without duplicated", () => {
+            const schema = mergeSchema({ type: ["integer", "object"] }, { type: ["object", "array"] });
+            assert.deepEqual(schema.type, ["integer", "object", "array"]);
+        });
+    });
 });

package/src/utils/mergeSchema.ts

@@ -32,7 +32,10 @@ export function mergeSchema2(a: unknown, b: unknown, property?: string): unknown
         return newObject;
     }
 
-    if (Array.isArray(a) && Array.isArray(b)) {
+    const aIsArray = Array.isArray(a);
+    const bIsArray = Array.isArray(b);
+
+    if (aIsArray && bIsArray) {
         if (property === "required" || property === "anyOf") {
             return a.concat(b).filter((item, index, array) => array.indexOf(item) === index);
         }
@@ -66,11 +69,29 @@ export function mergeSchema2(a: unknown, b: unknown, property?: string): unknown
         return [...result, ...append].filter((item, index, array) => array.indexOf(item) === index);
     }
 
-    if (Array.isArray(b)) {
+    // mixed data-type for type keyword
+    if (property === "type" && (aIsArray || bIsArray)) {
+        // we merge to the specific type
+        if (aIsArray && a.includes(b)) {
+            return b;
+        }
+        if (bIsArray && b.includes(a)) {
+            return a;
+        }
+        // extend the types if they do not match
+        if (aIsArray) {
+            return [...a, b];
+        }
+        if (bIsArray) {
+            return [...b, a];
+        }
+    }
+
+    if (bIsArray) {
         return b;
     }
 
-    if (Array.isArray(a)) {
+    if (aIsArray) {
         return a;
     }
 

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: {