isvalid 4.0.23 → 4.1.1

package/index.js

@@ -9,4 +9,4 @@
 import validate, { formalize, keyPaths, merge, plugins } from './lib/index.js';
 
 export default validate;
-export { formalize, keyPaths, merge, plugins };
+export { validate, formalize, keyPaths, merge, plugins };

package/lib/errors/aggregated.js

@@ -0,0 +1,18 @@
+//
+// aggregated.js
+//
+// Created by Kristian Trenskow on 2024-03-05
+//
+// See license in LICENSE
+//
+
+import ValidationError from './validation.js';
+
+export default class AggregatedError extends ValidationError {
+
+	constructor(keyPath, schema, validator, message, errors) {
+		super(keyPath, schema, validator, message);
+		this.errors = errors;
+	}
+
+}

package/lib/validate.js

@@ -7,6 +7,7 @@
 //
 
 import ValidationError from './errors/validation.js';
+import AggregatedError from './errors/aggregated.js';
 import { testIndex } from './ranges.js';
 import unique from './unique.js';
 import formalize from './formalize.js';
@@ -64,11 +65,39 @@ const validateObject = async (data, schema, options, keyPath, validatedData) =>
 			return schema.schema[key1].priority - schema.schema[key2].priority;
 		});
 
+		let errors = [];
+
 		for (let key of keys) {
-			let value = await validateAny(data[key], schema.schema[key], options, keyPath.concat([key]), validatedData);
-			if (typeof value !== 'undefined') {
-				data[key] = value;
+
+			try {
+				let value = await validateAny(data[key], schema.schema[key], options, keyPath.concat([key]), validatedData);
+				if (typeof value !== 'undefined') {
+					data[key] = value;
+				}
+			} catch (error) {
+
+				if (options.stopOnFirstError !== false) {
+					throw error;
+				}
+
+				errors.push(error);
+
 			}
+
+		}
+
+		if (errors.length) {
+
+			if (errors.length === 1) throw errors[0];
+
+			throw new AggregatedError(
+				keyPath,
+				schema._nonFormalizedSchema,
+				'object',
+				(schema.errors || {}).object || customErrorMessage(((options.errorMessages || {}).object || {}).object || 'Multiple errors occurred.'),
+				errors
+			);
+
 		}
 
 	}
@@ -97,9 +126,37 @@ const validateArray = async (data, schema, options, keyPath, validatedData) => {
 		}
 
 		if (typeof schema.schema !== 'undefined') {
-			data = await Promise.all(data.map((data, idx) => {
-				return validateAny(data, schema.schema, options, keyPath.concat([idx]), validatedData);
-			}));
+
+			let errors = [];
+
+			for (let idx in data) {
+				try {
+					data[idx] = await validateAny(data[idx], schema.schema, options, keyPath.concat([idx]), validatedData);
+				} catch (error) {
+
+					if (options.stopOnFirstError !== false) {
+						throw error;
+					}
+
+					errors.push(error);
+
+				}
+			}
+
+			if (errors.length) {
+
+				if (errors.length === 1) throw errors[0];
+
+				throw new AggregatedError(
+					keyPath,
+					schema._nonFormalizedSchema,
+					'array',
+					(schema.errors || {}).array || customErrorMessage(((options.errorMessages || {}).array || {}).array || 'Multiple errors occurred.'),
+					errors
+				);
+
+			}
+
 		}
 
 		if ((schema.len || options.defaults.len) && !testIndex((schema.len || options.defaults.len), data.length)) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "isvalid",
-	"version": "4.0.23",
+	"version": "4.1.1",
 	"description": "Async JSON validation library for node.js.",
 	"main": "./index.js",
 	"type": "module",
@@ -21,7 +21,7 @@
 	"devDependencies": {
 		"@trenskow/caseit": "^1.3.11",
 		"body-parser": "^1.20.2",
-		"chai": "^5.0.3",
+		"chai": "^5.1.0",
 		"chai-as-promised": "^7.1.1",
 		"eslint": "^8.56.0",
 		"express": "^4.18.2",
@@ -42,6 +42,6 @@
 		"url": "https://github.com/trenskow"
 	},
 	"overrides": {
-		"chai": "^5.0.3"
+		"chai": "^5.1.0"
 	}
 }

package/test/validate.js

@@ -8,6 +8,7 @@
 
 import { expect, assert } from 'chai';
 import ValidationError from '../lib/errors/validation.js';
+import AggregatedError from '../lib/errors/aggregated.js';
 import isvalid from '../index.js';
 import { typeName, instanceTypeName, isSameType } from '../lib/utils.js';
 
@@ -476,17 +477,23 @@ describe('validate', function() {
 				})).to.eventually.not.have.property('why');
 			});
 			describe('required', function() {
-				it ('should come back with object key path when implicit.', () => {
+				it ('should come back with object key path when implicit (aggregated error).', () => {
 					return expect(isvalid(undefined, {
 						'myObject': {
-							'myKey': {
+							'myFirstKey': {
+								type: String,
+								required: true
+							},
+							'mySecondKey': {
 								type: String,
 								required: true
 							}
-						}}))
-						.to.eventually.be.rejectedWith('Data is required.')
-						.and.to.be.instanceOf(ValidationError)
-						.and.have.property('keyPath').to.have.members(['myObject', 'myKey']);
+						}}, { keyPath: ['root'], stopOnFirstError: false }))
+						.to.eventually.be.rejectedWith('Multiple errors occurred.')
+						.and.to.be.instanceOf(AggregatedError)
+						.and.have.property('errors')
+						.and.have.property(0)
+						.and.have.property('message', 'Data is required.');
 				});
 			});
 			describe('#errors', function() {
@@ -541,7 +548,7 @@ describe('validate', function() {
 					}}, { keyPath: 'root'}))
 					.to.eventually.be.rejectedWith('Is not of type string.')
 					.and.to.be.instanceOf(ValidationError)
-					.and.have.property('keyPath').eql(['root', 0]);
+					.and.have.property('keyPath').eql(['root', '0']);
 			});
 		});
 		describe('len', function() {