ejv 1.1.10 → 2.0.0

package/src/ejv.ts

@@ -1,5 +1,17 @@
-import { EjvError, InternalOptions, Options, Scheme } from './interfaces';
-import { DataType, ErrorMsg, ErrorMsgCursorA, ErrorType, NumberFormat, StringFormat } from './constants';
+import {
+	AllDataType,
+	AnyObject,
+	ArrayScheme,
+	DateScheme,
+	EjvError,
+	InternalOptions,
+	NumberScheme,
+	ObjectScheme,
+	Options,
+	Scheme,
+	StringScheme
+} from './interfaces';
+import { DataType, ErrorMsg, ErrorType, NumberFormat, StringFormat } from './constants';
 
 import {
 	arrayTester,
@@ -34,545 +46,830 @@ import {
 	typeTester,
 	uniqueItemsTester
 } from './tester';
-import { clone } from './util';
+import { clone, createErrorMsg, sift } from './util';
 
 
-interface AnyObject {
-	[key : string] : any;
-}
+function _getEffectiveTypes (scheme: Scheme): DataType[] | undefined {
+	let result: DataType[] | undefined;
 
+	if (definedTester(scheme.type)) {
+		result = (arrayTester(scheme.type)
+			? scheme.type
+			: [scheme.type]) as DataType[];
+	}
+	else if (definedTester(scheme.parent)) {
+		result = _getEffectiveTypes(scheme.parent);
+	}
 
-const _ejv = <T>(data : T, schemes : Scheme[], options : InternalOptions = {
-	path : []
-}) : null | EjvError => {
+	return result;
+}
+
+const _ejv = <T> (data: T, schemes: Scheme[], options: InternalOptions): null | EjvError => {
 	// check schemes
+	if (!definedTester(schemes) || schemes === null) {
+		return new EjvError({
+			type: ErrorType.NO_SCHEME,
+			message: ErrorMsg.NO_SCHEME,
+
+			data: data,
+
+			errorScheme: schemes,
+			isSchemeError: true
+		});
+	}
+
 	if (!arrayTester(schemes)) {
-		throw new Error(ErrorMsg.NO_ARRAY_SCHEME);
+		return new EjvError({
+			type: ErrorType.INVALID_SCHEMES,
+			message: ErrorMsg.NO_ARRAY_SCHEME,
+
+			data: data,
+
+			errorScheme: schemes,
+			isSchemeError: true
+		});
 	}
 
 	if (!arrayTypeOfTester(schemes, DataType.OBJECT)) {
-		throw new Error(ErrorMsg.NO_OBJECT_ARRAY_SCHEME);
+		return new EjvError({
+			type: ErrorType.INVALID_SCHEMES,
+			message: ErrorMsg.NO_OBJECT_ARRAY_SCHEME,
+
+			data: data,
+
+			errorScheme: schemes,
+			isSchemeError: true
+		});
 	}
 
 	if (!minLengthTester(schemes, 1)) {
-		throw new Error(ErrorMsg.EMPTY_SCHEME);
+		return new EjvError({
+			type: ErrorType.INVALID_SCHEMES,
+			message: ErrorMsg.EMPTY_SCHEME,
+
+			data: data,
+
+			errorScheme: schemes,
+			isSchemeError: true
+		});
 	}
 
 	// check data by schemes
-	let result : EjvError | null = null;
+	let result: EjvError | null = null;
 
 	// use for() instead of forEach() to stop
-	const schemeLength : number = schemes.length;
+	for (const scheme of schemes) {
+		const key: keyof T = scheme.key as keyof T;
 
-	for (let i = 0; i < schemeLength; i++) {
-		const _options : InternalOptions = clone(options); // divide instance
+		const _options: InternalOptions = clone(options); // divide instance
 
-		if (!definedTester(_options.path)) {
-			_options.path = [];
-		}
-
-		const scheme : Scheme = schemes[i];
-		const key : keyof T = scheme.key as keyof T;
-
-		let value : any;
+		let value: unknown;
 
-		if (!!key) {
+		if (key) {
 			value = data[key];
 
 			_options.path.push(key as string);
 		}
 
-		let types : DataType[];
+		const types: DataType[] | undefined = _getEffectiveTypes(scheme);
 
-		if (!definedTester(scheme.type)) {
-			throw new Error(ErrorMsg.SCHEMES_SHOULD_HAVE_TYPE);
-		}
+		if (!definedTester(types)) {
+			return new EjvError({
+				type: ErrorType.INVALID_SCHEMES,
+				message: ErrorMsg.SCHEMES_SHOULD_HAVE_TYPE,
+
+				data: data,
 
-		if (!arrayTester(scheme.type)) {
-			types = [scheme.type as DataType];
-		} else {
-			types = scheme.type as DataType[];
+				errorScheme: scheme,
+				isSchemeError: true
+			});
 		}
 
-		const allDataType : DataType[] = Object.values(DataType);
 
+		const allDataType: DataType[] = Object.values(DataType);
 
-		const errorType : string | undefined = types.find(type => {
-			return !(stringTester(type) && enumTester(type, allDataType));
+		const typeError: string | undefined = types.find((type: DataType): boolean => {
+			return !definedTester(type)
+				|| !stringTester(type)
+				|| !enumTester(type, allDataType);
 		});
 
-		if (!!errorType) {
-			throw new Error(ErrorMsg.SCHEMES_HAS_INVALID_TYPE.replace(ErrorMsgCursorA, errorType));
+		if (typeError) {
+			return new EjvError({
+				type: ErrorType.INVALID_SCHEMES,
+				message: createErrorMsg(ErrorMsg.SCHEMES_HAS_INVALID_TYPE, {
+					placeholders: [typeError]
+				}),
+
+				data: data,
+
+				errorScheme: scheme,
+				isSchemeError: true
+			});
 		}
 
 		if (!uniqueItemsTester(types)) {
-			throw new Error(ErrorMsg.SCHEMES_HAS_DUPLICATED_TYPE);
+			const notUniqueItems: string[] = types.filter((type: string): boolean => {
+				return types.filter((_type: unknown): boolean => _type === type).length > 1;
+			});
+
+			const notUniqueItemsSifted: string[] = sift(notUniqueItems);
+
+			return new EjvError({
+				type: ErrorType.INVALID_SCHEMES,
+				message: createErrorMsg(ErrorMsg.SCHEMES_HAS_DUPLICATED_TYPE, {
+					placeholders: [notUniqueItemsSifted.join(', ')]
+				}),
+
+				data: data,
+
+				errorScheme: scheme,
+				isSchemeError: true
+			});
 		}
 
 		if (!definedTester(value)) {
 			if (scheme.optional !== true) {
-				result = new EjvError(
-					ErrorType.REQUIRED,
-					ErrorMsg.REQUIRED,
-					_options.path,
+				result = new EjvError({
+					type: ErrorType.REQUIRED,
+					message: createErrorMsg(ErrorMsg.REQUIRED),
+
 					data,
-					value
-				);
+					path: _options.path,
+
+					errorScheme: scheme,
+					errorData: value
+				});
 				break;
-			} else {
+			}
+			else {
 				continue;
 			}
 		}
 
 		if (value === null) {
 			if (scheme.nullable !== true) {
-				result = new EjvError(
-					ErrorType.REQUIRED,
-					ErrorMsg.REQUIRED,
-					_options.path,
+				result = new EjvError({
+					type: ErrorType.REQUIRED,
+					message: createErrorMsg(ErrorMsg.REQUIRED),
+
 					data,
-					value
-				);
+					path: _options.path,
+
+					errorScheme: scheme,
+					errorData: value
+				});
 				break;
-			} else {
+			}
+			else {
 				continue;
 			}
 		}
 
-		const typeResolved : DataType | undefined = types.find(type => {
+		const typeResolved: DataType | undefined = types.find((type: DataType): type is DataType => {
 			return typeTester(value, type);
 		});
 
-		if (!typeResolved) {
-			if (!arrayTester(scheme.type)) {
-				result = new EjvError(
-					ErrorType.TYPE_MISMATCH,
-					ErrorMsg.TYPE_MISMATCH.replace(ErrorMsgCursorA, scheme.type as DataType),
-					_options.path,
+		if (typeResolved) {
+			if (definedTester(scheme.type)) {
+				if (!arrayTester(scheme.type)) {
+					if (scheme.type !== typeResolved) {
+						result = new EjvError({
+							type: ErrorType.TYPE_MISMATCH,
+							message: createErrorMsg(ErrorMsg.TYPE_MISMATCH, {
+								placeholders: [scheme.type]
+							}),
+
+							data,
+							path: _options.path,
+
+							errorScheme: scheme,
+							errorData: value
+						});
+					}
+				}
+				else {
+					if (!scheme.type.includes(typeResolved)) {
+						result = new EjvError({
+							type: ErrorType.TYPE_MISMATCH_ONE_OF,
+							message: createErrorMsg(ErrorMsg.TYPE_MISMATCH_ONE_OF, {
+								placeholders: [JSON.stringify(scheme.type)]
+							}),
+
+							data,
+							path: _options.path,
+
+							errorScheme: scheme,
+							errorData: value
+						});
+					}
+				}
+			}
+			// else do additional validation
+		}
+		else {
+			// type is not resolved
+			const typesForMsg: AllDataType = scheme.type || scheme.parent?.type as AllDataType;
+
+			if (!arrayTester(typesForMsg)) {
+				result = new EjvError({
+					type: ErrorType.TYPE_MISMATCH,
+					message: createErrorMsg(ErrorMsg.TYPE_MISMATCH, {
+						placeholders: [typesForMsg]
+					}),
+
 					data,
-					value
-				);
-			} else {
-				result = new EjvError(
-					ErrorType.TYPE_MISMATCH_ONE_OF,
-					ErrorMsg.TYPE_MISMATCH_ONE_OF.replace(ErrorMsgCursorA, JSON.stringify(scheme.type)),
-					_options.path,
+					path: _options.path,
+
+					errorScheme: scheme,
+					errorData: value
+				});
+			}
+			else {
+				result = new EjvError({
+					type: ErrorType.TYPE_MISMATCH_ONE_OF,
+					message: createErrorMsg(ErrorMsg.TYPE_MISMATCH_ONE_OF, {
+						placeholders: [JSON.stringify(typesForMsg)]
+					}),
+
 					data,
-					value
-				);
+					path: _options.path,
+
+					errorScheme: scheme,
+					errorData: value
+				});
 			}
+
 			break;
 		}
 
 		// additional check for type resolved
 		switch (typeResolved) {
-			case DataType.NUMBER:
-				const valueAsNumber : number = value as unknown as number;
+			case DataType.NUMBER: {
+				const valueAsNumber: number = value as unknown as number;
+				const numberScheme: NumberScheme = scheme as NumberScheme;
+
+				if (definedTester(numberScheme.enum)) {
+					if (!arrayTester(numberScheme.enum)) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.ENUM_SHOULD_BE_ARRAY),
+
+							data: data,
 
-				if (definedTester(scheme.enum)) {
-					if (!arrayTester(scheme.enum)) {
-						throw new Error(ErrorMsg.ENUM_SHOULD_BE_ARRAY);
+							errorScheme: numberScheme,
+							isSchemeError: true
+						});
 					}
 
-					const enumArr : number[] = scheme.enum as number[];
+					const enumArr: number[] = numberScheme.enum;
 
 					if (!arrayTypeOfTester(enumArr, DataType.NUMBER)) {
-						throw new Error(ErrorMsg.ENUM_SHOULD_BE_NUMBERS);
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.ENUM_SHOULD_BE_NUMBERS),
+
+							data: data,
+
+							errorScheme: numberScheme,
+							isSchemeError: true
+						});
 					}
 
 					if (!enumTester(valueAsNumber, enumArr)) {
-						result = new EjvError(
-							ErrorType.ONE_OF,
-							ErrorMsg.ONE_OF.replace(ErrorMsgCursorA, JSON.stringify(enumArr)),
-							_options.path,
+						result = new EjvError({
+							type: ErrorType.ONE_OF,
+							message: createErrorMsg(ErrorMsg.ONE_VALUE_OF, {
+								placeholders: [JSON.stringify(enumArr)]
+							}),
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: numberScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.enumReverse)) {
-					const enumReverseArr : number[] = scheme.enumReverse as number[];
+				if (
+					definedTester(numberScheme.min)
+					|| definedTester((scheme.parent as NumberScheme)?.min)
+				) {
+					const effectiveMin: number = numberScheme.min || (scheme.parent as NumberScheme)?.min as number;
 
-					if (!arrayTester(enumReverseArr)) {
-						throw new Error(ErrorMsg.ENUM_REVERSE_SHOULD_BE_ARRAY);
-					}
+					if (!numberTester(effectiveMin)) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.MIN_SHOULD_BE_NUMBER),
 
-					if (!arrayTypeOfTester(enumReverseArr, DataType.NUMBER)) {
-						throw new Error(ErrorMsg.ENUM_REVERSE_SHOULD_BE_NUMBERS);
-					}
+							data: data,
 
-					if (enumTester(valueAsNumber, enumReverseArr)) {
-						result = new EjvError(
-							ErrorType.NOT_ONE_OF,
-							ErrorMsg.NOT_ONE_OF.replace(ErrorMsgCursorA, JSON.stringify(enumReverseArr)),
-							_options.path,
-							data,
-							value
-						);
-						break;
+							errorScheme: numberScheme,
+							isSchemeError: true
+						});
 					}
-				}
 
-				if (definedTester(scheme.min)) {
-					if (!numberTester(scheme.min)) {
-						throw new Error(ErrorMsg.MIN_SHOULD_BE_NUMBER);
-					}
+					if (definedTester(numberScheme.exclusiveMin)) {
+						if (!booleanTester(numberScheme.exclusiveMin)) {
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN),
+
+								data: data,
 
-					if (definedTester(scheme.exclusiveMin)) {
-						if (!booleanTester(scheme.exclusiveMin)) {
-							throw new Error(ErrorMsg.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN);
+								errorScheme: numberScheme,
+								isSchemeError: true
+							});
 						}
+					}
 
-						if (scheme.exclusiveMin === true) {
-							if (!exclusiveMinNumberTester(valueAsNumber, scheme.min as number)) {
-								result = new EjvError(
-									ErrorType.GREATER_THAN,
-									ErrorMsg.GREATER_THAN.replace(ErrorMsgCursorA, '' + scheme.min),
-									_options.path,
-									data,
-									value
-								);
-								break;
-							}
-						} else {
-							if (!minNumberTester(valueAsNumber, scheme.min as number)) {
-								result = new EjvError(
-									ErrorType.GREATER_THAN_OR_EQUAL,
-									ErrorMsg.GREATER_THAN_OR_EQUAL.replace(ErrorMsgCursorA, '' + scheme.min),
-									_options.path,
-									data,
-									value
-								);
-								break;
-							}
+					if (numberScheme.exclusiveMin) {
+						if (!exclusiveMinNumberTester(valueAsNumber, effectiveMin)) {
+							result = new EjvError({
+								type: ErrorType.BIGGER_THAN,
+								message: createErrorMsg(ErrorMsg.BIGGER_THAN, {
+									placeholders: [effectiveMin]
+								}),
+
+								data,
+								path: _options.path,
+
+								errorScheme: numberScheme,
+								errorData: value
+							});
+							break;
 						}
-					} else {
-						if (!minNumberTester(valueAsNumber, scheme.min as number)) {
-							result = new EjvError(
-								ErrorType.GREATER_THAN_OR_EQUAL,
-								ErrorMsg.GREATER_THAN_OR_EQUAL.replace(ErrorMsgCursorA, '' + scheme.min),
-								_options.path,
+					}
+					else {
+						if (!minNumberTester(valueAsNumber, effectiveMin)) {
+							result = new EjvError({
+								type: ErrorType.BIGGER_THAN_OR_EQUAL,
+								message: createErrorMsg(ErrorMsg.BIGGER_THAN_OR_EQUAL, {
+									placeholders: [effectiveMin]
+								}),
+
 								data,
-								value
-							);
+								path: _options.path,
+
+								errorScheme: numberScheme,
+								errorData: value
+							});
 							break;
 						}
 					}
 				}
 
-				if (definedTester(scheme.max)) {
-					if (!numberTester(scheme.max)) {
-						throw new Error(ErrorMsg.MAX_SHOULD_BE_NUMBER);
+				if (definedTester(numberScheme.max)
+					|| definedTester((scheme.parent as NumberScheme)?.max)) {
+					const effectiveMax: number = numberScheme.max || (scheme.parent as NumberScheme)?.max as number;
+
+					if (!numberTester(effectiveMax)) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.MAX_SHOULD_BE_NUMBER),
+
+							data: data,
+
+							errorScheme: numberScheme,
+							isSchemeError: true
+						});
 					}
 
-					if (definedTester(scheme.exclusiveMax)) {
-						if (!booleanTester(scheme.exclusiveMax)) {
-							throw new Error(ErrorMsg.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN);
+					if (definedTester(numberScheme.exclusiveMax)) {
+						if (!booleanTester(numberScheme.exclusiveMax)) {
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN),
+
+								data: data,
+
+								errorScheme: numberScheme,
+								isSchemeError: true
+							});
 						}
+					}
 
-						if (scheme.exclusiveMax === true) {
-							if (!exclusiveMaxNumberTester(valueAsNumber, scheme.max as number)) {
-								result = new EjvError(
-									ErrorType.SMALLER_THAN,
-									ErrorMsg.SMALLER_THAN.replace(ErrorMsgCursorA, '' + scheme.max),
-									_options.path,
-									data,
-									value
-								);
-								break;
-							}
-						} else {
-							if (!maxNumberTester(valueAsNumber, scheme.max as number)) {
-								result = new EjvError(
-									ErrorType.SMALLER_THAN_OR_EQUAL,
-									ErrorMsg.SMALLER_THAN_OR_EQUAL.replace(ErrorMsgCursorA, '' + scheme.max),
-									_options.path,
-									data,
-									value
-								);
-								break;
-							}
+					if (numberScheme.exclusiveMax) {
+						if (!exclusiveMaxNumberTester(valueAsNumber, effectiveMax)) {
+							result = new EjvError({
+								type: ErrorType.SMALLER_THAN,
+								message: createErrorMsg(ErrorMsg.SMALLER_THAN, {
+									placeholders: [effectiveMax]
+								}),
+
+								data,
+								path: _options.path,
+
+								errorScheme: numberScheme,
+								errorData: value
+							});
+							break;
 						}
-					} else {
-						if (!maxNumberTester(valueAsNumber, scheme.max as number)) {
-							result = new EjvError(
-								ErrorType.SMALLER_THAN_OR_EQUAL,
-								ErrorMsg.SMALLER_THAN_OR_EQUAL.replace(ErrorMsgCursorA, '' + scheme.max),
-								_options.path,
+					}
+					else {
+						if (!maxNumberTester(valueAsNumber, effectiveMax)) {
+							result = new EjvError({
+								type: ErrorType.SMALLER_THAN_OR_EQUAL,
+								message: createErrorMsg(ErrorMsg.SMALLER_THAN_OR_EQUAL, {
+									placeholders: [effectiveMax]
+								}),
+
 								data,
-								value
-							);
+								path: _options.path,
+
+								errorScheme: numberScheme,
+								errorData: value
+							});
 							break;
 						}
 					}
 				}
 
-				if (definedTester(scheme.format)) {
-					let formats : NumberFormat[];
+				if (definedTester(numberScheme.format)) {
+					let formats: NumberFormat[];
 
-					const allNumberFormat : NumberFormat[] = Object.values(NumberFormat);
+					const allNumberFormat: NumberFormat[] = Object.values(NumberFormat);
 
-					if (!arrayTester(scheme.format)) {
-						const formatAsString : NumberFormat = scheme.format as NumberFormat;
+					if (!arrayTester(numberScheme.format)) {
+						const formatAsString: NumberFormat = numberScheme.format as NumberFormat;
 
 						if (!enumTester(formatAsString, allNumberFormat)) {
-							throw new Error(ErrorMsg.INVALID_NUMBER_FORMAT.replace(ErrorMsgCursorA, formatAsString));
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.INVALID_NUMBER_FORMAT, {
+									placeholders: [formatAsString]
+								}),
+
+								data: data,
+
+								errorScheme: numberScheme,
+								isSchemeError: true
+							});
 						}
 
-						formats = [scheme.format as NumberFormat];
-					} else {
-						const formatAsArray : NumberFormat[] = scheme.format as NumberFormat[];
+						formats = [numberScheme.format as NumberFormat];
+					}
+					else {
+						const formatAsArray: NumberFormat[] = numberScheme.format as NumberFormat[];
 
-						const errorFormat : string | undefined = formatAsArray.find(format => {
+						const errorFormat: string | undefined = formatAsArray.find((format: NumberFormat): boolean => {
 							return !enumTester(format, allNumberFormat);
 						});
 
-						if (!!errorFormat) {
-							throw new Error(ErrorMsg.INVALID_NUMBER_FORMAT.replace(ErrorMsgCursorA, errorFormat));
+						if (errorFormat) {
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.INVALID_NUMBER_FORMAT, {
+									placeholders: [errorFormat]
+								}),
+
+								data: data,
+
+								errorScheme: numberScheme,
+								isSchemeError: true
+							});
 						}
 
-						formats = scheme.format as NumberFormat[];
+						formats = numberScheme.format as NumberFormat[];
 					}
 
-					if (!formats.some(format => {
-						let valid : boolean = false;
+					const someFormatIsWrong: boolean = formats.some((format: NumberFormat): boolean => {
+						let valid: boolean = false;
 
 						switch (format) {
 							case NumberFormat.INTEGER:
-								valid = integerTester(value);
+								valid = integerTester(valueAsNumber);
 								break;
 
 							case NumberFormat.INDEX:
-								valid = indexTester(value);
+								valid = indexTester(valueAsNumber);
 								break;
 						}
 
 						return valid;
-					})) {
-						if (!arrayTester(scheme.format)) {
-							result = new EjvError(
-								ErrorType.FORMAT,
-								ErrorMsg.FORMAT.replace(ErrorMsgCursorA, scheme.format as NumberFormat),
-								_options.path,
+					});
+
+					if (!someFormatIsWrong) {
+						if (!arrayTester(numberScheme.format)) {
+							result = new EjvError({
+								type: ErrorType.FORMAT,
+								message: createErrorMsg(ErrorMsg.FORMAT, {
+									placeholders: [numberScheme.format]
+								}),
+
 								data,
-								value
-							);
-						} else {
-							result = new EjvError(
-								ErrorType.FORMAT_ONE_OF,
-								ErrorMsg.FORMAT_ONE_OF.replace(ErrorMsgCursorA, JSON.stringify(scheme.format)),
-								_options.path,
+								path: _options.path,
+
+								errorScheme: numberScheme,
+								errorData: value
+							});
+						}
+						else {
+							result = new EjvError({
+								type: ErrorType.FORMAT_ONE_OF,
+								message: createErrorMsg(ErrorMsg.FORMAT_ONE_OF, {
+									placeholders: [JSON.stringify(numberScheme.format)]
+								}),
+
 								data,
-								value
-							);
+								path: _options.path,
+
+								errorScheme: numberScheme,
+								errorData: value
+							});
 						}
 						break;
 					}
 				}
 				break;
+			}
 
-			case DataType.STRING:
-				const valueAsString : string = value as unknown as string;
+			case DataType.STRING: {
+				const valueAsString: string = value as unknown as string;
+				const stringScheme: StringScheme = scheme as StringScheme;
 
-				if (definedTester(scheme.enum)) {
-					if (!arrayTester(scheme.enum)) {
-						throw new Error(ErrorMsg.ENUM_SHOULD_BE_ARRAY);
-					}
+				if (definedTester(stringScheme.enum)) {
+					if (!arrayTester(stringScheme.enum)) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.ENUM_SHOULD_BE_ARRAY),
 
-					const enumArr : string[] = scheme.enum as string[];
+							data: data,
 
-					if (!arrayTypeOfTester(enumArr, DataType.STRING)) {
-						throw new Error(ErrorMsg.ENUM_SHOULD_BE_STRINGS);
+							errorScheme: stringScheme,
+							isSchemeError: true
+						});
 					}
 
-					if (!enumTester(valueAsString, enumArr)) {
-						result = new EjvError(
-							ErrorType.ONE_OF,
-							ErrorMsg.ONE_OF.replace(ErrorMsgCursorA, JSON.stringify(scheme.enum)),
-							_options.path,
-							data,
-							value
-						);
-						break;
-					}
-				}
+					const enumArr: string[] = stringScheme.enum;
 
-				if (definedTester(scheme.enumReverse)) {
-					if (!arrayTester(scheme.enumReverse)) {
-						throw new Error(ErrorMsg.ENUM_REVERSE_SHOULD_BE_ARRAY);
-					}
+					if (!arrayTypeOfTester(enumArr, DataType.STRING)) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.ENUM_SHOULD_BE_STRINGS),
 
-					const enumReverseArr : string[] = scheme.enumReverse as string[];
+							data: data,
 
-					if (!arrayTypeOfTester(enumReverseArr, DataType.STRING)) {
-						throw new Error(ErrorMsg.ENUM_REVERSE_SHOULD_BE_STRINGS);
+							errorScheme: stringScheme,
+							isSchemeError: true
+						});
 					}
 
-					if (enumTester(valueAsString, enumReverseArr)) {
-						result = new EjvError(
-							ErrorType.NOT_ONE_OF,
-							ErrorMsg.NOT_ONE_OF.replace(ErrorMsgCursorA, JSON.stringify(enumReverseArr)),
-							_options.path,
+					if (!enumTester(valueAsString, enumArr)) {
+						result = new EjvError({
+							type: ErrorType.ONE_OF,
+							message: createErrorMsg(ErrorMsg.ONE_VALUE_OF, {
+								placeholders: [JSON.stringify(stringScheme.enum)]
+							}),
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: stringScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.length)) {
-					const length : number = scheme.length as number;
+				if (definedTester(stringScheme.length)) {
+					const length: number = stringScheme.length;
 
 					if (!(numberTester(length) && integerTester(length))) {
-						throw new Error(ErrorMsg.LENGTH_SHOULD_BE_INTEGER);
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.LENGTH_SHOULD_BE_INTEGER),
+
+							data: data,
+
+							errorScheme: stringScheme,
+							isSchemeError: true
+						});
 					}
 
 					if (!lengthTester(valueAsString, length)) {
-						result = new EjvError(
-							ErrorType.LENGTH,
-							ErrorMsg.LENGTH.replace(ErrorMsgCursorA, '' + length),
-							_options.path,
+						result = new EjvError({
+							type: ErrorType.LENGTH,
+							message: createErrorMsg(ErrorMsg.LENGTH, {
+								placeholders: [length]
+							}),
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: stringScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.minLength)) {
-					const minLength : number = scheme.minLength as number;
+				if (definedTester(stringScheme.minLength)) {
+					const minLength: number = stringScheme.minLength;
 
 					if (!(numberTester(minLength) && integerTester(minLength))) {
-						throw new Error(ErrorMsg.MIN_LENGTH_SHOULD_BE_INTEGER);
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.MIN_LENGTH_SHOULD_BE_INTEGER),
+
+							data: data,
+
+							errorScheme: stringScheme,
+							isSchemeError: true
+						});
 					}
 
 					if (!minLengthTester(valueAsString, minLength)) {
-						result = new EjvError(
-							ErrorType.MIN_LENGTH,
-							ErrorMsg.MIN_LENGTH.replace(ErrorMsgCursorA, '' + minLength),
-							_options.path,
+						result = new EjvError({
+							type: ErrorType.MIN_LENGTH,
+							message: createErrorMsg(ErrorMsg.MIN_LENGTH, {
+								placeholders: ['' + minLength]
+							}),
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: stringScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.maxLength)) {
-					const maxLength : number = scheme.maxLength as number;
+				if (definedTester(stringScheme.maxLength)) {
+					const maxLength: number = stringScheme.maxLength;
 
 					if (!(numberTester(maxLength) && integerTester(maxLength))) {
-						throw new Error(ErrorMsg.MAX_LENGTH_SHOULD_BE_INTEGER);
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.MAX_LENGTH_SHOULD_BE_INTEGER),
+
+							data: data,
+
+							errorScheme: stringScheme,
+							isSchemeError: true
+						});
 					}
 
 					if (!maxLengthTester(valueAsString, maxLength)) {
-						result = new EjvError(
-							ErrorType.MAX_LENGTH,
-							ErrorMsg.MAX_LENGTH.replace(ErrorMsgCursorA, '' + maxLength),
-							_options.path,
+						result = new EjvError({
+							type: ErrorType.MAX_LENGTH,
+							message: createErrorMsg(ErrorMsg.MAX_LENGTH, {
+								placeholders: ['' + maxLength]
+							}),
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: stringScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.format)) {
-					let formats : StringFormat[];
+				if (definedTester(stringScheme.format)) {
+					let formats: StringFormat[];
 
-					const allStringFormat : StringFormat[] = Object.values(StringFormat);
+					const allStringFormat: StringFormat[] = Object.values(StringFormat);
 
-					if (!arrayTester(scheme.format)) {
-						const formatAsString : string = scheme.format as string;
+					if (!arrayTester(stringScheme.format)) {
+						const formatAsString: string = stringScheme.format;
 
 						if (!enumTester(formatAsString, allStringFormat)) {
-							throw new Error(ErrorMsg.INVALID_STRING_FORMAT.replace(ErrorMsgCursorA, formatAsString));
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.INVALID_STRING_FORMAT, {
+									placeholders: [formatAsString]
+								}),
+
+								data: data,
+
+								errorScheme: stringScheme,
+								isSchemeError: true
+							});
 						}
 
-						formats = [scheme.format] as StringFormat[];
-					} else {
-						const formatAsArray : string[] = scheme.format as string[];
-						const errorFormat : string | undefined = formatAsArray.find(format => {
+						formats = [stringScheme.format] as StringFormat[];
+					}
+					else {
+						const formatAsArray: string[] = stringScheme.format;
+						const errorFormat: string | undefined = formatAsArray.find((format: string): boolean => {
 							return !enumTester(format, allStringFormat);
 						});
 
-						if (!!errorFormat) {
-							throw new Error(ErrorMsg.INVALID_STRING_FORMAT.replace(ErrorMsgCursorA, errorFormat));
+						if (errorFormat) {
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.INVALID_STRING_FORMAT, {
+									placeholders: [errorFormat]
+								}),
+
+								data: data,
+
+								errorScheme: stringScheme,
+								isSchemeError: true
+							});
 						}
 
-						formats = scheme.format as StringFormat[];
+						formats = stringScheme.format as StringFormat[];
 					}
 
-					if (!formats.some(format => {
-						let valid : boolean = false;
+					const foundFormatMatching: boolean = formats.some((format: StringFormat): boolean => {
+						let valid: boolean = false;
 
 						switch (format) {
 							case StringFormat.EMAIL:
-								valid = emailTester(value);
+								valid = emailTester(valueAsString);
 								break;
 
 							case StringFormat.DATE:
-								valid = dateFormatTester(value);
+								valid = dateFormatTester(valueAsString);
 								break;
 
 							case StringFormat.TIME:
-								valid = timeFormatTester(value);
+								valid = timeFormatTester(valueAsString);
 								break;
 
 							case StringFormat.DATE_TIME:
-								valid = dateTimeFormatTester(value);
+								valid = dateTimeFormatTester(valueAsString);
 								break;
 						}
 
 						return valid;
-					})) {
-						if (!arrayTester(scheme.format)) {
-							result = new EjvError(
-								ErrorType.FORMAT,
-								ErrorMsg.FORMAT.replace(ErrorMsgCursorA, scheme.format as StringFormat),
-								_options.path,
+					});
+
+					if (!foundFormatMatching) {
+						if (!arrayTester(stringScheme.format)) {
+							result = new EjvError({
+								type: ErrorType.FORMAT,
+								message: createErrorMsg(ErrorMsg.FORMAT, {
+									placeholders: [stringScheme.format as StringFormat]
+								}),
+
 								data,
-								value
-							);
-						} else {
-							result = new EjvError(
-								ErrorType.FORMAT_ONE_OF,
-								ErrorMsg.FORMAT_ONE_OF.replace(ErrorMsgCursorA, JSON.stringify(scheme.format)),
-								_options.path,
+								path: _options.path,
+
+								errorScheme: stringScheme,
+								errorData: value
+							});
+						}
+						else {
+							result = new EjvError({
+								type: ErrorType.FORMAT_ONE_OF,
+								message: createErrorMsg(ErrorMsg.FORMAT_ONE_OF, {
+									placeholders: [JSON.stringify(stringScheme.format)]
+								}),
+
 								data,
-								value
-							);
+								path: _options.path,
+
+								errorScheme: stringScheme,
+								errorData: value
+							});
 						}
 						break;
 					}
 				}
 
-				if (definedTester(scheme.pattern)) {
+				if (definedTester(stringScheme.pattern)) {
 					// check parameter
-					if (scheme.pattern === null) {
-						throw new Error(ErrorMsg.INVALID_STRING_PATTERN
-							.replace(ErrorMsgCursorA, 'null'));
+					if (stringScheme.pattern === null) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.INVALID_STRING_PATTERN, {
+								placeholders: ['null']
+							}),
+
+							data: data,
+
+							errorScheme: stringScheme,
+							isSchemeError: true
+						});
 					}
 
-					const isValidPattern = (pattern : string | RegExp) : boolean => {
+					const isValidPattern = (pattern: string | RegExp): boolean => {
 						return (stringTester(pattern) && minLengthTester(pattern as string, 1))
 							|| (regExpTester(pattern) && pattern.toString() !== '/(?:)/' && pattern.toString() !== '/null/');
 					};
 
-					const patternToString = (pattern : string | RegExp) : string => {
-						let regExpStr : string;
+					const patternToString = (pattern: string | RegExp): string => {
+						let regExpStr: string;
 
 						if (pattern === null) {
 							regExpStr = '/null/';
-						} else if (stringTester(pattern)) {
+						}
+						else if (stringTester(pattern)) {
 							if (minLengthTester(pattern as string, 1)) {
 								regExpStr = new RegExp(pattern as string).toString();
-							} else {
+							}
+							else {
 								regExpStr = '//';
 							}
-						} else {
+						}
+						else {
 							regExpStr = pattern.toString();
 						}
 
@@ -584,488 +881,768 @@ const _ejv = <T>(data : T, schemes : Scheme[], options : InternalOptions = {
 						return regExpStr;
 					};
 
-					const createArrayErrorMsg = (patternsAsArray : (string | RegExp)[]) : string => {
-						return '[' + patternsAsArray.map(onePattern => {
+					const createArrayErrorMsg = (patternsAsArray: (string | RegExp)[]): string => {
+						return '[' + patternsAsArray.map((onePattern: string | RegExp): string => {
 							return patternToString(onePattern);
 						}).join(', ') + ']';
 					};
 
-					if (arrayTester(scheme.pattern)) {
-						const patternsAsArray : (string | RegExp)[] = scheme.pattern as (string | RegExp)[];
+					if (arrayTester(stringScheme.pattern)) {
+						const patternsAsArray: (string | RegExp)[] = stringScheme.pattern as (string | RegExp)[];
 
 						if (!minLengthTester(patternsAsArray, 1)) { // empty array
-							throw new Error(ErrorMsg.INVALID_STRING_PATTERN
-								.replace(ErrorMsgCursorA, createArrayErrorMsg(patternsAsArray)));
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.INVALID_STRING_PATTERN, {
+									placeholders: [createArrayErrorMsg(patternsAsArray)]
+								}),
+
+								data: data,
+
+								errorScheme: stringScheme,
+								isSchemeError: true
+							});
 						}
 
-						const regExpPatterns : RegExp[] = patternsAsArray.map(pattern => {
-							if (!isValidPattern(pattern)) {
-								throw new Error(ErrorMsg.INVALID_STRING_PATTERN
-									.replace(ErrorMsgCursorA, createArrayErrorMsg(patternsAsArray)));
-							}
+						try {
+							const regExpPatterns: RegExp[] = patternsAsArray.map((pattern: string | RegExp): RegExp => {
+								if (!isValidPattern(pattern)) {
+									throw new Error(createErrorMsg(ErrorMsg.INVALID_STRING_PATTERN, {
+										placeholders: [createArrayErrorMsg(patternsAsArray)]
+									}));
+								}
 
-							return new RegExp(pattern);
-						}) as RegExp[];
+								return new RegExp(pattern);
+							}) as RegExp[];
 
-						// check value
-						if (!regExpPatterns.some((regexp : RegExp) => {
-							return stringRegExpTester(value, regexp);
-						})) {
-							result = new EjvError(
-								ErrorType.PATTERN_ONE_OF,
-								ErrorMsg.PATTERN_ONE_OF
-									.replace(ErrorMsgCursorA, createArrayErrorMsg(patternsAsArray)),
-								_options.path,
-								data,
-								value
-							);
-							break;
+							// check value
+							const foundMatchPattern: boolean = regExpPatterns.some((regexp: RegExp): boolean => {
+								return stringRegExpTester(valueAsString, regexp);
+							});
+
+							if (!foundMatchPattern) {
+								result = new EjvError({
+									type: ErrorType.PATTERN_ONE_OF,
+									message: createErrorMsg(ErrorMsg.PATTERN_ONE_OF, {
+										placeholders: [createArrayErrorMsg(patternsAsArray)]
+									}),
+
+									data,
+									path: _options.path,
+
+									errorScheme: stringScheme,
+									errorData: value
+								});
+								break;
+							}
 						}
+						catch (e: unknown) {
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.INVALID_STRING_PATTERN, {
+									placeholders: [createArrayErrorMsg(patternsAsArray)]
+								}),
 
-					} else {
-						const patternAsOne : string | RegExp = scheme.pattern as string | RegExp;
+								data: data,
+
+								errorScheme: stringScheme,
+								isSchemeError: true
+							});
+						}
+					}
+					else {
+						const patternAsOne: string | RegExp = stringScheme.pattern as string | RegExp;
 
 						if (!isValidPattern(patternAsOne)) {
-							throw new Error(ErrorMsg.INVALID_STRING_PATTERN
-								.replace(ErrorMsgCursorA, patternToString(patternAsOne)));
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.INVALID_STRING_PATTERN, {
+									placeholders: [patternToString(patternAsOne)]
+								}),
+
+								data: data,
+
+								errorScheme: stringScheme,
+								isSchemeError: true
+							});
 						}
 
 						// check value
-						const regExp : RegExp = new RegExp(patternAsOne);
+						const regExp: RegExp = new RegExp(patternAsOne);
 
 						if (!stringRegExpTester(valueAsString, regExp)) {
-							result = new EjvError(
-								ErrorType.PATTERN,
-								ErrorMsg.PATTERN.replace(ErrorMsgCursorA, patternToString(patternAsOne)),
-								_options.path,
+							result = new EjvError({
+								type: ErrorType.PATTERN,
+								message: createErrorMsg(ErrorMsg.PATTERN, {
+									placeholders: [patternToString(patternAsOne)]
+								}),
+
 								data,
-								value
-							);
+								path: _options.path,
+
+								errorScheme: stringScheme,
+								errorData: value
+							});
 							break;
 						}
 					}
 				}
 				break;
+			}
+
+			case DataType.OBJECT: {
+				const valueAsObject: AnyObject = value as unknown as AnyObject;
+				const objectScheme: ObjectScheme = scheme as ObjectScheme;
+
+				if (definedTester(objectScheme.allowNoProperty)) {
+					if (!booleanTester(objectScheme.allowNoProperty)) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.ALLOW_NO_PROPERTY_SHOULD_BE_BOOLEAN),
 
-			case DataType.OBJECT:
-				const valueAsObject = value as unknown as { [key : string] : any };
+							data: data,
 
-				if (definedTester(scheme.allowNoProperty)) {
-					if (!booleanTester(scheme.allowNoProperty)) {
-						throw new Error(ErrorMsg.ALLOW_NO_PROPERTY_SHOULD_BE_BOOLEAN);
+							errorScheme: objectScheme,
+							isSchemeError: true
+						});
 					}
 
-					if (scheme.allowNoProperty !== true && !hasPropertyTester(valueAsObject)) {
-						result = new EjvError(
-							ErrorType.NO_PROPERTY,
-							ErrorMsg.NO_PROPERTY,
-							_options.path,
+					if (!objectScheme.allowNoProperty && !hasPropertyTester(valueAsObject)) {
+						result = new EjvError({
+							type: ErrorType.PROPERTY,
+							message: ErrorMsg.PROPERTY,
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: objectScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.properties)) {
-					if (!arrayTester(scheme.properties)) {
-						throw new Error(ErrorMsg.PROPERTIES_SHOULD_BE_ARRAY);
+				if (definedTester(objectScheme.properties)) {
+					if (!arrayTester(objectScheme.properties)) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.PROPERTIES_SHOULD_BE_ARRAY),
+
+							data: data,
+
+							errorScheme: objectScheme,
+							isSchemeError: true
+						});
 					}
 
-					const properties : Scheme[] = scheme.properties as Scheme[];
+					const properties: Scheme[] = objectScheme.properties as Scheme[];
 
 					if (!minLengthTester(properties, 1)) {
-						throw new Error(ErrorMsg.PROPERTIES_SHOULD_HAVE_ITEMS);
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.PROPERTIES_SHOULD_HAVE_ITEMS),
+
+							data: data,
+
+							errorScheme: objectScheme,
+							isSchemeError: true
+						});
 					}
 
 					if (!arrayTypeOfTester(properties, DataType.OBJECT)) {
-						throw new Error(ErrorMsg.PROPERTIES_SHOULD_BE_ARRAY_OF_OBJECT);
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.PROPERTIES_SHOULD_BE_ARRAY_OF_OBJECT),
+
+							data: data,
+
+							errorScheme: objectScheme,
+							isSchemeError: true
+						});
 					}
 
 					if (!objectTester(value)) {
-						result = new EjvError(
-							ErrorType.TYPE_MISMATCH,
-							ErrorMsg.TYPE_MISMATCH.replace(ErrorMsgCursorA, 'object'),
-							_options.path,
+						result = new EjvError({
+							type: ErrorType.TYPE_MISMATCH,
+							message: createErrorMsg(ErrorMsg.TYPE_MISMATCH, {
+								placeholders: ['object']
+							}),
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: objectScheme,
+							errorData: value
+						});
 						break;
 					}
 
-					const partialData : T[keyof T] = data[key];
-					const partialScheme : Scheme[] = scheme.properties as Scheme[];
+					const partialData: T[keyof T] = data[key];
+					const partialScheme: Scheme[] = objectScheme.properties as Scheme[];
+					scheme.parent = objectScheme;
 
 					// call recursively
 					result = _ejv(partialData, partialScheme, _options);
 
-					if (!!result) {
+					if (result) {
 						// inject original data
 						result.data = data;
 					}
 				}
 				break;
+			}
+
+			case DataType.DATE: {
+				const valueAsDate: Date = value as unknown as Date;
+				const dateScheme: DateScheme = scheme as DateScheme;
+				const parentDateScheme: DateScheme | undefined = scheme.parent as DateScheme | undefined;
 
-			case DataType.DATE:
-				const valueAsDate : Date = value as unknown as Date;
+				if (definedTester(dateScheme.min)
+					|| definedTester(parentDateScheme?.min)) {
+					const minDateCandidate: string | Date = dateScheme.min || parentDateScheme?.min as string | Date;
 
-				if (definedTester(scheme.min)) {
 					if (!(
-						(stringTester(scheme.min) && (dateFormatTester(scheme.min as string) || dateTimeFormatTester(scheme.min as string)))
-						|| dateTester(scheme.min)
+						(stringTester(minDateCandidate)
+							&& (
+								dateFormatTester(minDateCandidate as string)
+								|| dateTimeFormatTester(minDateCandidate as string)
+							)
+						)
+						|| dateTester(minDateCandidate)
 					)) {
-						throw new Error(ErrorMsg.MIN_DATE_SHOULD_BE_DATE_OR_STRING);
-					}
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.MIN_DATE_SHOULD_BE_DATE_OR_STRING),
+
+							data: data,
 
-					if (definedTester(scheme.exclusiveMin) && !booleanTester(scheme.exclusiveMin)) {
-						throw new Error(ErrorMsg.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN);
+							errorScheme: dateScheme,
+							isSchemeError: true
+						});
 					}
 
-					let minDate : Date = new Date(scheme.min as string | Date);
+					const effectiveMin: Date = new Date(minDateCandidate);
 
-					// adjust timezone
-					if (stringTester(scheme.min)) {
-						// by minutes
-						const timezoneOffset : number = minDate.getTimezoneOffset();
+					if (definedTester(dateScheme.exclusiveMin)) {
+						if (!booleanTester(dateScheme.exclusiveMin)) {
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.EXCLUSIVE_MIN_SHOULD_BE_BOOLEAN),
 
-						minDate = new Date(+minDate + (timezoneOffset * 60 * 1000));
-					}
+								data: data,
 
-					if (scheme.exclusiveMin !== true) {
-						if (!minDateTester(valueAsDate, minDate)) {
-							result = new EjvError(
-								ErrorType.AFTER_OR_SAME_DATE,
-								ErrorMsg.AFTER_OR_SAME_DATE.replace(ErrorMsgCursorA, minDate.toISOString()),
-								_options.path,
-								data,
-								value
-							);
-							break;
+								errorScheme: dateScheme,
+								isSchemeError: true
+							});
+						}
+
+
+						if (dateScheme.exclusiveMin) {
+							if (!exclusiveMinDateTester(valueAsDate, effectiveMin)) {
+								result = new EjvError({
+									type: ErrorType.AFTER_DATE,
+									message: createErrorMsg(ErrorMsg.AFTER_DATE, {
+										placeholders: [effectiveMin.toISOString()]
+									}),
+
+									data,
+									path: _options.path,
+
+									errorScheme: dateScheme,
+									errorData: value
+								});
+								break;
+
+							}
+						}
+						else {
+							if (!minDateTester(valueAsDate, effectiveMin)) {
+								result = new EjvError({
+									type: ErrorType.AFTER_OR_SAME_DATE,
+									message: createErrorMsg(ErrorMsg.AFTER_OR_SAME_DATE, {
+										placeholders: [effectiveMin.toISOString()]
+									}),
+
+									data,
+									path: _options.path,
+
+									errorScheme: dateScheme,
+									errorData: value
+								});
+								break;
+							}
 						}
 
-					} else {
-						if (!exclusiveMinDateTester(valueAsDate, minDate)) {
-							result = new EjvError(
-								ErrorType.AFTER_DATE,
-								ErrorMsg.AFTER_DATE.replace(ErrorMsgCursorA, minDate.toISOString()),
-								_options.path,
+
+					}
+					else {
+						if (!minDateTester(valueAsDate, effectiveMin)) {
+							result = new EjvError({
+								type: ErrorType.AFTER_OR_SAME_DATE,
+								message: createErrorMsg(ErrorMsg.AFTER_OR_SAME_DATE, {
+									placeholders: [effectiveMin.toISOString()]
+								}),
+
 								data,
-								value
-							);
+								path: _options.path,
+
+								errorScheme: dateScheme,
+								errorData: value
+							});
 							break;
 						}
 					}
 				}
 
-				if (definedTester(scheme.max)) {
+				if (definedTester(dateScheme.max)
+					|| definedTester(parentDateScheme?.max)) {
+					const maxDateCandidate: string | Date = dateScheme.max || parentDateScheme?.max as string | Date;
+
 					if (!(
-						(stringTester(scheme.max) && (dateFormatTester(scheme.max as string) || dateTimeFormatTester(scheme.max as string)))
-						|| dateTester(scheme.max)
+						(stringTester(maxDateCandidate)
+							&& (
+								dateFormatTester(maxDateCandidate as string)
+								|| dateTimeFormatTester(maxDateCandidate as string)
+							)
+						)
+						|| dateTester(maxDateCandidate)
 					)) {
-						throw new Error(ErrorMsg.MAX_DATE_SHOULD_BE_DATE_OR_STRING);
-					}
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.MAX_DATE_SHOULD_BE_DATE_OR_STRING),
+
+							data: data,
 
-					if (definedTester(scheme.exclusiveMax) && !booleanTester(scheme.exclusiveMax)) {
-						throw new Error(ErrorMsg.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN);
+							errorScheme: dateScheme,
+							isSchemeError: true
+						});
 					}
 
-					let maxDate : Date = new Date(scheme.max as string | Date);
+					const effectiveMax: Date = new Date(maxDateCandidate);
+
+					if (definedTester(dateScheme.exclusiveMax)) {
+						if (!booleanTester(dateScheme.exclusiveMax)) {
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.EXCLUSIVE_MAX_SHOULD_BE_BOOLEAN),
 
-					// adjust timezone
-					if (stringTester(scheme.max)) {
-						// by minutes
-						const timezoneOffset : number = maxDate.getTimezoneOffset();
+								data: data,
 
-						maxDate = new Date(+maxDate + (timezoneOffset * 60 * 1000));
+								errorScheme: dateScheme,
+								isSchemeError: true
+							});
+						}
 					}
 
-					if (scheme.exclusiveMax !== true) {
-						if (!maxDateTester(valueAsDate, maxDate)) {
-							result = new EjvError(
-								ErrorType.BEFORE_OR_SAME_DATE,
-								ErrorMsg.BEFORE_OR_SAME_DATE.replace(ErrorMsgCursorA, maxDate.toISOString()),
-								_options.path,
+					if (dateScheme.exclusiveMax) {
+						if (!exclusiveMaxDateTester(valueAsDate, effectiveMax)) {
+							result = new EjvError({
+								type: ErrorType.BEFORE_DATE,
+								message: createErrorMsg(ErrorMsg.BEFORE_DATE, {
+									placeholders: [effectiveMax.toISOString()]
+								}),
+
 								data,
-								value
-							);
+								path: _options.path,
+
+								errorScheme: dateScheme,
+								errorData: value
+							});
 							break;
 						}
+					}
+					else {
+						if (!maxDateTester(valueAsDate, effectiveMax)) {
+							result = new EjvError({
+								type: ErrorType.BEFORE_OR_SAME_DATE,
+								message: createErrorMsg(ErrorMsg.BEFORE_OR_SAME_DATE, {
+									placeholders: [effectiveMax.toISOString()]
+								}),
 
-					} else {
-						if (!exclusiveMaxDateTester(valueAsDate, maxDate)) {
-							result = new EjvError(
-								ErrorType.BEFORE_DATE,
-								ErrorMsg.BEFORE_DATE.replace(ErrorMsgCursorA, maxDate.toISOString()),
-								_options.path,
 								data,
-								value
-							);
+								path: _options.path,
+
+								errorScheme: dateScheme,
+								errorData: value
+							});
 							break;
 						}
 					}
 				}
 				break;
+			}
 
-			case DataType.ARRAY:
-				const valueAsArray : any[] = value as unknown as any[];
+			case DataType.ARRAY: {
+				const valueAsArray: unknown[] = value as unknown as unknown[];
+				const arrayScheme: ArrayScheme = scheme as ArrayScheme;
 
-				if (definedTester(scheme.length)) {
-					const length : number = scheme.length as number;
+				if (definedTester(arrayScheme.length)) {
+					const length: number = arrayScheme.length;
 
 					if (!(numberTester(length) && integerTester(length))) {
-						throw new Error(ErrorMsg.LENGTH_SHOULD_BE_INTEGER);
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.LENGTH_SHOULD_BE_INTEGER),
+
+							data: data,
+
+							errorScheme: arrayScheme,
+							isSchemeError: true
+						});
 					}
 
 					if (!lengthTester(valueAsArray, length)) {
-						result = new EjvError(
-							ErrorType.LENGTH,
-							ErrorMsg.LENGTH.replace(ErrorMsgCursorA, '' + length),
-							_options.path,
+						result = new EjvError({
+							type: ErrorType.LENGTH,
+							message: createErrorMsg(ErrorMsg.LENGTH, {
+								placeholders: ['' + length]
+							}),
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: arrayScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.minLength)) {
-					const minLength : number = scheme.minLength as number;
+				if (definedTester(arrayScheme.minLength)) {
+					const minLength: number = arrayScheme.minLength;
 
-					if (!(numberTester(scheme.minLength) && integerTester(minLength))) {
-						throw new Error(ErrorMsg.MIN_LENGTH_SHOULD_BE_INTEGER);
+					if (!(numberTester(arrayScheme.minLength) && integerTester(minLength))) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.MIN_LENGTH_SHOULD_BE_INTEGER),
+
+							data: data,
+
+							errorScheme: arrayScheme,
+							isSchemeError: true
+						});
 					}
 
 					if (!minLengthTester(valueAsArray, minLength)) {
-						result = new EjvError(
-							ErrorType.MIN_LENGTH,
-							ErrorMsg.MIN_LENGTH.replace(ErrorMsgCursorA, '' + minLength),
-							_options.path,
+						result = new EjvError({
+							type: ErrorType.MIN_LENGTH,
+							message: createErrorMsg(ErrorMsg.MIN_LENGTH, {
+								placeholders: ['' + minLength]
+							}),
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: arrayScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.maxLength)) {
-					const maxLength : number = scheme.maxLength as number;
+				if (definedTester(arrayScheme.maxLength)) {
+					const maxLength: number = arrayScheme.maxLength;
+
+					if (!(numberTester(arrayScheme.maxLength) && integerTester(maxLength))) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.MAX_LENGTH_SHOULD_BE_INTEGER),
+
+							data: data,
 
-					if (!(numberTester(scheme.maxLength) && integerTester(maxLength))) {
-						throw new Error(ErrorMsg.MAX_LENGTH_SHOULD_BE_INTEGER);
+							errorScheme: arrayScheme,
+							isSchemeError: true
+						});
 					}
 
 					if (!maxLengthTester(valueAsArray, maxLength)) {
-						result = new EjvError(
-							ErrorType.MAX_LENGTH,
-							ErrorMsg.MAX_LENGTH.replace(ErrorMsgCursorA, '' + maxLength),
-							_options.path,
+						result = new EjvError({
+							type: ErrorType.MAX_LENGTH,
+							message: createErrorMsg(ErrorMsg.MAX_LENGTH, {
+								placeholders: ['' + maxLength]
+							}),
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: arrayScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.unique)) {
-					if (!booleanTester(scheme.unique)) {
-						throw new Error(ErrorMsg.UNIQUE_SHOULD_BE_BOOLEAN);
+				if (definedTester(arrayScheme.unique)) {
+					if (!booleanTester(arrayScheme.unique)) {
+						return new EjvError({
+							type: ErrorType.INVALID_SCHEMES,
+							message: createErrorMsg(ErrorMsg.UNIQUE_SHOULD_BE_BOOLEAN),
+
+							data: data,
+
+							errorScheme: arrayScheme,
+							isSchemeError: true
+						});
 					}
 
-					if (scheme.unique === true && !uniqueItemsTester(valueAsArray)) {
-						result = new EjvError(
-							ErrorType.UNIQUE_ITEMS,
-							ErrorMsg.UNIQUE_ITEMS,
-							_options.path,
+					if (arrayScheme.unique && !uniqueItemsTester(valueAsArray)) {
+						result = new EjvError({
+							type: ErrorType.UNIQUE_ITEMS,
+							message: ErrorMsg.UNIQUE_ITEMS,
+
 							data,
-							value
-						);
+							path: _options.path,
+
+							errorScheme: arrayScheme,
+							errorData: value
+						});
 						break;
 					}
 				}
 
-				if (definedTester(scheme.items)) {
+				if (definedTester(arrayScheme.items)) {
 					// convert array to object
 					if (valueAsArray.length > 0) {
-						const now : Date = new Date;
-						const tempKeyArr : string[] = valueAsArray.map((value : any, i : number) => {
+						const now: Date = new Date();
+						const tempKeyArr: string[] = valueAsArray.map((_value: unknown, i: number): string => {
 							return '' + (+now + i);
 						});
 
-						if (stringTester(scheme.items) // by DataType
-							|| (arrayTester(scheme.items) && arrayTypeOfTester(scheme.items as DataType[], DataType.STRING)) // by DataType[]
+						if (stringTester(arrayScheme.items) // by DataType
+							|| (arrayTester(arrayScheme.items) && arrayTypeOfTester(arrayScheme.items as DataType[], DataType.STRING)) // by DataType[]
 						) {
-							const itemTypes : DataType[] = (arrayTester(scheme.items) ? scheme.items : [scheme.items]) as DataType[];
+							const itemTypes: DataType[] = (arrayTester(arrayScheme.items)
+								? arrayScheme.items
+								: [arrayScheme.items]) as DataType[];
+
+							const itemTypeError: string | undefined = itemTypes.find((type: DataType): boolean => {
+								return !definedTester(type)
+									|| !stringTester(type)
+									|| !enumTester(type, allDataType);
+							});
+
+							if (itemTypeError) {
+								return new EjvError({
+									type: ErrorType.INVALID_SCHEMES,
+									message: createErrorMsg(ErrorMsg.SCHEMES_HAS_INVALID_TYPE, {
+										placeholders: [itemTypeError]
+									}),
 
-							const partialData : AnyObject = {};
-							const partialSchemes : Scheme[] = [];
+									data: data,
 
-							tempKeyArr.forEach((tempKey : string, i : number) => {
+									errorScheme: scheme,
+									isSchemeError: true
+								});
+							}
+
+
+							const partialData: AnyObject = {};
+							const partialSchemes: Scheme[] = [];
+
+							tempKeyArr.forEach((tempKey: string, i: number): void => {
 								partialData[tempKey] = valueAsArray[i];
 								partialSchemes.push({
-									key : tempKey,
-									type : itemTypes
+									key: tempKey,
+									type: itemTypes
 								});
 							});
 
+							scheme.parent = arrayScheme;
+
 							// call recursively
-							const partialResult : EjvError | null = _ejv(partialData, partialSchemes, _options);
+							const partialResult: EjvError | null = _ejv(partialData, partialSchemes, _options);
 
 							// convert new EjvError
-							if (!!partialResult) {
-								let errorMsg : string;
+							if (partialResult) {
+								let errorMsg: string;
 
-								if (arrayTester(scheme.items)) {
-									errorMsg = ErrorMsg.ITEMS_TYPE.replace(ErrorMsgCursorA, JSON.stringify(itemTypes));
-								} else {
-									errorMsg = ErrorMsg.ITEMS_TYPE.replace(ErrorMsgCursorA, scheme.items as string);
+								if (arrayTester(arrayScheme.items)) {
+									errorMsg = createErrorMsg(ErrorMsg.ITEMS_TYPE, {
+										placeholders: [JSON.stringify(itemTypes)]
+									});
+								}
+								else {
+									errorMsg = createErrorMsg(ErrorMsg.ITEMS_TYPE, {
+										placeholders: [arrayScheme.items as string]
+									});
 								}
 
-								const partialKeys : string[] = partialResult.path.split('/');
-								const partialKey : string = partialKeys[partialKeys.length - 1];
+								const partialKeys: string[] = (partialResult.path || '').split('/');
+								const partialKey: string = partialKeys[partialKeys.length - 1];
 
-								const partialScheme : Scheme = partialSchemes.find(scheme => {
-									return scheme.key === partialKey;
+								const partialScheme: Scheme = partialSchemes.find((_scheme: Scheme): boolean => {
+									return _scheme.key === partialKey;
 								}) as Scheme;
 
-								const partialKeyIndex : number = partialSchemes.indexOf(partialScheme);
+								const partialKeyIndex: number = partialSchemes.indexOf(partialScheme);
+
+								result = new EjvError({
+									type: ErrorType.ITEMS_TYPE,
+									message: errorMsg,
 
-								result = new EjvError(
-									ErrorType.ITEMS_TYPE,
-									errorMsg,
-									[..._options.path, '' + partialKeyIndex],
 									data,
-									partialData[partialKey]
-								);
+									path: [..._options.path, '' + partialKeyIndex],
+
+									errorScheme: partialScheme,
+									errorData: partialData[partialKey]
+								});
 							}
 							break;
-						} else if ((objectTester(scheme.items) && scheme.items !== null) // by Scheme
-							|| (arrayTester(scheme.items) && arrayTypeOfTester(scheme.items as Scheme[], DataType.OBJECT)) // by Scheme[]
+						}
+						else if ((objectTester(arrayScheme.items) && arrayScheme.items !== null) // by Scheme
+							|| (arrayTester(arrayScheme.items) && arrayTypeOfTester(arrayScheme.items as Scheme[], DataType.OBJECT)) // by Scheme[]
 						) {
-							const itemsAsSchemes : Scheme[] = (arrayTester(scheme.items) ? scheme.items : [scheme.items]) as Scheme[];
+							const itemsAsSchemes: Scheme[] = arrayTester(arrayScheme.items)
+								? arrayScheme.items
+								: [arrayScheme.items] as Scheme[];
 
-							let partialError : EjvError | null | undefined = null;
+							let partialError: EjvError | null | undefined = null;
 
 							// use for() instead of forEach() to break
-							const valueLength : number = valueAsArray.length;
+							const valueLength: number = valueAsArray.length;
 
 							for (let arrIndex = 0; arrIndex < valueLength; arrIndex++) {
-								const oneValue : any = valueAsArray[arrIndex];
+								const oneValue: unknown = valueAsArray[arrIndex];
 
-								const partialData : AnyObject = {};
-								const partialSchemes : Scheme[] = [];
+								const partialData: AnyObject = {};
+								const partialSchemes: Scheme[] = [];
 
-								const tempKeyForThisValue : string = tempKeyArr[arrIndex];
+								const tempKeyForThisValue: string = tempKeyArr[arrIndex];
 
 								partialData[tempKeyForThisValue] = oneValue;
 
-								partialSchemes.push(...itemsAsSchemes.map((oneScheme : Scheme) => {
-									const newScheme : Scheme = clone(oneScheme); // divide instance
+								partialSchemes.push(...itemsAsSchemes.map((oneScheme: Scheme): Scheme => {
+									const newScheme: Scheme = clone(oneScheme); // divide instance
 
 									newScheme.key = tempKeyForThisValue;
 
 									return newScheme;
 								}));
 
-								const partialResults : (EjvError | null)[] = partialSchemes.map((partialScheme : Scheme) => {
+								const partialResults: (EjvError | null)[] = partialSchemes.map((partialScheme: Scheme): EjvError | null => {
 									// call recursively
-									const partialResult : EjvError | null = _ejv(partialData, [partialScheme], _options);
+									const partialResult: EjvError | null = _ejv(partialData, [partialScheme], _options);
 
-									if (!!partialResult) {
-										partialResult.path = partialResult.path.replace(tempKeyForThisValue, '' + arrIndex);
+									if (partialResult) {
+										partialResult.path = (partialResult.path || '').replace(tempKeyForThisValue, '' + arrIndex);
 									}
 
 									return partialResult;
 								});
 
-								if (!partialResults.some(oneResult => oneResult === null)) {
-									partialError = partialResults.find(oneResult => {
+								if (!partialResults.some((oneResult: EjvError | null): boolean => oneResult === null)) {
+									partialError = partialResults.find((oneResult: EjvError | null): boolean => {
 										return !!oneResult;
-									});
+									}) as EjvError;
 									break;
 								}
 							}
 
-							if (!!partialError) {
-								let errorType : ErrorType;
-								let errorMsg : string;
+							if (partialError) {
+								let errorType: ErrorType;
+								let errorMsg: string;
 
 								if (!!itemsAsSchemes && itemsAsSchemes.length > 1) {
 									errorType = ErrorType.ITEMS_SCHEMES;
-									errorMsg = ErrorMsg.ITEMS_SCHEMES.replace(ErrorMsgCursorA, JSON.stringify(itemsAsSchemes));
-								} else {
+									errorMsg = createErrorMsg(ErrorMsg.ITEMS_SCHEMES, {
+										placeholders: [JSON.stringify(itemsAsSchemes)]
+									});
+								}
+								else {
 									errorType = partialError.type;
 									errorMsg = partialError.message;
 
 									if (errorType === ErrorType.REQUIRED) {
 										// REQUIRED in array is TYPE_MISMATCH except with nullable === true
 										errorType = ErrorType.TYPE_MISMATCH;
-										errorMsg = ErrorMsg.TYPE_MISMATCH.replace(ErrorMsgCursorA, JSON.stringify(scheme.items));
+										errorMsg = createErrorMsg(ErrorMsg.TYPE_MISMATCH, {
+											placeholders: [JSON.stringify(arrayScheme.items)]
+										});
 									}
 								}
 
-								result = new EjvError(
-									errorType,
-									errorMsg,
-									partialError.path.split('/'),
-									data,
-									partialError.errorData
-								);
+								result = new EjvError({
+									type: errorType,
+									message: errorMsg,
+
+									data
+								});
+
+								if (errorType === ErrorType.INVALID_SCHEMES) {
+									result.errorScheme = arrayScheme;
+									result.isSchemeError = true;
+									result.isDataError = false;
+								}
+								else {
+									result.path = partialError.path;
+									result.errorData = partialError.errorData;
+								}
 								break;
 							}
-						} else {
-							throw new Error(ErrorMsg.INVALID_ITEMS_SCHEME.replace(ErrorMsgCursorA, JSON.stringify(scheme.items)));
+						}
+						else {
+							return new EjvError({
+								type: ErrorType.INVALID_SCHEMES,
+								message: createErrorMsg(ErrorMsg.INVALID_ITEMS_SCHEME, {
+									placeholders: [JSON.stringify(arrayScheme.items)]
+								}),
+
+								data: data,
+
+								errorScheme: arrayScheme,
+								isSchemeError: true
+							});
 						}
 					}
 				}
 				break;
+			}
 		}
 
-		if (!!result) {
+		if (result) {
 			break;
 		}
 	}
 
-	if (definedTester(result) && definedTester(options.customErrorMsg)) {
-		const resultAsNotNull : EjvError = result as NonNullable<EjvError>;
-		const customErrorMsgObj : {
-			[key in ErrorType]? : string;
+	if (result !== null && definedTester(options.customErrorMsg)) {
+		const customErrorMsgObj: {
+			[key in ErrorType]?: string;
 		} = options.customErrorMsg as {
-			[key in ErrorType]? : string;
+			[key in ErrorType]?: string;
 		};
 
 		// override error message
-		const customMsg : string = customErrorMsgObj[resultAsNotNull.type] as string;
+		const customMsg: string | undefined = customErrorMsgObj[result.type];
 
 		if (definedTester(customMsg)) {
-			resultAsNotNull.message = customMsg;
+			result.message = customMsg;
 		}
 	}
 
 	return result;
 };
 
-export const ejv = (data : object, schemes : Scheme[], options? : Options) : null | EjvError => {
+export const ejv = (data: object, schemes: Scheme[], options?: Options): null | EjvError => {
 	// check data itself
 	if (!definedTester(data) || !objectTester(data) || data === null) {
-		return new EjvError(ErrorType.REQUIRED, ErrorMsg.NO_DATA, ['/'], data, undefined);
-	}
+		return new EjvError({
+			type: ErrorType.NO_DATA,
+			message: ErrorMsg.NO_DATA,
 
-	// check schemes itself
-	if (!definedTester(schemes) || schemes === null) {
-		throw new Error(ErrorMsg.NO_SCHEME);
-	}
-
-	if (!arrayTester(schemes)) {
-		throw new Error(ErrorMsg.NO_ARRAY_SCHEME);
+			data: data,
+			errorData: data
+		});
 	}
 
-	if (!arrayTypeOfTester(schemes, DataType.OBJECT)) {
-		throw new Error(ErrorMsg.NO_OBJECT_ARRAY_SCHEME);
-	}
+	const internalOption: InternalOptions = (options
+		? {
+			...options
+		}
+		: {}) as InternalOptions;
 
-	if (!minLengthTester(schemes, 1)) {
-		throw new Error(ErrorMsg.EMPTY_SCHEME);
+	if (!definedTester(internalOption.path)) {
+		internalOption.path = [];
 	}
 
-	return _ejv(data, schemes, options as InternalOptions);
+	return _ejv(data, schemes, internalOption);
 };