json-schema-library 5.3.0 → 7.0.0

package/lib/schema/getTypeDefs.ts

@@ -4,28 +4,40 @@ import getTypeId from "./getTypeId";
 import types from "./types";
 import { JSONSchema, JSONPointer } from "../types";
 
+const isObject = (value: unknown) => Object.prototype.toString.call(value) === "[object Object]";
 
-const isObject = value => Object.prototype.toString.call(value) === "[object Object]";
-
+type TypeDef = { pointer: JSONPointer; def: unknown };
 
 /**
  * Returns a list of all (direct) type definitions from the given schema
  * @param schema
  * @return list of type definition, given as { pointer, def }
  */
-export default function getTypeDefs(schema: JSONSchema): Array<{ pointer: JSONPointer, def: any }> {
-    const defs = [];
+export default function getTypeDefs(schema: JSONSchema): TypeDef[] {
+    const defs: TypeDef[] = [];
     const id = getTypeId(schema);
     if (id == null) {
         return defs;
     }
-    const type = types[id];
+
+    let type;
+    if (Array.isArray(id)) {
+        // since types can also be declared as a set of types, merge the definitions
+        // maybe this will require a more sophisticated approach
+        type = {};
+        for (let i = 0, l = id.length; i < l; i += 1) {
+            Object.assign(type, types[id[i]]);
+        }
+    } else {
+        type = types[id];
+    }
+
     if (type.definitions == null) {
         return defs;
     }
 
-    type.definitions.forEach(query => {
-        get(schema, query, (value, key, parent, pointer) => {
+    type.definitions.forEach((query: string) => {
+        get(schema, query, (value: unknown, key, parent, pointer) => {
             if (isObject(value) && getTypeId(value)) {
                 defs.push({ pointer: gp.join(gp.split(pointer), false), def: value });
             }

package/lib/schema/getTypeId.ts

@@ -1,9 +1,9 @@
 import types from "./types";
 import { JSONSchema } from "../types";
 
-const isObject = value => Object.prototype.toString.call(value) === "[object Object]";
-const typeKeywords = Object.keys(types).filter(id => types[id].type === false);
-
+const isObject = (value: unknown) => Object.prototype.toString.call(value) === "[object Object]";
+const typeKeywords = Object.keys(types).filter((id) => types[id].type === false);
+const hasOwnProperty = Object.prototype.hasOwnProperty;
 
 /**
  * @throws Error    on multiple matches (invalid schema)
@@ -12,7 +12,7 @@ const typeKeywords = Object.keys(types).filter(id => types[id].type === false);
  * @param schema
  * @return type id, if found
  */
-export default function getTypeId(schema: JSONSchema): string|undefined {
+export default function getTypeId(schema: JSONSchema): string | string[] | undefined {
     if (isObject(schema) === false) {
         return undefined;
     }
@@ -21,11 +21,12 @@ export default function getTypeId(schema: JSONSchema): string|undefined {
         return "enum";
     }
 
-    if (types[schema.type]) {
+    // @ts-ignore
+    if (types[schema.type] || Array.isArray(schema.type)) {
         return schema.type;
     }
 
-    const ids = typeKeywords.filter(type => schema[type]);
+    const ids = typeKeywords.filter((type) => schema[type]);
 
     if (ids.length === 1) {
         return ids[0];
@@ -35,7 +36,8 @@ export default function getTypeId(schema: JSONSchema): string|undefined {
         // @expensive, guess type object
         for (let i = 0, l = types.object.keywords.length; i < l; i += 1) {
             const keyword = types.object.keywords[i];
-            if (schema.hasOwnProperty(keyword)) { // eslint-disable-line
+            if (hasOwnProperty.call(schema, keyword)) {
+                // eslint-disable-line
                 return "object";
             }
         }
@@ -43,7 +45,8 @@ export default function getTypeId(schema: JSONSchema): string|undefined {
         // @expensive, guess type array
         for (let i = 0, l = types.array.keywords.length; i < l; i += 1) {
             const keyword = types.array.keywords[i];
-            if (schema.hasOwnProperty(keyword)) { // eslint-disable-line
+            if (hasOwnProperty.call(schema, keyword)) {
+                // eslint-disable-line
                 return "array";
             }
         }

package/lib/schema/types.ts

@@ -1,4 +1,11 @@
-export default {
+export type Type = {
+    type: boolean;
+    definitions?: string[];
+    validationKeywords?: string[];
+    keywords?: string[];
+};
+
+const Types: Record<string, Type> = {
     $ref: {
         type: false
     },
@@ -13,14 +20,22 @@ export default {
     array: {
         type: true,
         // ignore additionalItems:TypeDef, when items:TypeDef
-        definitions: ["allOf/*", "anyOf/*", "oneOf/*", "not", "items", "items/*", "additionalItems"],
+        definitions: [
+            "allOf/*",
+            "anyOf/*",
+            "oneOf/*",
+            "not",
+            "items",
+            "items/*",
+            "additionalItems"
+        ],
         validationKeywords: ["minItems", "maxItems", "uniqueItems"],
         keywords: ["items", "additionalItems", "minItems", "maxItems", "uniqueItems"]
     },
-    "boolean": {
+    boolean: {
         type: true
     },
-    "enum": {
+    enum: {
         type: false
     },
     integer: {
@@ -37,7 +52,7 @@ export default {
         definitions: ["allOf/*", "anyOf/*", "oneOf/*", "not"],
         validationKeywords: ["minimum", "maximum", "multipleOf"]
     },
-    "null": {
+    null: {
         type: true
     },
     object: {
@@ -45,11 +60,26 @@ export default {
         // patternProperties also validate properties
         // dependencies:(string, TypeDef) extend current TypeDef
         // additional Properties validate only remaining properties (after properties & pattern)
-        definitions: ["allOf/*", "anyOf/*", "oneOf/*", "not",
-            "properties/*", "additionalProperties", "patternProperties/*", "dependencies/*"],
+        definitions: [
+            "allOf/*",
+            "anyOf/*",
+            "oneOf/*",
+            "not",
+            "properties/*",
+            "additionalProperties",
+            "patternProperties/*",
+            "dependencies/*"
+        ],
         validationKeywords: ["minProperties", "maxProperties", "required"],
-        keywords: ["properties", "additionalProperties", "patternProperties", "dependencies", "minProperties",
-            "maxProperties", "required"]
+        keywords: [
+            "properties",
+            "additionalProperties",
+            "patternProperties",
+            "dependencies",
+            "minProperties",
+            "maxProperties",
+            "required"
+        ]
     },
     oneOf: {
         type: false,
@@ -61,3 +91,5 @@ export default {
         validationKeywords: ["minLength", "maxLength", "pattern"]
     }
 };
+
+export default Types;

package/lib/step.ts

@@ -2,13 +2,17 @@ import getTypeOf from "./getTypeOf";
 import createSchemaOf from "./createSchemaOf";
 import errors from "./validation/errors";
 import merge from "./utils/merge";
-import { JSONSchema, JSONPointer, JSONError } from "./types";
-import Core from "./cores/CoreInterface";
-
+import { JSONSchema, JSONPointer, JSONError, isJSONError } from "./types";
+import { Draft as Core } from "./draft";
 
 const stepType = {
-
-    array: (core: Core, key: string|number, schema: JSONSchema, data: any, pointer: JSONPointer): JSONSchema|JSONError => {
+    array: (
+        core: Core,
+        key: string,
+        schema: JSONSchema,
+        data: any,
+        pointer: JSONPointer
+    ): JSONSchema | JSONError => {
         const itemsType = getTypeOf(schema.items);
 
         if (itemsType === "object") {
@@ -33,12 +37,29 @@ const stepType = {
         }
 
         if (itemsType === "array") {
+            // @draft >= 7 bool schema, items:[true, false]
+            if (schema.items[key] === true) {
+                return createSchemaOf(data[key]);
+            }
+            // @draft >= 7 bool schema, items:[true, false]
+            if (schema.items[key] === false) {
+                return errors.invalidDataError({
+                    key,
+                    value: data[key],
+                    pointer
+                });
+            }
+
             if (schema.items[key]) {
                 return core.resolveRef(schema.items[key]);
             }
 
             if (schema.additionalItems === false) {
-                return errors.additionalItemsError({ key, value: data[key], pointer });
+                return errors.additionalItemsError({
+                    key,
+                    value: data[key],
+                    pointer
+                });
             }
 
             if (schema.additionalItems === true || schema.additionalItems === undefined) {
@@ -49,7 +70,13 @@ const stepType = {
                 return schema.additionalItems;
             }
 
-            throw new Error(`Invalid schema ${JSON.stringify(schema, null, 4)} for ${JSON.stringify(data, null, 4)}`);
+            throw new Error(
+                `Invalid schema ${JSON.stringify(schema, null, 4)} for ${JSON.stringify(
+                    data,
+                    null,
+                    4
+                )}`
+            );
         }
 
         if (schema.additionalItems !== false && data[key]) {
@@ -61,14 +88,19 @@ const stepType = {
         return new Error(`Invalid array schema for ${key} at ${pointer}`) as JSONError;
     },
 
-    object: (core: Core, key: string|number, schema: JSONSchema, data: any, pointer: JSONPointer): JSONSchema|JSONError => {
-
+    object: (
+        core: Core,
+        key: string,
+        schema: JSONSchema,
+        data: any,
+        pointer: JSONPointer
+    ): JSONSchema | JSONError => {
         if (Array.isArray(schema.oneOf)) {
             // update current schema
             const oneOfSchema = core.resolveOneOf(data, schema, pointer);
             // resolveOneOf does currently not apply merge with base schema
             schema = merge(schema, oneOfSchema);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
@@ -76,7 +108,7 @@ const stepType = {
         if (Array.isArray(schema.anyOf)) {
             // update current schema
             schema = core.resolveAnyOf(data, schema, pointer);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
@@ -84,7 +116,7 @@ const stepType = {
         if (Array.isArray(schema.allOf)) {
             // update current schema
             schema = core.resolveAllOf(data, schema, pointer);
-            if (schema && schema.type === "error") {
+            if (isJSONError(schema)) {
                 return schema;
             }
         }
@@ -96,7 +128,7 @@ const stepType = {
             // @todo patternProperties also validate properties
 
             targetSchema = core.resolveRef(schema.properties[key]);
-            if (targetSchema && targetSchema.type === "error") {
+            if (isJSONError(targetSchema)) {
                 return targetSchema;
             }
 
@@ -104,9 +136,17 @@ const stepType = {
             if (targetSchema && Array.isArray(targetSchema.oneOf)) {
                 // @special case: this is a mix of a schema and optional definitions
                 // we resolve the schema here and add the original schema to `oneOfSchema`
-                let resolvedSchema = core.resolveOneOf(data[key], targetSchema, `${pointer}/${key}`);
+                let resolvedSchema = core.resolveOneOf(
+                    data[key],
+                    targetSchema,
+                    `${pointer}/${key}`
+                );
+
+                const oneOfIndex = targetSchema.oneOf.findIndex((s) => s === resolvedSchema);
+
                 resolvedSchema = JSON.parse(JSON.stringify(resolvedSchema));
                 resolvedSchema.variableSchema = true;
+                resolvedSchema.oneOfIndex = oneOfIndex;
                 resolvedSchema.oneOfSchema = targetSchema;
                 return resolvedSchema;
             }
@@ -117,6 +157,24 @@ const stepType = {
             }
         }
 
+        // @draft <= 07
+        const { dependencies } = schema;
+        if (getTypeOf(dependencies) === "object") {
+            const dependentProperties = Object.keys(dependencies).filter(
+                (propertyName) =>
+                    // data[propertyName] !== undefined &&
+                    getTypeOf(dependencies[propertyName]) === "object"
+            );
+
+            for (let i = 0, l = dependentProperties.length; i < l; i += 1) {
+                const dependentProperty = dependentProperties[i];
+                const schema = step(core, key, dependencies[dependentProperty], data);
+                if (!isJSONError(schema)) {
+                    return schema;
+                }
+            }
+        }
+
         // find matching property key
         if (getTypeOf(schema.patternProperties) === "object") {
             let regex;
@@ -134,14 +192,18 @@ const stepType = {
         }
 
         if (schema.additionalProperties === true) {
-            return createSchemaOf(data);
+            return createSchemaOf(data[key]);
         }
 
-        return errors.unknownPropertyError({ property: key, value: data, pointer });
+        return errors.unknownPropertyError({
+            property: key,
+            value: data,
+            // pointer: `${pointer}/${key}`,
+            pointer: `${pointer}`
+        });
     }
 };
 
-
 /**
  * Returns the json-schema of the given object property or array item.
  * e.g. it steps by one key into the data
@@ -149,18 +211,40 @@ const stepType = {
  *  This helper determines the location of the property within the schema (additional properties, oneOf, ...) and
  *  returns the correct schema.
  *
- * @param  core     - validator
- * @param  key      - property-name or array-index
- * @param  schema          - json schema of current data
+ * @param  core      - validator
+ * @param  key       - property-name or array-index
+ * @param  schema    - json schema of current data
  * @param  data      - parent of key
- * @param  [pointer]
+ * @param  [pointer] - pointer to schema and data (parent of key)
  * @return Schema or Error if failed resolving key
  */
-export default function step(core: Core, key: string|number, schema: JSONSchema, data?: any, pointer: JSONPointer = "#"):
-JSONSchema|JSONError {
+export default function step(
+    core: Core,
+    key: string | number,
+    schema: JSONSchema,
+    data?: any,
+    pointer: JSONPointer = "#"
+): JSONSchema | JSONError {
+    // @draft >= 4 ?
+    if (Array.isArray(schema.type)) {
+        const dataType = getTypeOf(data);
+        if (schema.type.includes(dataType)) {
+            // @ts-ignore
+            return stepType[dataType](core, `${key}`, schema, data, pointer);
+        }
+        return core.errors.typeError({
+            value: data,
+            pointer,
+            expected: schema.type,
+            received: dataType
+        });
+    }
+
     const expectedType = schema.type || getTypeOf(data);
-    if (stepType[expectedType]) {
-        return stepType[expectedType](core, key, schema, data, pointer);
+    // @ts-ignore
+    const stepFunction = stepType[expectedType];
+    if (stepFunction) {
+        return stepFunction(core, `${key}`, schema, data, pointer);
     }
     return new Error(`Unsupported schema type ${schema.type} for key ${key}`) as JSONError;
 }

package/lib/types.ts

@@ -1,19 +1,37 @@
-import Core from "./cores/CoreInterface";
+import { Draft as Core } from "./draft";
 
-
-export type JSONSchema = { [p:string]: any };
+export type JSONSchema = { [p: string]: any };
 
 export type JSONPointer = string;
 
 export type JSONError = {
-    type: "error"|"string";
+    type: "error";
     name: string;
     code: string;
     message: string;
     data?: { [p: string]: any };
     [p: string]: any;
+};
+
+/**
+ * ts type guard for json error
+ * @returns true if passed type is a JSONError
+ */
+export function isJSONError(error: any): error is JSONError {
+    return error?.type === "error";
 }
 
 export interface JSONValidator {
-    (core: Core, schema: JSONSchema, value: any, pointer: JSONPointer): void|undefined|JSONError|Array<JSONError>;
+    (core: Core, schema: JSONSchema, value: unknown, pointer: JSONPointer):
+        | void
+        | undefined
+        | JSONError
+        | JSONError[]
+        | JSONError[][];
+}
+
+export interface JSONTypeValidator {
+    (core: Core, schema: JSONSchema, value: unknown, pointer: JSONPointer): Array<
+        void | undefined | JSONError | JSONError[] | JSONError[][]
+    >;
 }

package/lib/utils/createCustomError.ts

@@ -1,18 +1,14 @@
 import __ from "./__";
-import { JSONError } from "../types";
+import { JSONError, JSONPointer } from "../types";
 
+export type ErrorData = { pointer: JSONPointer } & Record<string, unknown>;
+export type CreateError = (data: ErrorData) => JSONError;
 
-export interface CreateError {
-    (data?: { [p : string]: any }): JSONError
+function dashCase(text: string): string {
+    return text.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 }
 
-
-function dashCase(str: string): string {
-    return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-}
-
-
-export function createError(name: string, data?: { [p : string]: any }): JSONError {
+export function createError(name: string, data: ErrorData): JSONError {
     return {
         type: "error",
         name,
@@ -22,14 +18,13 @@ export function createError(name: string, data?: { [p : string]: any }): JSONErr
     };
 }
 
-
 /**
  * Creates a custom Error-Constructor which instances may be identified by `customError instanceof Error`. Its messages
- * are defined by strings-object __@see config/strings.ts
+ * are defined by strings-object @see config/strings.ts
  *
  * @param name - id of error (camelcased)
  * @return error constructor function
  */
-export default function createCustomError(name: string): CreateError {
+export function createCustomError(name: string): CreateError {
     return createError.bind(null, name);
 }

package/lib/utils/filter.ts

@@ -1,15 +1,13 @@
-export function isPromise(obj) {
-    return obj instanceof Promise;
-}
+import { isJSONError, JSONError } from "../types";
 
-export function isError(obj) {
-    return obj && obj.type === "error";
+export function isPromise(obj: unknown): obj is Promise<unknown> {
+    return obj instanceof Promise;
 }
 
-export function errorOrPromise(error) {
-    return isError(error) || isPromise(error);
+export function errorOrPromise(error: unknown): error is JSONError | Promise<unknown> {
+    return isJSONError(error) || isPromise(error);
 }
 
-export function errorsOnly(error) {
-    return isError(error);
+export function errorsOnly(error: unknown): error is JSONError {
+    return isJSONError(error);
 }

package/lib/utils/flattenArray.ts

@@ -1,9 +1,10 @@
-export default function flattenArray<T = any>(list: Array<any>, result = []): Array<T> {
+export default function flattenArray<T = unknown>(list: unknown[], result: T[] = []): T[] {
     for (let i = 0; i < list.length; i += 1) {
-        if (Array.isArray(list[i])) {
-            flattenArray(list[i], result);
+        const item = list[i];
+        if (Array.isArray(item)) {
+            flattenArray(item, result);
         } else {
-            result.push(list[i]);
+            result.push(item as T);
         }
     }
     return result;

package/lib/utils/merge.ts

@@ -1,3 +1,8 @@
 import deepmerge from "deepmerge";
+// @ts-ignore
 const overwriteMerge = (destinationArray, sourceArray) => sourceArray;
+
+/**
+ * returns a new json-schema, where properties are combined and arrays are replaced
+ */
 export default <T, K>(a: T, b: K): T & K => deepmerge(a, b, { arrayMerge: overwriteMerge });

package/lib/utils/punycode.ucs2decode.ts

@@ -15,18 +15,19 @@
  * @param string The Unicode input string (UCS-2).
  * @returns The new array of code points.
  */
-export default function ucs2decode(string: string): Array<string> {
+export default function ucs2decode(string: string): string[] {
     const output = [];
     let counter = 0;
     const length = string.length;
     while (counter < length) {
         const value = string.charCodeAt(counter++);
-        if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+        if (value >= 0xd800 && value <= 0xdbff && counter < length) {
             // It's a high surrogate, and there is a next character.
             const extra = string.charCodeAt(counter++);
             // eslint-disable-next-line eqeqeq
-            if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.
-                output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+            if ((extra & 0xfc00) == 0xdc00) {
+                // Low surrogate.
+                output.push(((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000);
             } else {
                 // It's an unmatched surrogate; only append this code unit, in case the
                 // next code unit is the high surrogate of a surrogate pair.
@@ -37,5 +38,5 @@ export default function ucs2decode(string: string): Array<string> {
             output.push(value);
         }
     }
-    return output;
+    return output as unknown as string[];
 }