json-schema-library 11.0.4 → 11.1.0

package/src/keywords/required.ts

@@ -1,25 +1,48 @@
 import { isObject } from "../utils/isObject";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
 import { hasProperty } from "../utils/hasProperty";
+import { SchemaNode } from "../SchemaNode";
+import { isListOfStrings } from "../utils/isListOfStrings";
 
-export const requiredKeyword: Keyword = {
-    id: "required",
-    keyword: "required",
-    addValidate: ({ schema }) => Array.isArray(schema.required),
+const KEYWORD = "required";
+
+export const requiredKeyword: Keyword<"required"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseRequired,
+    addValidate: (node) => node.required != null,
     validate: validateRequired
 };
 
-function validateRequired({ node, data, pointer = "#" }: JsonSchemaValidatorParams) {
-    const { schema } = node;
+function parseRequired(node: SchemaNode) {
+    const required = node.schema[KEYWORD];
+    if (required == null) {
+        return;
+    }
+
+    if (!isListOfStrings(required)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: required,
+            message: `Keyword '${KEYWORD}' must be a string[]`
+        });
+    }
+
+    node.required = required;
+}
+
+function validateRequired({ node, data, pointer = "#" }: JsonSchemaValidatorParams<"required">) {
+    const { required } = node;
     if (!isObject(data)) {
         return undefined;
     }
-    return schema.required.map((property: string) => {
+    return required.map((property: string) => {
         if (!hasProperty(data, property)) {
             return node.createError("required-property-error", {
                 key: property,
                 pointer,
-                schema,
+                schema: node.schema,
                 value: data
             });
         }

package/src/keywords/type.ts

@@ -2,17 +2,58 @@ import { getTypeOf, JSType } from "../utils/getTypeOf";
 import { SchemaNode } from "../types";
 import { Keyword, JsonSchemaReducerParams, JsonSchemaValidatorParams } from "../Keyword";
 
-export const typeKeyword: Keyword = {
-    id: "type",
-    keyword: "type",
-    addReduce: (node) => Array.isArray(node.schema.type),
+const KEYWORD = "type";
+const validTyes = ["null", "boolean", "number", "integer", "string", "object", "array"];
+
+export const typeKeyword: Keyword<"type"> = {
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseType,
+    addReduce: (node) => Array.isArray(node.type),
     reduce: reduceType,
-    addValidate: ({ schema }) => schema.type != null,
+    addValidate: (node) => node.type != null,
     validate: validateType
 };
 
+function parseType(node: SchemaNode) {
+    const type = node.schema[KEYWORD];
+    if (type == null) {
+        return;
+    }
+    if (typeof type !== "string" && !Array.isArray(type)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: type,
+            message: `Keyword '${KEYWORD}' must be a string or a string[] - received ${typeof type}`
+        });
+    }
+    if (typeof type === "string" && !validTyes.includes(type)) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: type,
+            message: `Keyword '${KEYWORD}' is not a valid JSON Schema type - received '${type}'. Expected one of ${validTyes.join(", ")}`
+        });
+    }
+
+    if (Array.isArray(type)) {
+        const invalidTypeIndex = type.findIndex((t) => !validTyes.includes(t));
+        if (invalidTypeIndex !== -1) {
+            return node.createError("schema-error", {
+                pointer: `${node.schemaLocation}/${KEYWORD}/${invalidTypeIndex}`,
+                schema: node.schema,
+                value: type[invalidTypeIndex],
+                message: `Keyword '${KEYWORD}' contains an invalid JSON Schema type: '${type[invalidTypeIndex]}'`
+            });
+        }
+    }
+
+    node[KEYWORD] = type;
+}
+
 function reduceType({ node, pointer, data }: JsonSchemaReducerParams): undefined | SchemaNode {
-    const dataType = getJsonSchemaType(data, node.schema.type);
+    const dataType = getJsonSchemaType(data, node.type!);
     if (dataType !== "undefined" && Array.isArray(node.schema.type) && node.schema.type.includes(dataType)) {
         return node.compileSchema({ ...node.schema, pointer, type: dataType }, node.evaluationPath);
     }
@@ -30,22 +71,18 @@ function getJsonSchemaType(value: unknown, expectedType: string | string[]): JST
     return jsType;
 }
 
-function validateType({ node, data, pointer }: JsonSchemaValidatorParams) {
-    const schema = node.schema;
-    const dataType = getJsonSchemaType(data, schema.type);
-    if (
-        data === undefined ||
-        schema.type === dataType ||
-        (Array.isArray(schema.type) && schema.type.includes(dataType))
-    ) {
+function validateType({ node, data, pointer }: JsonSchemaValidatorParams<"type">) {
+    const type = node[KEYWORD];
+    const dataType = getJsonSchemaType(data, type);
+    if (data === undefined || type === dataType || (Array.isArray(type) && type.includes(dataType))) {
         return;
     }
 
     return node.createError("type-error", {
         value: data,
         received: dataType,
-        expected: schema.type,
-        schema,
+        expected: type,
+        schema: node.schema,
         pointer
     });
 }

package/src/keywords/unevaluatedItems.ts

@@ -1,31 +1,47 @@
-import { isObject } from "../utils/isObject";
-import { SchemaNode } from "../types";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { Keyword, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { validateNode } from "../validateNode";
 import { isItemEvaluated } from "../isItemEvaluated";
 
+const KEYWORD = "unevaluatedItems";
+
 /**
  * @draft >= 2019-09
  * Similar to additionalItems, but can "see" into subschemas and across references
  * https://json-schema.org/draft/2019-09/json-schema-core#rfc.section.9.3.1.3
  */
 export const unevaluatedItemsKeyword: Keyword = {
-    id: "unevaluatedItems",
-    keyword: "unevaluatedItems",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseUnevaluatedItems,
-    addValidate: ({ schema }) => schema.unevaluatedItems != null,
+    addValidate: ({ schema }) => schema.unevaluatedItems != null, // currently we do not store boolean schema
     validate: validateUnevaluatedItems
 };
 
 export function parseUnevaluatedItems(node: SchemaNode) {
-    if (!isObject(node.schema.unevaluatedItems)) {
+    const unevaluatedItems = node.schema[KEYWORD];
+    if (unevaluatedItems == null) {
+        return;
+    }
+    if (!(isJsonSchema(unevaluatedItems) || isBooleanSchema(unevaluatedItems))) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: unevaluatedItems,
+            message: `Keyword '${KEYWORD}' must be a valid JSON Schema - received '${typeof unevaluatedItems}'`
+        });
+    }
+
+    if (isBooleanSchema(unevaluatedItems)) {
         return;
     }
+
     node.unevaluatedItems = node.compileSchema(
         node.schema.unevaluatedItems,
-        `${node.evaluationPath}/unevaluatedItems`,
-        `${node.schemaLocation}/unevaluatedItems`
+        `${node.evaluationPath}/${KEYWORD}`,
+        `${node.schemaLocation}/${KEYWORD}`
     );
+    return node.unevaluatedItems.schemaValidation;
 }
 
 function validateUnevaluatedItems({ node, data, pointer, path }: JsonSchemaValidatorParams) {

package/src/keywords/unevaluatedProperties.ts

@@ -1,26 +1,43 @@
 import { isObject } from "../utils/isObject";
-import { SchemaNode } from "../types";
+import { isBooleanSchema, isJsonSchema, SchemaNode } from "../types";
 import { Keyword, JsonSchemaValidatorParams, ValidationReturnType } from "../Keyword";
 import { validateNode } from "../validateNode";
 import { isPropertyEvaluated } from "../isPropertyEvaluated";
 
+const KEYWORD = "unevaluatedProperties";
+
 export const unevaluatedPropertiesKeyword: Keyword = {
-    id: "unevaluatedProperties",
-    keyword: "unevaluatedProperties",
+    id: KEYWORD,
+    keyword: KEYWORD,
     parse: parseUnevaluatedProperties,
-    addValidate: ({ schema }) => schema.unevaluatedProperties != null,
+    addValidate: ({ schema }) => schema[KEYWORD] != null, // currently we do not store boolean schema
     validate: validateUnevaluatedProperties
 };
 
 export function parseUnevaluatedProperties(node: SchemaNode) {
-    if (!isObject(node.schema.unevaluatedProperties)) {
+    const unevaluatedProperties = node.schema[KEYWORD];
+    if (unevaluatedProperties == null) {
+        return;
+    }
+    if (!(isJsonSchema(unevaluatedProperties) || isBooleanSchema(unevaluatedProperties))) {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: unevaluatedProperties,
+            message: `Keyword '${KEYWORD}' must be a valid JSON Schema - received '${typeof unevaluatedProperties}'`
+        });
+    }
+
+    if (isBooleanSchema(unevaluatedProperties)) {
         return;
     }
+
     node.unevaluatedProperties = node.compileSchema(
         node.schema.unevaluatedProperties,
-        `${node.evaluationPath}/unevaluatedProperties`,
-        `${node.schemaLocation}/unevaluatedProperties`
+        `${node.evaluationPath}/${KEYWORD}`,
+        `${node.schemaLocation}/${KEYWORD}`
     );
+    return node.unevaluatedProperties.schemaValidation;
 }
 
 // @todo we should use collected annotation to evaluated unevaluate properties

package/src/keywords/uniqueItems.ts

@@ -1,14 +1,33 @@
-import { JsonError } from "../types";
+import { JsonError, SchemaNode } from "../types";
 import { Keyword, JsonSchemaValidatorParams } from "../Keyword";
 import deepEqual from "fast-deep-equal";
 
+const KEYWORD = "uniqueItems";
+
 export const uniqueItemsKeyword: Keyword = {
-    id: "uniqueItems",
-    keyword: "uniqueItems",
-    addValidate: ({ schema }) => schema.uniqueItems === true,
+    id: KEYWORD,
+    keyword: KEYWORD,
+    parse: parseUniqueItems,
+    addValidate: ({ schema }) => schema[KEYWORD] === true,
     validate: validateUniqueItems
 };
 
+function parseUniqueItems(node: SchemaNode) {
+    const uniqueItems = node.schema[KEYWORD];
+    if (uniqueItems == null || uniqueItems === false) {
+        return;
+    }
+    if (typeof uniqueItems !== "boolean") {
+        return node.createError("schema-error", {
+            pointer: `${node.schemaLocation}/${KEYWORD}`,
+            schema: node.schema,
+            value: uniqueItems,
+            message: `Keyword '${KEYWORD}' must be a boolean - received ${typeof uniqueItems}`
+        });
+    }
+    node.uniqueItems = true;
+}
+
 function validateUniqueItems({ node, data, pointer }: JsonSchemaValidatorParams) {
     if (!Array.isArray(data)) {
         return undefined;

package/src/mergeNode.ts

@@ -37,9 +37,12 @@ function mergeObjects(a?: Record<string, SchemaNode>, b?: Record<string, SchemaN
     return object;
 }
 
-// function mergeArray<T = unknown[]>(a?: T[], b?: T[]) {
-//     return a || b ? [...(a ?? []), ...(b ?? [])] : undefined;
-// }
+function combineArrays<T>(a?: T[], b?: T[]): T[] | undefined {
+    if (a == null || b == null) {
+        return b || a;
+    }
+    return a.concat(b).filter((value, index, list) => list.indexOf(value) === index);
+}
 
 function mergePatternProperties(a?: SchemaNode["patternProperties"], b?: SchemaNode["patternProperties"]) {
     if (a == null || b == null) {
@@ -92,6 +95,7 @@ export function mergeNode(a?: SchemaNode, b?: SchemaNode, ...omit: string[]): Sc
 
         additionalProperties: mergeNode(a.additionalProperties, b.additionalProperties),
         contains: mergeNode(a.contains, b.contains),
+        enum: combineArrays(a.enum, b.enum),
         if: mergeNode(a.if, b.if),
         then: mergeNode(a.then, b.then),
         else: mergeNode(a.else, b.else),
@@ -101,7 +105,8 @@ export function mergeNode(a?: SchemaNode, b?: SchemaNode, ...omit: string[]): Sc
         unevaluatedItems: mergeNode(a.unevaluatedItems, b.unevaluatedItems),
         $defs: mergeObjects(a.$defs, b.$defs),
         patternProperties: mergePatternProperties(a.patternProperties, b.patternProperties),
-        properties: mergeObjects(a.properties, b.properties)
+        properties: mergeObjects(a.properties, b.properties),
+        required: combineArrays(a.required, b.required)
     };
 
     // this removes any function that has no keyword associated on schema

package/src/settings.ts

@@ -14,7 +14,8 @@ export default {
         "dependentRequired",
         "definitions",
         "dependencies",
-        "patternProperties"
+        "patternProperties",
+        "propertyDependencies"
     ],
     REGEX_FLAGS: "u"
 };

package/src/types.ts

@@ -67,5 +67,5 @@ export function isJsonError(error: unknown): error is JsonError {
 }
 
 export function isNumber(value: unknown): value is number {
-    return isNaN(value as number) === false;
+    return typeof value === "number";
 }

package/src/utils/isListOfStrings.ts

@@ -0,0 +1,3 @@
+export function isListOfStrings(v: unknown): v is string[] {
+    return Array.isArray(v) && v.find((item) => typeof item !== "string") == null;
+}

package/src/validate.test.ts

@@ -8,7 +8,6 @@ describe("compileSchema : validate", () => {
     // note: boolean schema is already thoroughly tested by spec
     describe("boolean schema", () => {
         it("should fail if root schema is false", () => {
-            // @ts-expect-error boolean typ unsupported
             const { errors } = compileSchema(false).validate("anything");
             assert.deepEqual(errors.length, 1);
         });
@@ -23,7 +22,6 @@ describe("compileSchema : validate", () => {
             assert.deepEqual(errors.length, 1);
         });
         it("should succeed if root schema is true", () => {
-            // @ts-expect-error boolean typ unsupported
             const { errors } = compileSchema(true).validate("anything");
             assert.deepEqual(errors.length, 0);
         });

package/src/validateNode.ts

@@ -1,5 +1,5 @@
 import { BooleanSchema, JsonSchema, SchemaNode } from "./types";
-import { ValidationPath, ValidationReturnType } from "./Keyword";
+import { SchemaNodeWithRequired, ValidationPath, ValidationReturnType } from "./Keyword";
 import sanitizeErrors from "./utils/sanitizeErrors";
 
 export function validateNode(node: SchemaNode, data: unknown, pointer: string, path: ValidationPath) {
@@ -19,7 +19,7 @@ export function validateNode(node: SchemaNode, data: unknown, pointer: string, p
     }
     const errors: ValidationReturnType = [];
     for (const validate of node.validators) {
-        const result = validate({ node, data, pointer, path });
+        const result = validate({ node: node as SchemaNodeWithRequired<keyof SchemaNode>, data, pointer, path });
         if (Array.isArray(result)) {
             errors.push(...result);
         } else if (result) {