ejv 2.1.4 → 2.1.5

package/spec/StringScheme.ts

@@ -6,13 +6,13 @@ import { ejv } from '../src/ejv';
 import { EjvError, Scheme } from '../src/interfaces';
 import { ERROR_MESSAGE, ERROR_TYPE } from '../src/constants';
 import { createErrorMsg } from '../src/util';
-import { checkSchemeError, TypeTester, typeTesterArr } from './common-test-util';
+import { checkSchemeError, TypeTester, TYPE_TESTER_ARR } from './common-test-util';
 
 
 describe('StringScheme', () => {
 	describe('type', () => {
 		describe('mismatch', () => {
-			typeTesterArr
+			TYPE_TESTER_ARR
 				.filter((obj: TypeTester): boolean => obj.type !== 'string')
 				.forEach((obj: TypeTester): void => {
 					const data = {
@@ -129,7 +129,8 @@ describe('StringScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'string',
-						enum: null as unknown as string[]
+						// @ts-expect-error: null
+						enum: null
 					};
 
 					checkSchemeError({
@@ -143,7 +144,8 @@ describe('StringScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'string',
-						enum: 'a' as unknown as string[]
+						// @ts-expect-error: type mismatch
+						enum: 'a'
 					};
 
 					checkSchemeError({
@@ -225,7 +227,8 @@ describe('StringScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'string',
-						notEnum: null as unknown as string[]
+						// @ts-expect-error: null
+						notEnum: null
 					};
 
 					checkSchemeError({
@@ -239,7 +242,8 @@ describe('StringScheme', () => {
 					const errorScheme: Scheme = {
 						key: 'a',
 						type: 'string',
-						notEnum: 'a' as unknown as string[]
+						// @ts-expect-error: type mismatch
+						notEnum: 'a'
 					};
 
 					checkSchemeError({
@@ -322,7 +326,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					length: null as unknown as number
+					// @ts-expect-error: null
+					length: null
 				};
 
 				checkSchemeError({
@@ -336,7 +341,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					length: '3' as unknown as number
+					// @ts-expect-error: type mismatch
+					length: '3'
 				};
 
 				checkSchemeError({
@@ -402,7 +408,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					minLength: null as unknown as number
+					// @ts-expect-error: type mismatch
+					minLength: null
 				};
 
 				checkSchemeError({
@@ -430,7 +437,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					minLength: '1' as unknown as number
+					// @ts-expect-error: type mismatch
+					minLength: '1'
 				};
 
 				checkSchemeError({
@@ -504,7 +512,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					maxLength: null as unknown as number
+					// @ts-expect-error: null
+					maxLength: null
 				};
 
 				checkSchemeError({
@@ -532,7 +541,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					maxLength: '1' as unknown as number
+					// @ts-expect-error: type mismatch
+					maxLength: '1'
 				};
 
 				checkSchemeError({
@@ -606,7 +616,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					format: null as unknown as string
+					// @ts-expect-error: null
+					format: null
 				};
 
 				checkSchemeError({
@@ -1064,7 +1075,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					pattern: null as unknown as string
+					// @ts-expect-error: null
+					pattern: null
 				};
 
 				checkSchemeError({
@@ -1080,7 +1092,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					pattern: 1 as unknown as string
+					// @ts-expect-error: type mismatch
+					pattern: 1
 				};
 
 				checkSchemeError({
@@ -1128,7 +1141,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					pattern: [null as unknown as RegExp, /ab/]
+					// @ts-expect-error: type mismatch
+					pattern: [null, /ab/]
 				};
 
 				checkSchemeError({
@@ -1144,7 +1158,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					pattern: [1, 3] as unknown as string[]
+					// @ts-expect-error: type mismatch
+					pattern: [1, 3]
 				};
 
 				checkSchemeError({
@@ -1192,7 +1207,8 @@ describe('StringScheme', () => {
 				const errorScheme: Scheme = {
 					key: 'a',
 					type: 'string',
-					pattern: new RegExp(null as unknown as string)
+					// @ts-expect-error: type mismatch
+					pattern: new RegExp(null)
 				};
 
 				checkSchemeError({

package/spec/common-test-util.ts

@@ -6,7 +6,7 @@ import { EjvError, Scheme } from '../src/interfaces';
 import { ejv } from '../src/ejv';
 import { ERROR_TYPE } from '../src/constants';
 
-export const commonTestRunner = (
+export function commonTestRunner (
 	testFnc: (args: unknown) => unknown,
 	nullResult: boolean,
 	undefinedResult: boolean,
@@ -14,38 +14,41 @@ export const commonTestRunner = (
 	numberResult: boolean,
 	stringResult: boolean,
 	arrayResult: boolean,
-	objectResult: boolean
-): boolean => {
+	objectResult: boolean,
+	bufferResult: boolean
+): boolean {
 	return testFnc(null) === nullResult
 		&& testFnc(undefined) === undefinedResult
 		&& testFnc(true) === booleanResult
 		&& testFnc(8) === numberResult
 		&& testFnc('hello') === stringResult
 		&& testFnc([1, 2, 3]) === arrayResult
-		&& testFnc({ a: 1 }) === objectResult;
-};
+		&& testFnc({ a: 1 }) === objectResult
+		&& testFnc(new Uint8Array(3)) === bufferResult;
+}
 
 export interface TypeTester {
 	type: string;
 	value: unknown;
 }
 
-export const typeTesterArr: TypeTester[] = [
+export const TYPE_TESTER_ARR: TypeTester[] = [
 	{ type: 'boolean', value: true },
 	{ type: 'number', value: 123 },
 	{ type: 'string', value: 'ejv' },
 	{ type: 'object', value: {} },
 	{ type: 'date', value: new Date },
 	{ type: 'regexp', value: new RegExp('ejv') },
-	{ type: 'array', value: [1, 2, 3] }
+	{ type: 'array', value: [1, 2, 3] },
+	{ type: 'buffer', value: new Uint8Array(5) }
 ];
 
 
-export const checkSchemeError = (param: {
+export function checkSchemeError (param: {
 	data: object,
 	errorScheme: Scheme,
 	message: string,
-}): void => {
+}): void {
 	const ejvError: EjvError | null = ejv(param.data, [param.errorScheme]);
 
 	expect(ejvError).to.be.instanceOf(EjvError);
@@ -60,4 +63,4 @@ export const checkSchemeError = (param: {
 
 	expect(ejvError).to.have.property('isSchemeError', true);
 	expect(ejvError).to.have.property('isDataError', false);
-};
+}

package/spec/testers.spec.ts

@@ -7,6 +7,7 @@ import {
 	arrayTester,
 	arrayTypeOfTester,
 	booleanTester,
+	bufferTester,
 	dateFormatTester,
 	dateTester,
 	dateTimeFormatTester,
@@ -49,6 +50,7 @@ describe('testers', function () {
 					true,
 					true,
 					true,
+					true,
 					true
 				)).to.be.true;
 			});
@@ -112,6 +114,7 @@ describe('testers', function () {
 					false,
 					false,
 					false,
+					false,
 					false
 				)).to.be.true;
 			});
@@ -140,6 +143,7 @@ describe('testers', function () {
 					true,
 					false,
 					false,
+					false,
 					false
 				)).to.be.true;
 			});
@@ -257,6 +261,7 @@ describe('testers', function () {
 					false,
 					true,
 					false,
+					false,
 					false
 				)).to.be.true;
 			});
@@ -603,7 +608,8 @@ describe('testers', function () {
 					false,
 					false,
 					true, // array is object
-					true
+					true,
+					true // buffer is object
 				)).to.be.true;
 			});
 
@@ -644,6 +650,7 @@ describe('testers', function () {
 					false,
 					false,
 					false,
+					false,
 					false
 				)).to.be.true;
 			});
@@ -778,6 +785,7 @@ describe('testers', function () {
 					false,
 					false,
 					true,
+					false,
 					false
 				)).to.be.true;
 			});
@@ -818,6 +826,7 @@ describe('testers', function () {
 					false,
 					false,
 					false,
+					false,
 					false
 				)).to.be.true;
 			});
@@ -830,4 +839,29 @@ describe('testers', function () {
 			});
 		});
 	});
+
+	describe('buffer', () => {
+		describe('bufferTester()', () => {
+			it('common test', () => {
+				expect(commonTestRunner(
+					bufferTester,
+					false,
+					false,
+					false,
+					false,
+					false,
+					false,
+					false,
+					true
+				)).to.be.true;
+			});
+
+			it('logic test', () => {
+				expect(bufferTester(new Uint8Array)).to.be.true;
+				expect(bufferTester(new Uint16Array)).to.be.true;
+				expect(bufferTester(new Uint32Array)).to.be.true;
+				expect(bufferTester(Buffer.from('hello'))).to.be.true;
+			});
+		});
+	});
 });

package/src/constants.ts

@@ -5,7 +5,8 @@ export enum DATA_TYPE {
 	OBJECT = 'object',
 	DATE = 'date',
 	REGEXP = 'regexp',
-	ARRAY = 'array'
+	ARRAY = 'array',
+	BUFFER = 'buffer'
 }
 
 export enum NUMBER_FORMAT {
@@ -58,6 +59,10 @@ export enum ERROR_TYPE {
 	MIN_LENGTH = 'MIN_LENGTH',
 	MAX_LENGTH = 'MAX_LENGTH',
 
+	BYTE_LENGTH = 'BYTE_LENGTH',
+	MIN_BYTE_LENGTH = 'MIN_BYTE_LENGTH',
+	MAX_BYTE_LENGTH = 'MAX_BYTE_LENGTH',
+
 	PATTERN = 'PATTERN',
 	PATTERN_ONE_OF = 'PATTERN_ONE_OF',
 
@@ -110,6 +115,10 @@ export enum ERROR_MESSAGE {
 	MIN_LENGTH_SHOULD_BE_INTEGER = 'minLength should be a integer',
 	MAX_LENGTH_SHOULD_BE_INTEGER = 'maxLength should be a integer',
 
+	BYTE_LENGTH_SHOULD_BE_INTEGER = 'byteLength should be a integer',
+	MIN_BYTE_LENGTH_SHOULD_BE_INTEGER = 'minByteLength should be a integer',
+	MAX_BYTE_LENGTH_SHOULD_BE_INTEGER = 'maxByteLength should be a integer',
+
 	PROPERTIES_SHOULD_BE_ARRAY = 'properties should be array',
 	PROPERTIES_SHOULD_HAVE_ITEMS = 'properties should have items',
 	PROPERTIES_SHOULD_BE_ARRAY_OF_OBJECT = 'properties should be array of object',
@@ -145,6 +154,10 @@ export enum ERROR_MESSAGE {
 	MIN_LENGTH = 'the value should be longer than <<1>>', // minLength
 	MAX_LENGTH = 'the value should be shorter than <<1>>', // maxLength
 
+	BYTE_LENGTH = 'the byte length of value should be <<1>>', // length
+	MIN_BYTE_LENGTH = 'the byte length of value should be longer than <<1>>', // minLength
+	MAX_BYTE_LENGTH = 'the byte length of value should be shorter than <<1>>', // maxLength
+
 	PATTERN = 'the value should be pattern of <<1>>', // pattern
 	PATTERN_ONE_OF = 'the value should be one of pattern of <<1>>', // pattern
 

package/src/ejv.ts

@@ -2,6 +2,8 @@ import {
 	AllDataType,
 	AnyObject,
 	ArrayScheme,
+	BufferLike,
+	BufferScheme,
 	DateScheme,
 	EjvError,
 	InternalOptions,
@@ -17,6 +19,7 @@ import {
 	arrayTester,
 	arrayTypeOfTester,
 	booleanTester,
+	bufferLengthTester,
 	dateFormatTester,
 	dateTester,
 	dateTimeFormatTester,
@@ -32,9 +35,11 @@ import {
 	integerTester,
 	jsonStrTester,
 	lengthTester,
+	maxByteLengthTester,
 	maxDateTester,
 	maxLengthTester,
 	maxNumberTester,
+	minByteLengthTester,
 	minDateTester,
 	minLengthTester,
 	minNumberTester,
@@ -1695,6 +1700,108 @@ const _ejv = <T> (data: T, schemes: Scheme[], options: InternalOptions): null |
 				}
 				break;
 			}
+
+			case DATA_TYPE.BUFFER: {
+				const valueAsBuffer: BufferLike = value as unknown as BufferLike;
+				const bufferScheme: BufferScheme = scheme as BufferScheme;
+
+				if (definedTester(bufferScheme.byteLength)) {
+					const length: number = bufferScheme.byteLength;
+
+					if (!(numberTester(length) && integerTester(length))) {
+						return new EjvError({
+							type: ERROR_TYPE.INVALID_SCHEMES,
+							message: createErrorMsg(ERROR_MESSAGE.BYTE_LENGTH_SHOULD_BE_INTEGER),
+
+							data: data,
+
+							errorScheme: bufferScheme,
+							isSchemeError: true
+						});
+					}
+
+					if (!bufferLengthTester(valueAsBuffer, length)) {
+						result = new EjvError({
+							type: ERROR_TYPE.BYTE_LENGTH,
+							message: createErrorMsg(ERROR_MESSAGE.BYTE_LENGTH, {
+								placeholders: ['' + length]
+							}),
+
+							data,
+							path: _options.path,
+
+							errorScheme: bufferScheme,
+							errorData: value
+						});
+						break;
+					}
+				}
+
+				if (definedTester(bufferScheme.minByteLength)) {
+					const minLength: number = bufferScheme.minByteLength;
+
+					if (!(numberTester(bufferScheme.minByteLength) && integerTester(minLength))) {
+						return new EjvError({
+							type: ERROR_TYPE.INVALID_SCHEMES,
+							message: createErrorMsg(ERROR_MESSAGE.MIN_BYTE_LENGTH_SHOULD_BE_INTEGER),
+
+							data: data,
+
+							errorScheme: bufferScheme,
+							isSchemeError: true
+						});
+					}
+
+					if (!minByteLengthTester(valueAsBuffer, minLength)) {
+						result = new EjvError({
+							type: ERROR_TYPE.MIN_BYTE_LENGTH,
+							message: createErrorMsg(ERROR_MESSAGE.MIN_BYTE_LENGTH, {
+								placeholders: ['' + minLength]
+							}),
+
+							data,
+							path: _options.path,
+
+							errorScheme: bufferScheme,
+							errorData: value
+						});
+						break;
+					}
+				}
+
+				if (definedTester(bufferScheme.maxByteLength)) {
+					const maxLength: number = bufferScheme.maxByteLength;
+
+					if (!(numberTester(bufferScheme.maxByteLength) && integerTester(maxLength))) {
+						return new EjvError({
+							type: ERROR_TYPE.INVALID_SCHEMES,
+							message: createErrorMsg(ERROR_MESSAGE.MAX_BYTE_LENGTH_SHOULD_BE_INTEGER),
+
+							data: data,
+
+							errorScheme: bufferScheme,
+							isSchemeError: true
+						});
+					}
+
+					if (!maxByteLengthTester(valueAsBuffer, maxLength)) {
+						result = new EjvError({
+							type: ERROR_TYPE.MAX_BYTE_LENGTH,
+							message: createErrorMsg(ERROR_MESSAGE.MAX_BYTE_LENGTH, {
+								placeholders: ['' + maxLength]
+							}),
+
+							data,
+							path: _options.path,
+
+							errorScheme: bufferScheme,
+							errorData: value
+						});
+						break;
+					}
+				}
+				break;
+			}
 		}
 
 		if (result) {
@@ -1720,7 +1827,7 @@ const _ejv = <T> (data: T, schemes: Scheme[], options: InternalOptions): null |
 	return result;
 };
 
-export const ejv = (data: object, schemes: Scheme[], options?: Options): null | EjvError => {
+export function ejv (data: object, schemes: Scheme[], options?: Options): null | EjvError {
 	// check data itself
 	if (!definedTester(data) || !objectTester(data) || data === null) {
 		return new EjvError({
@@ -1748,4 +1855,4 @@ export const ejv = (data: object, schemes: Scheme[], options?: Options): null |
 	}
 
 	return _ejv(data, schemes, internalOption);
-};
+}

package/src/interfaces.ts

@@ -66,6 +66,17 @@ export interface ArrayScheme extends CommonScheme {
 	maxLength?: number;
 }
 
+
+export type BufferLike = ArrayBuffer
+	| SharedArrayBuffer
+	| Exclude<ArrayBufferView, DataView>;
+
+export interface BufferScheme extends CommonScheme {
+	byteLength?: number;
+	minByteLength?: number;
+	maxByteLength?: number;
+}
+
 export type Scheme =
 	BooleanScheme
 	| NumberScheme
@@ -73,7 +84,8 @@ export type Scheme =
 	| ObjectScheme
 	| DateScheme
 	| RegExpScheme
-	| ArrayScheme;
+	| ArrayScheme
+	| BufferScheme;
 
 
 export interface Options {