json-schema-library 11.2.0 → 11.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-schema-library",
-  "version": "11.2.0",
+  "version": "11.3.0",
   "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -39,7 +39,7 @@
     "test:7:ci": "DISABLE_LOG=true mocha -R json 'src/tests/spec/draft07.spec.ts' > test-result-spec7.json; exit 0",
     "test:inspect": "NODE_OPTIONS='--inspect-brk' mocha 'src/**/*.test.ts'",
     "test:spec": "mocha 'src/tests/spec/*.spec.ts'",
-    "test:unit": "mocha 'src/**/*.test.ts' 'bowtie/**/*.test.ts'",
+    "test:unit": "mocha 'src/**/*.test.ts' 'bowtie/*.test.ts'",
     "test:unit:ci": "DISABLE_LOG=true mocha -R json 'src/**/*.test.ts' -R json > test-result-unit.json; exit 0"
   },
   "repository": {

package/src/compileSchema.test.ts

@@ -2,6 +2,9 @@ import { compileSchema } from "./compileSchema";
 import { strict as assert } from "assert";
 import { draftEditor } from "./draftEditor";
 import { SchemaNode } from "./SchemaNode";
+import { draft04 } from "./draft04";
+import { draft07 } from "./draft07";
+import { draft2020 } from "./draft2020";
 
 describe("compileSchema vocabulary", () => {
     let root: SchemaNode;
@@ -33,6 +36,54 @@ describe("compileSchema vocabulary", () => {
     });
 });
 
+describe("compileSchema draft-version", () => {
+    it("should select last draft", () => {
+        const node = compileSchema({}, { drafts: [draft04, draft07, draft2020] });
+        assert(node.getDraftVersion(), "draft-2020");
+    });
+
+    it("should select draft specified by $schema", () => {
+        const node = compileSchema(
+            { $schema: "http://json-schema.org/draft-07/schema#" },
+            { drafts: [draft04, draft07, draft2020] }
+        );
+        assert(node.getDraftVersion(), "draft-07");
+    });
+
+    it("should select fallback draft specified by `draft`", () => {
+        const node = compileSchema(
+            {},
+            {
+                draft: "http://json-schema.org/draft-07/schema#",
+                drafts: [draft04, draft07, draft2020]
+            }
+        );
+        assert(node.getDraftVersion(), "draft-07");
+    });
+
+    it("should prefer `$schema` over `draft` options", () => {
+        const node = compileSchema(
+            { $schema: "http://json-schema.org/draft-04/schema#" },
+            {
+                draft: "http://json-schema.org/draft-07/schema#",
+                drafts: [draft04, draft07, draft2020]
+            }
+        );
+        assert(node.getDraftVersion(), "draft-04");
+    });
+
+    it("should always fallback to last draft if nothing matches", () => {
+        const node = compileSchema(
+            { $schema: "http://json-schema.org/draft-A/schema#" },
+            {
+                draft: "http://json-schema.org/draft-B/schema#",
+                drafts: [draft04, draft07, draft2020]
+            }
+        );
+        assert(node.getDraftVersion(), "draft-2020");
+    });
+});
+
 describe("compileSchema vocabulary", () => {
     it("should add remote schema on compile", () => {
         const remote = compileSchema({
@@ -150,6 +201,7 @@ describe("compileSchema `schemaLocation`", () => {
             $defs: { asset: { type: "string" } }
         });
 
+        assert(node.if && node.then && node.properties && node.$defs);
         assert.deepEqual(node.schemaLocation, "#");
         assert.deepEqual(node.if.schemaLocation, "#/if");
         assert.deepEqual(node.then.schemaLocation, "#/then");

package/src/compileSchema.ts

@@ -25,15 +25,62 @@ import sanitizeErrors from "./utils/sanitizeErrors";
 const { REGEX_FLAGS } = settings;
 
 export type CompileOptions = {
+    /**
+     * List of drafts to support.
+     *
+     * Drafts are selected by testing the passed `schema.$schema` for a matching id, which
+     * is tested by each draft's `Draft.$schemaRegEx`. In case no draft matches `schema.$schema`
+     * the last draft in the list will be used.
+     *
+     * @default [draft04, draft06, draft07, draft2019, draft2020]
+     *
+     * @example
+     * import { draft04, draft07, draft2020 } from "json-schema-library"
+     * compileSchema({ $schema: "draft-04" }, { drafts: [draft04, draft07, draft2020] })
+     */
     drafts?: Draft[];
+    /**
+     * Fallback _draft_ version in case no _draft_ is specified by `schema.$schema`.
+     *
+     * Drafts are selected by given `schema.$schema` or the last draft from `drafts` as a fallback.
+     * Specifying `draft` will workthe same as a specifying `schema.$schema` in case no $schema is
+     * defined. When no match can be found, the last _draft_ from `drafts` will be used.
+     *
+     * @example
+     * // uses draft-04
+     * compileSchema({ $schema: "draft-04" }, { drafts: [draft04, draft07, draft2020] })
+     *
+     * // uses draft-2020-12
+     * compileSchema({}, { drafts: [draft04, draft07, draft2020] })
+     *
+     * // uses draft-07
+     * compileSchema({}, { draft: "draft-07", drafts: [draft04, draft07, draft2020] })
+
+     * // uses draft-04
+     * compileSchema({ $schema: "draft-04" }, { draft: "draft-07", drafts: [draft04, draft07, draft2020] })
+     *
+     * // uses draft-2020
+     * compileSchema({ $schema: "draft-04" }, { draft: "draft-07", drafts: [draft2020] })
+     */
+    draft?: string;
+    /**
+     * Set node and its remote schemata as remote schemata for this node and schema to resolve $ref
+     */
     remote?: SchemaNode;
+    /**
+     * 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.
+     *
+     * @default true
+     */
     formatAssertion?: boolean | "meta-schema" | undefined;
+    /** Set default options for all `node.getData` requests */
     getDataDefaultOptions?: TemplateOptions;
-    /** set to true to throw an Error on errors in input schema. Defaults to false */
+    /** Set to true to throw an Error on errors in input schema. Defaults to false */
     throwOnInvalidSchema?: boolean;
-    /** set to true to collect unknown keywords of input schema in `node.schemaAnnotations`. Defaults to false */
+    /** Set to true to collect unknown keywords of input schema in `node.schemaAnnotations`. Defaults to false */
     withSchemaAnnotations?: boolean;
-    /** set to true to throw an Error when encountering an unresolvable ref  */
+    /** Set to true to throw an Error when encountering an unresolvable ref  */
     throwOnInvalidRef?: boolean;
 };
 
@@ -51,7 +98,7 @@ function getDraft(drafts: Draft[], $schema: string) {
 export function compileSchema(schema: JsonSchema | BooleanSchema, options: CompileOptions = {}) {
     let formatAssertion = options.formatAssertion ?? true;
     const drafts = options.drafts ?? defaultDrafts;
-    const draft = getDraft(drafts, isJsonSchema(schema) ? schema.$schema : undefined);
+    const draft = getDraft(drafts, isJsonSchema(schema) ? (options.draft ?? schema.$schema) : undefined);
     const node: SchemaNode & { schemaErrors?: JsonError[]; schemaAnnotations: JsonAnnotation[] } = {
         evaluationPath: "#",
         lastIdPointer: "#",

package/src/draft04.ts

@@ -61,8 +61,8 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft04 = sanitizeKeywords({
     version: "draft-04",
-    $schemaRegEx: "draft-04",
-    $schema: "http://json-schema.org/draft-04/schema",
+    $schemaRegEx: "draft-?0?4",
+    $schema: "http://json-schema.org/draft-04/schema#",
     errors,
     formats,
     methods: {

package/src/draft06.ts

@@ -62,8 +62,8 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft06 = sanitizeKeywords({
     version: "draft-06",
-    $schemaRegEx: "draft-06",
-    $schema: "http://json-schema.org/draft-06/schema",
+    $schemaRegEx: "draft-?0?6",
+    $schema: "http://json-schema.org/draft-06/schema#",
     errors,
     formats,
     methods: {

package/src/draft07.ts

@@ -53,8 +53,8 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft07 = sanitizeKeywords({
     version: "draft-07",
-    $schemaRegEx: "draft-07",
-    $schema: "http://json-schema.org/draft-07/schema",
+    $schemaRegEx: "draft-?0?7",
+    $schema: "http://json-schema.org/draft-07/schema#",
     errors,
     formats,
     methods: {

package/src/draft2019-09/keywords/$ref.ts

@@ -1,12 +1,10 @@
 import { Keyword, JsonSchemaValidatorParams, ValidationPath } from "../../Keyword";
 import { resolveUri } from "../../utils/resolveUri";
 import splitRef from "../../utils/splitRef";
-import { omit } from "../../utils/omit";
-import { isObject } from "../../utils/isObject";
 import { validateNode } from "../../validateNode";
 import { isSchemaNode, JsonError, SchemaNode } from "../../types";
 import { get, split } from "@sagold/json-pointer";
-import { reduceRef } from "../../keywords/$ref";
+import { reduceRef, compileNext } from "../../keywords/$ref";
 
 export const $refKeyword: Keyword = {
     id: "$ref",
@@ -132,14 +130,6 @@ function resolveRecursiveRef(node: SchemaNode, path: ValidationPath): SchemaNode
     return nextNode;
 }
 
-function compileNext(referencedNode: SchemaNode, evaluationPath = referencedNode.evaluationPath) {
-    const referencedSchema = isObject(referencedNode.schema)
-        ? omit(referencedNode.schema, "$id")
-        : referencedNode.schema;
-
-    return referencedNode.compileSchema(referencedSchema, `${evaluationPath}/$ref`, referencedNode.schemaLocation);
-}
-
 export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode | JsonError {
     if ($ref == null) {
         return node;
@@ -147,11 +137,11 @@ export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode
 
     // resolve $ref by json-evaluationPath
     if (node.context.refs[$ref]) {
-        return compileNext(node.context.refs[$ref], node.evaluationPath);
+        return compileNext(node.context.refs[$ref], node);
     }
     // resolve $ref from $anchor
     if (node.context.anchors[$ref]) {
-        return compileNext(node.context.anchors[$ref], node.evaluationPath);
+        return compileNext(node.context.anchors[$ref], node);
     }
 
     // check for remote-host + pointer pair to switch rootSchema
@@ -171,7 +161,7 @@ export default function getRef(node: SchemaNode, $ref = node?.$ref): SchemaNode
         const $ref = fragments[0];
         // this is a reference to remote-host root node
         if (node.context.remotes[$ref]) {
-            return compileNext(node.context.remotes[$ref], node.evaluationPath);
+            return compileNext(node.context.remotes[$ref], node);
         }
         if ($ref[0] === "#") {
             // @todo there is a bug joining multiple fragments to e.g. #/base#/examples/0

package/src/draft2019.ts

@@ -60,7 +60,7 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft2019 = sanitizeKeywords({
     version: "draft-2019-09",
-    $schemaRegEx: "draft[/-]2019-09",
+    $schemaRegEx: "draft[/-]2019-?(09)?",
     $schema: "https://json-schema.org/draft/2019-09/schema",
     errors,
     formats,

package/src/draft2020.ts

@@ -70,7 +70,7 @@ import { uniqueItemsKeyword } from "./keywords/uniqueItems";
  */
 export const draft2020 = sanitizeKeywords({
     version: "draft-2020-12",
-    $schemaRegEx: "draft[/-]2020-12",
+    $schemaRegEx: "draft[/-]2020-?(12)?",
     $schema: "https://json-schema.org/draft/2020-12/schema",
     errors,
     formats,

package/src/keywords/$ref.ts

@@ -8,6 +8,7 @@ import { validateNode } from "../validateNode";
 import { get, split } from "@sagold/json-pointer";
 import { mergeNode } from "../mergeNode";
 import { pick } from "../utils/pick";
+import settings from "src/settings";
 
 export const $refKeyword: Keyword = {
     id: "$ref",
@@ -177,14 +178,12 @@ function resolveRecursiveRef(node: SchemaNode, path: ValidationPath): SchemaNode
     return getRef(node, refInCurrentScope);
 }
 
-const PROPERTIES_TO_MERGE = ["title", "description", "options", "readOnly", "writeOnly"];
-
-function compileNext(referencedNode: SchemaNode, sourceNode: SchemaNode) {
+export function compileNext(referencedNode: SchemaNode, sourceNode: SchemaNode) {
     let referencedSchema = referencedNode.schema;
     if (isObject(referencedNode.schema)) {
         referencedSchema = {
             ...omit(referencedNode.schema, "$id"),
-            ...pick(sourceNode.schema, ...PROPERTIES_TO_MERGE)
+            ...pick(sourceNode.schema, ...settings.PROPERTIES_TO_MERGE)
         };
     }
     return referencedNode.compileSchema(

package/src/keywords/oneOf.test.ts

@@ -483,7 +483,7 @@ describe("keyword : oneof-fuzzy : validate", () => {
                         required: ["type", "children"],
                         properties: {
                             type: {
-                                options: { hidden: true },
+                                "x-options": { hidden: true },
                                 type: "string",
                                 const: "parent"
                             },
@@ -500,7 +500,7 @@ describe("keyword : oneof-fuzzy : validate", () => {
                                             required: ["type"],
                                             properties: {
                                                 type: {
-                                                    options: { hidden: true },
+                                                    "x-options": { hidden: true },
                                                     type: "string",
                                                     const: "one"
                                                 }
@@ -512,7 +512,7 @@ describe("keyword : oneof-fuzzy : validate", () => {
                                             required: ["type"],
                                             properties: {
                                                 type: {
-                                                    options: { hidden: true },
+                                                    "x-options": { hidden: true },
                                                     type: "string",
                                                     const: "two"
                                                 }

package/src/settings.ts

@@ -17,5 +17,31 @@ export default {
         "patternProperties",
         "propertyDependencies"
     ],
-    REGEX_FLAGS: "u"
+    REGEX_FLAGS: "u",
+    /**
+     * properties to keep from a $ref-schema when resolving a $ref (recursively)
+     * this allows to overwrite specified properties locally on a $ref-definition
+     *
+     * - draft 2019-09
+     * - draft 2020-12
+     *
+     * @example
+     * {
+     *   title: "custom component",
+     *   $ref: "#/$defs/component",
+     *
+     *   $defs: {
+     *     component: {
+     *       title: "component",
+     *       type: "object"
+     *     }
+     *   }
+     * }
+     * // results in
+     * {
+     *   title: "custom component"
+     *   type: "object"
+     * }
+     */
+    PROPERTIES_TO_MERGE: ["title", "description", "options", "x-options", "readOnly", "writeOnly"]
 };