json-schema-library 11.4.1 → 11.5.0

package/package.json

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

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