ejv 1.1.10 → 2.0.0

package/src/index.ts

@@ -0,0 +1,14 @@
+export { ejv } from './ejv';
+export { DataType, NumberFormat, StringFormat, ErrorMsg, ErrorType } from './constants';
+export {
+	BooleanScheme,
+	NumberScheme,
+	StringScheme,
+	ObjectScheme,
+	ArrayScheme,
+	RegExpScheme,
+	DateScheme,
+	EjvError,
+	Scheme,
+	Options
+} from './interfaces';

package/src/interfaces.ts

@@ -1,63 +1,149 @@
 import { DataType, ErrorType, NumberFormat, StringFormat } from './constants';
 
-// use common Scheme for multiple types
-export interface Scheme {
-	// common
-	key? : string; // can be omitted in array items
-	type : string | string[] | DataType | DataType[];
-	optional? : boolean; // false
-	nullable? : boolean; // false
-	// reverse? not?
+export type AllDataType = string | string[] | DataType | DataType[];
 
-	// common - number & Date (date string, Date)
-	min? : number | string | Date;
-	exclusiveMin? : boolean; // false
 
-	max? : number | string | Date;
-	exclusiveMax? : boolean; // false
+interface CommonScheme {
+	parent?: Scheme;
 
-	// common - number & string
-	enum? : number[] | string[];
-	enumReverse? : number[] | string[];
+	key?: string; // can be omitted in array items
+	type?: AllDataType; // optional for not
 
-	// common - number & string
-	format? : string | string[] | NumberFormat | NumberFormat[] | StringFormat | StringFormat[];
+	optional?: boolean; // false
+	nullable?: boolean; // false
+}
+
+// no additional rule
+export type BooleanScheme = CommonScheme;
+
+export interface MinMax<T> {
+	min?: T;
+	exclusiveMin?: boolean; // default false
+
+	max?: T;
+	exclusiveMax?: boolean; // default false
+}
+
+export interface MinMaxScheme<T> extends CommonScheme, MinMax<T> {
+}
+
+export interface NumberScheme extends MinMaxScheme<number> {
+	value?: number; // TODO: need to add
+
+	enum?: number[];
+
+	format?: string | string[] | NumberFormat | NumberFormat[];
+}
+
+export interface StringScheme extends CommonScheme {
+	value?: string; // TODO: need to add
+
+	enum?: string[];
+
+	format?: string | string[] | StringFormat | StringFormat[];
+	pattern?: string | string[] | RegExp | RegExp[];
+
+	length?: number;
+	minLength?: number;
+	maxLength?: number;
+}
+
+export interface ObjectScheme extends CommonScheme {
+	properties?: Scheme[];
+	allowNoProperty?: boolean; // true
+}
 
-	// common - string & array
-	length? : number;
-	minLength? : number;
-	maxLength? : number;
 
-	// string
-	pattern? : string | string[] | RegExp | RegExp[];
+/* eslint-disable @typescript-eslint/no-empty-interface */
+export interface DateScheme extends MinMaxScheme<string | Date> {
+	// min, max string for date string
+}
+
+// no additional rule
+export type RegExpScheme = CommonScheme;
 
-	// object
-	properties? : Scheme[];
-	allowNoProperty? : boolean; // true
+export interface ArrayScheme extends CommonScheme {
+	unique?: boolean; // false
+	items?: AllDataType | Scheme | Scheme[];
 
-	// array
-	unique? : boolean; // false
-	items? : string | string[] | DataType | DataType[] | Scheme | Scheme[];
+	length?: number;
+	minLength?: number;
+	maxLength?: number;
 }
 
+export type Scheme =
+	BooleanScheme
+	| NumberScheme
+	| StringScheme
+	| ObjectScheme
+	| DateScheme
+	| RegExpScheme
+	| ArrayScheme;
+
+
 export interface Options {
-	customErrorMsg? : {
-		[key in ErrorType]? : string;
+	customErrorMsg?: {
+		[key in ErrorType]?: string;
 	};
 }
 
 export interface InternalOptions extends Options {
-	path : string[];
+	path: string[];
 }
 
 export class EjvError {
-	public path : string;
-
-	constructor (public type : ErrorType,
-	             public message : string,
-	             path : string[],
-	             public data : any,
-	             public errorData : any) {
-		this.path = path.join('/');
+	public type: ErrorType;
+	public message: string;
+
+	public data: unknown;
+	public path: string | undefined;
+
+	public errorScheme: Scheme | undefined;
+	public errorData: unknown | undefined;
+
+	public isSchemeError: boolean;
+	public isDataError: boolean;
+
+	constructor (param: {
+		type: ErrorType,
+		message: string,
+
+		data: unknown,
+		path?: string[],
+
+		errorScheme?: Scheme,
+		errorData?: unknown,
+
+		isSchemeError?: boolean
+	}) {
+		this.type = param.type;
+		this.message = param.message;
+
+		this.data = param.data;
+
+		if ('path' in param && param.path !== undefined) {
+			this.path = param.path.join('/');
+		}
+
+		if ('errorScheme' in param) {
+			this.errorScheme = param.errorScheme;
+		}
+
+		if ('errorData' in param) {
+			this.errorData = param.errorData;
+		}
+
+		if (param.isSchemeError) {
+			this.isSchemeError = true;
+			this.isDataError = false;
+		}
+		else {
+			this.isSchemeError = false;
+			this.isDataError = true;
+		}
 	}
 }
+
+export interface AnyObject {
+	[key: string]: unknown;
+}

package/src/tester.ts

@@ -1,7 +1,8 @@
 import { DataType } from './constants';
+import { AnyObject } from './interfaces';
 
-export const typeTester = (value : any, type : DataType) : boolean => {
-	let valid : boolean;
+export const typeTester = (value: unknown, type: DataType): boolean => {
+	let valid: boolean;
 
 	switch (type) {
 		case DataType.BOOLEAN:
@@ -36,66 +37,66 @@ export const typeTester = (value : any, type : DataType) : boolean => {
 	return valid;
 };
 
-export const definedTester = (value : any) : value is boolean => {
+export const definedTester = (value: unknown): value is boolean => {
 	return value !== undefined;
 };
 
-export const enumTester = <T> (value : T, arr : T[]) : boolean => {
+export const enumTester = <T> (value: T, arr: T[]): boolean => {
 	return arr.includes(value);
 };
 
-export const lengthTester = (value : string | any[], length : number) : boolean => {
+export const lengthTester = (value: string | unknown[], length: number): boolean => {
 	return value.length === length;
 };
 
-export const minLengthTester = (value : string | any[], minLength : number) : boolean => {
+export const minLengthTester = (value: string | unknown[], minLength: number): boolean => {
 	return value.length >= minLength;
 };
 
-export const maxLengthTester = (value : string | any[], maxLength : number) : boolean => {
+export const maxLengthTester = (value: string | unknown[], maxLength: number): boolean => {
 	return value.length <= maxLength;
 };
 
-export const booleanTester = (value : any) : boolean => {
+export const booleanTester = (value: unknown): value is boolean => {
 	return typeof value === 'boolean';
 };
 
-export const numberTester = (value : any) : value is number => {
+export const numberTester = (value: unknown): value is number => {
 	return typeof value === 'number' && !isNaN(value);
 };
 
-export const integerTester = (value : number) : boolean => {
+export const integerTester = (value: number): boolean => {
 	return +value.toFixed(0) === value;
 };
 
-export const indexTester = (value : number) : value is number => {
+export const indexTester = (value: number): value is number => {
 	return integerTester(value) && value >= 0;
 };
 
-export const minNumberTester = (value : number, min : number) : boolean => {
+export const minNumberTester = (value: number, min: number): boolean => {
 	return value >= min;
 };
 
-export const exclusiveMinNumberTester = (value : number, min : number) : boolean => {
+export const exclusiveMinNumberTester = (value: number, min: number): boolean => {
 	return value > min;
 };
 
-export const maxNumberTester = (value : number, max : number) : boolean => {
+export const maxNumberTester = (value: number, max: number): boolean => {
 	return value <= max;
 };
 
-export const exclusiveMaxNumberTester = (value : number, max : number) : boolean => {
+export const exclusiveMaxNumberTester = (value: number, max: number): boolean => {
 	return value < max;
 };
 
-export const stringTester = (value : any) : value is string => {
+export const stringTester = (value: unknown): value is string => {
 	return typeof value === 'string';
 };
 
-export const stringRegExpTester = (value : string, regExp : string | RegExp) : boolean => {
-	let valid : boolean = false;
+export const stringRegExpTester = (value: string, regExp: string | RegExp): boolean => {
+	let valid = false;
 
-	let _regExp : RegExp | undefined = undefined;
+	let _regExp: RegExp | undefined = undefined;
 
 	if (regExpTester(regExp)) {
 		_regExp = regExp as RegExp;
@@ -112,30 +113,30 @@ export const stringRegExpTester = (value : string, regExp : string | RegExp) : b
 };
 
 // RFC 5322, 3.4.1. spec
-export const emailTester = (value : string) : boolean => {
-	let valid : boolean = false;
+export const emailTester = (value: string): boolean => {
+	let valid = false;
 
 	if (stringTester(value) && stringRegExpTester(value, /^.+@.+$/)) {
-		const valueAsString : string = value as string;
+		const valueAsString: string = value as string;
 
-		const atIndex : number = valueAsString.lastIndexOf('@');
-		const localPart : string = valueAsString.substr(0, atIndex);
-		const domain : string = valueAsString.substr(atIndex + 1);
+		const atIndex: number = valueAsString.lastIndexOf('@');
+		const localPart: string = valueAsString.substr(0, atIndex);
+		const domain: string = valueAsString.substr(atIndex + 1);
 
 		// regular expression sources
 		// const aTextRegExpStr : string = '[-a-zA-Z0-9!#$%&\\\'*+/=?^_`{|}~]+';
 
-		const dotAtomRegExp : RegExp = /^(\.?[-a-zA-Z0-9!#$%&'*+/=?^_`{|}~]+)*$/;
-		const quotedStringRegExp : RegExp = /^"[\u0020-\u005b\u005d-\u007e\\]*"$/; // include space (\u005b)
-		const domainLiteralRegExp : RegExp = /^\[[\u0020-\u005a\u005c-\u007e\\]*]$/;
+		const dotAtomRegExp = /^(\.?[-a-zA-Z0-9!#$%&'*+/=?^_`{|}~]+)*$/;
+		const quotedStringRegExp = /^"[\u0020-\u005b\u005d-\u007e\\]*"$/; // include space (\u005b)
+		const domainLiteralRegExp = /^\[[\u0020-\u005a\u005c-\u007e\\]*]$/;
 
-		const validLocalPart : boolean = localPart.length <= 64
+		const validLocalPart: boolean = localPart.length <= 64
 			&& (
 				dotAtomRegExp.test(localPart)
 				|| quotedStringRegExp.test(localPart)
 			);
 
-		const validDomain : boolean = !domain.startsWith('.') && !domain.endsWith('.')
+		const validDomain: boolean = !domain.startsWith('.') && !domain.endsWith('.')
 			&& (
 				dotAtomRegExp.test(domain)
 				|| domainLiteralRegExp.test(domain)
@@ -148,17 +149,17 @@ export const emailTester = (value : string) : boolean => {
 };
 
 // RFC 3339 (https://www.ietf.org/rfc/rfc3339.txt) : YYYY-MM-DDThh:mm:ss[.SSSZ]
-const rfc3339Tester = (value : string) : boolean => {
+const rfc3339Tester = (value: string): boolean => {
 	return /^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([0-1][0-9]|2[0-3])(:([0-5][0-9])){2}(\.\d+)?(Z|[-+]\d{2}:\d{2})?$/.test(value);
 };
 
-const iso8601DateTester = (value : string) : boolean => {
-	const years : string = '(\\d{4})';
-	const months : string = '(0[1-9]|1[0-2])';
-	const dates : string = '(0[1-9]|[1-2][0-9]|3[0-1])';
-	const dateOfYear : string = '(00[1-9]|0[1-9][0-9]|[1-2]\\d{2}|3[0-5]\\d|36[0-6])'; // 366 for leap year
-	const weeks : string = '(W(0[1-9]|[2-4][0-9]|5[0-3]))';
-	const days : string = '[1-7]';
+const iso8601DateTester = (value: string): boolean => {
+	const years = '(\\d{4})';
+	const months = '(0[1-9]|1[0-2])';
+	const dates = '(0[1-9]|[1-2][0-9]|3[0-1])';
+	const dateOfYear = '(00[1-9]|0[1-9][0-9]|[1-2]\\d{2}|3[0-5]\\d|36[0-6])'; // 366 for leap year
+	const weeks = '(W(0[1-9]|[2-4][0-9]|5[0-3]))';
+	const days = '[1-7]';
 
 	return [
 		new RegExp(`^[-+]?${ years }$`), // years : YYYY, +YYYY, -YYYY
@@ -168,45 +169,49 @@ const iso8601DateTester = (value : string) : boolean => {
 		new RegExp(`^${ years }-${ weeks }(-${ days })?$`), // week dates : YYYY-Www, YYYY-Www-D
 		new RegExp(`^${ years }${ weeks }(${ days })?$`), // week dates : YYYYWww, YYYYWwwD
 		new RegExp(`^${ years }-?${ dateOfYear }$`) // ordinal dates : YYYY-DDD, YYYYDDD
-	].some((regExp : RegExp) => {
+	].some((regExp: RegExp): boolean => {
 		return regExp.test(value);
 	});
 };
 
-const iso8601TimeTester = (value : string) : boolean => {
-	const hours : string = '([0-1]\\d|2[0-3])';
-	const minutes : string = '([0-5]\\d)';
-	const seconds : string = '([0-5]\\d|60)'; // 60 for leap second
-	const ms : string = '(\\.[0-9]+)';
+const iso8601TimeTester = (value: string): boolean => {
+	const hours = '([0-1]\\d|2[0-3])';
+	const minutes = '([0-5]\\d)';
+	const seconds = '([0-5]\\d|60)'; // 60 for leap second
+	const ms = '(\\.[0-9]+)';
 
 	return [
 		new RegExp(`^(${ hours }|24)$`), // hh
 		new RegExp(`^((${ hours }:${ minutes })|24:00)$`), // hh:mm
 		new RegExp(`^((${ hours }:${ minutes }:${ seconds })|24:00:00)$`), // hh:mm:ss
-		new RegExp(`^((${ hours }:${ minutes }:${ seconds }${ ms })|24:00:00\.0+)$`), // hh:mm:ss
+		new RegExp(`^((${ hours }:${ minutes }:${ seconds }${ ms })|24:00:00.0+)$`), // hh:mm:ss
 
 		new RegExp(`^(${ hours }${ minutes }|2400)$`), // hhmm
 		new RegExp(`^(${ hours }${ minutes }${ seconds }|240000)$`), // hhmmss
-		new RegExp(`^(${ hours }${ minutes }${ seconds }${ ms }|240000\.0+)$`) // hhmmss.sss
+		new RegExp(`^(${ hours }${ minutes }${ seconds }${ ms }|240000.0+)$`) // hhmmss.sss
 	]
-		.some((regExp : RegExp) => {
+		.some((regExp: RegExp): boolean => {
 			return regExp.test(value);
 		});
 };
 
-const iso8601DateTimeTester = (value : string) : boolean => {
-	let valid : boolean = false;
+const iso8601DateTimeTester = (value: string): boolean => {
+	let valid = false;
 
 	if (/.+T.+/.test(value) // should have 1 'T'
 		&& /(Z|[-+]\d{2}:?\d{2})$/.test(value) // should end with 'Z' or timezone
 	) {
-		let [date, time] = value.split('T');
+		const dateAndTime: string[] = value.split('T');
+		const date: string = dateAndTime[0];
+		let time: string = dateAndTime[1];
 
 		if (time.endsWith('Z')) {
 			time = time.replace('Z', '');
 		}
 		else {
-			const timezoneStartIndex : number = time.includes('+') ? time.indexOf('+') : time.indexOf('-');
+			const timezoneStartIndex: number = time.includes('+')
+				? time.indexOf('+')
+				: time.indexOf('-');
 
 			time = time.substr(0, timezoneStartIndex);
 		}
@@ -217,15 +222,15 @@ const iso8601DateTimeTester = (value : string) : boolean => {
 	return valid;
 };
 
-export const dateFormatTester = (value : string) : boolean => {
+export const dateFormatTester = (value: string): boolean => {
 	return iso8601DateTester(value);
 };
 
-export const timeFormatTester = (value : string) : boolean => {
+export const timeFormatTester = (value: string): boolean => {
 	return iso8601TimeTester(value);
 };
 
-export const dateTimeFormatTester = (value : string) : boolean => {
+export const dateTimeFormatTester = (value: string): boolean => {
 	return rfc3339Tester(value) || iso8601DateTimeTester(value);
 };
 
@@ -250,53 +255,54 @@ export const dateTimeFormatTester = (value : string) : boolean => {
 // 	return ipv4Tester(value) || ipv6Tester(value);
 // };
 
-export const objectTester = (value : any) : value is { [key : string] : any } => {
+export const objectTester = (value: unknown): boolean => {
 	return typeof value === 'object';
 };
 
-export const hasPropertyTester = (value : object) : boolean => {
+export const hasPropertyTester = (value: AnyObject): boolean => {
 	return Object.keys(value).length > 0;
 };
 
-export const dateTester = (value : any) : value is Date => {
+export const dateTester = (value: unknown): value is Date => {
 	return objectTester(value)
 		&& value !== null
-		&& typeof value.getFullYear === 'function'
+		&& typeof value === 'object'
+		&& value instanceof Date
 		&& !isNaN(value.getFullYear());
 };
 
-export const minDateTester = (value : Date, min : Date) : boolean => {
+export const minDateTester = (value: Date, min: Date): boolean => {
 	return +value >= +min;
 };
 
-export const exclusiveMinDateTester = (value : Date, min : Date) : boolean => {
+export const exclusiveMinDateTester = (value: Date, min: Date): boolean => {
 	return +value > +min;
 };
 
-export const maxDateTester = (value : Date, max : Date) : boolean => {
+export const maxDateTester = (value: Date, max: Date): boolean => {
 	return +value <= +max;
 };
 
-export const exclusiveMaxDateTester = (value : Date, max : Date) : boolean => {
+export const exclusiveMaxDateTester = (value: Date, max: Date): boolean => {
 	return +value < +max;
 };
 
-export const arrayTester = (value : any) : value is any[] => {
+export const arrayTester = (value: unknown): value is unknown[] => {
 	return Array.isArray(value);
 };
 
-export const arrayTypeOfTester = (array : any[], type : DataType) : boolean => {
-	return array.every((item : any) => {
+export const arrayTypeOfTester = (array: unknown[], type: DataType): boolean => {
+	return array.every((item: unknown): boolean => {
 		return typeTester(item, type);
 	});
 };
 
-export const uniqueItemsTester = (array : any[]) : boolean => {
-	return array.every(item => {
-		return array.filter((target : any) => target === item).length === 1;
+export const uniqueItemsTester = (array: unknown[]): boolean => {
+	return array.every((item: unknown): boolean => {
+		return array.filter((target: unknown): boolean => target === item).length === 1;
 	});
 };
 
-export const regExpTester = (value : any) : value is RegExp => {
+export const regExpTester = (value: unknown): value is RegExp => {
 	return value instanceof RegExp;
 };

package/src/util.ts

@@ -1,59 +1,124 @@
-export const clone = (obj : any) : any => {
-	let result : any = null;
-
-	if (!!obj) {
-		let type : string = typeof obj;
-
-		if (type === 'object') {
-			if (obj.push !== undefined && typeof obj.push === 'function') {
-				type = 'array';
-			} else if (obj.getFullYear !== undefined && typeof obj.getFullYear === 'function') {
-				type = 'date';
-			} else if (obj.byteLength !== undefined) {
-				type = 'buffer';
-			} else if (obj.exec !== undefined && obj.test !== undefined) {
-				type = 'regexp';
+import { AnyObject } from './interfaces';
+import { ErrorMsg } from './constants';
+
+
+enum CloneDataType {
+	Boolean = 'boolean',
+	Number = 'number',
+	Function = 'function',
+	String = 'string',
+	Buffer = 'buffer',
+	Object = 'object',
+	Array = 'array',
+	Date = 'date',
+	RegExp = 'regexp'
+}
+
+export const isArray = <T> (value: unknown): value is T[] => {
+	return value !== undefined
+		&& value !== null
+		&& Array.isArray(value);
+};
+
+
+// sanitize removes undefined & null fields from object. default false
+export const clone = <T> (obj: T, sanitize?: boolean): T => {
+	let result !: T;
+
+	if (obj) {
+		let type: CloneDataType = typeof obj as CloneDataType;
+
+		if (type === CloneDataType.Object) {
+			const objAsObject: AnyObject = obj as unknown as AnyObject;
+
+			if (isArray(objAsObject)) {
+				type = CloneDataType.Array;
+			}
+			else if (objAsObject instanceof Date) {
+				type = CloneDataType.Date;
+			}
+			else if (objAsObject instanceof RegExp) {
+				type = CloneDataType.RegExp;
+			}
+			else if (objAsObject.byteLength
+				&& typeof objAsObject.byteLength === 'function') {
+				type = CloneDataType.Buffer;
 			}
 		}
 
 		switch (type) {
-			case 'boolean':
-			case 'number':
-			case 'function':
-			case 'string':
-			case 'buffer':
-				// ok with simple copy
-				result = obj;
-				break;
-
-			case 'regexp':
-				result = new RegExp(obj);
-				break;
-
-			case 'date':
-				result = new Date(obj);
+			case CloneDataType.Date: {
+				const objAsDate: Date = obj as unknown as Date;
+				result = new Date(objAsDate) as unknown as T;
 				break;
+			}
 
-			case 'array':
-				result = [...obj.map((one : any) => {
+			case  CloneDataType.Array: {
+				const objAsArray: unknown[] = obj as unknown as unknown[];
+				result = objAsArray.map((one: unknown): unknown => {
 					return clone(one);
-				})];
+				}) as unknown as T;
 				break;
+			}
 
-			case 'object':
+			case CloneDataType.Object: {
 				// sanitize default false
-				result = {};
+				result = {} as unknown as T;
 
-				Object.keys(obj)
-					.forEach(key => {
-						// recursively call
-						result[key] = clone(obj[key]);
+				const entries: [string, unknown][] = Object.entries(obj)
+					.filter(([, value]): boolean => {
+						return sanitize
+							? value !== undefined && value !== null
+							: true;
 					});
+
+
+				for (const [key, value] of entries) {
+					// call recursively
+					(result as unknown as AnyObject)[key] = clone(value, sanitize);
+				}
 				break;
+			}
+
+			default:
+				// simple copy
+				result = obj;
 		}
-	} else {
+	}
+	else {
 		result = obj; // do not copy null & undefined
 	}
 
 	return result;
-};
+};
+
+
+export const sift = <T> (arr: T[]): T[] => {
+	return arr.reduce((acc: T[], cur: T) => {
+		if (cur !== null && cur !== undefined && !acc.includes(cur)) {
+			acc.push(cur);
+		}
+
+		return acc;
+	}, []);
+};
+
+
+export const createErrorMsg = (errorMsg: ErrorMsg, param?: {
+	placeholders?: (string | number)[]
+}): string => {
+	let result: string = errorMsg;
+
+	if (param?.placeholders) {
+		param.placeholders.forEach((strToReplace: string | number, i: number): void => {
+			result = result.replace(
+				`<<${ i + 1 }>>`,
+				typeof strToReplace === 'string'
+					? strToReplace
+					: '' + strToReplace
+			);
+		});
+	}
+
+	return result;
+};