isvalid 2.10.0 → 2.10.4

package/lib/formalize.js

@@ -33,24 +33,16 @@ const formalizeObject = (formalizedSchema, nonFormalizedSchema, options) => {
 	// We iterate through all keys.
 	Object.keys(formalizedSchema.schema)
 		.forEach((key) => {
-
-			const formalizedKey = formalizeAny(formalizedSchema.schema[key], options);
-
-			if (!options.throwDeepKeyOnImplicit) {
-				if (formalizedSchema.required === undefined || formalizedSchema.required == 'implicit') {
-					if (formalizedKey.required === true) formalizedSchema.required = true;
-				}
-			} else {
-				if (formalizedSchema.required === undefined) {
-					formalizedSchema.required = 'implicit';
-				}
-			}
-
-			formalizedSubSchema[key] = formalizedKey;
-
+			formalizedSubSchema[key] = formalizeAny(formalizedSchema.schema[key], options);
 		});
 
-	formalizedSchema.schema = formalizedSubSchema || {};
+	formalizedSchema.schema = formalizedSubSchema;
+
+	if (typeof formalizedSchema.required === 'undefined') {
+		if (Object.keys(formalizedSubSchema).some((key) => formalizedSubSchema[key].required === true || formalizedSubSchema[key].required === 'implicit')) {
+			formalizedSchema.required = 'implicit';
+		}
+	}
 
 	return finalize(formalizedSchema, nonFormalizedSchema);
 

package/lib/key-paths.js

@@ -3,12 +3,22 @@
 const formalize = require('./formalize'),
 	utils = require('./utils');
 
-exports = module.exports = (schema) => {
+exports = module.exports = (schema, formalizeOptions) => {
 
-	schema = formalize(schema);
+	schema = formalize(schema, formalizeOptions);
 
 	return {
-		all: (types, keyPath = []) => {
+		all: (types, options, keyPath = [], level = 0) => {
+
+			if (typeof types === 'object' && types !== null && !Array.isArray(types)) {
+				options = types;
+				types = [];
+			}
+
+			options = options || {};
+			options.maxDepth = typeof options.maxDepth !== 'undefined' ? options.maxDepth : Infinity;
+
+			if (typeof options.maxDepth !== 'number') throw new Error('Maximum depth must be a number.');
 
 			if (!types) types = [];
 			if (!Array.isArray(types)) types = [types];
@@ -21,15 +31,19 @@ exports = module.exports = (schema) => {
 
 			if (types.length == 0 || types.includes(typeName)) result.push(keyPath.join('.'));
 
-			switch (typeName) {
-			case 'object':
-				result = result.concat(...Object.keys(schema.schema).map((key) => {
-					return exports(schema.schema[key]).all(types, keyPath.concat([key]));
-				}));
-				break;
-			case 'array':
-				result = result.concat(exports(schema.schema).all(types, keyPath));
-				break;
+			if (level < options.maxDepth) {
+
+				switch (typeName) {
+				case 'object':
+					result = result.concat(...Object.keys(schema.schema).map((key) => {
+						return exports(schema.schema[key]).all(types, options, keyPath.concat([key]), level + 1);
+					}));
+					break;
+				case 'array':
+					result = result.concat(exports(schema.schema).all(types, options, keyPath, level + 1));
+					break;
+				}
+
 			}
 
 			let uniqueResult = [];
@@ -61,7 +75,7 @@ exports = module.exports = (schema) => {
 		set: (keyPath, newSchema) => {
 
 			keyPath = keyPath || '';
-			newSchema = formalize(newSchema);
+			newSchema = formalize(newSchema, formalizeOptions);
 
 			if (!Array.isArray(keyPath)) keyPath = keyPath.split('.').filter((key) => key);
 

package/lib/merge.js

@@ -5,10 +5,10 @@ const merge = require('merge');
 const formalize = require('./formalize'),
 	utils = require('./utils');
 
-const mergeSchema = (dest, src) => {
+const mergeSchema = (dest, src, formalizeOptions) => {
 
-	dest = formalize(dest);
-	src = formalize(src);
+	dest = formalize(dest, formalizeOptions);
+	src = formalize(src, formalizeOptions);
 
 	const destType = utils.typeName(dest.type).toLowerCase();
 	const srcType = utils.typeName(src.type).toLowerCase();
@@ -34,22 +34,26 @@ const mergeSchema = (dest, src) => {
 			else schema[key] = mergeSchema(destSchema[key], srcSchema[key]);
 		});
 
-		return formalize(merge(formalize.strip(dest), formalize.strip(src), { schema }));
+		return formalize(merge(formalize.strip(dest), formalize.strip(src), { schema }), formalizeOptions);
 
 	}
 	case 'array': {
 		return merge(dest, src, {
-			schema: formalize(mergeSchema(formalize.strip(dest.schema), formalize.strip(src.schema)))
+			schema: formalize(mergeSchema(formalize.strip(dest.schema), formalize.strip(src.schema)), formalizeOptions)
 		});
 	}
 	default:
-		return formalize(merge(formalize.strip(dest), formalize.strip(src)));
+		return formalize(merge(formalize.strip(dest), formalize.strip(src)), formalizeOptions);
 	}
 
 };
 
-exports = module.exports = (dest, ...sources) => {
-	return sources.reduce((result, current) => {
-		return mergeSchema(result, current);
-	}, dest);
+exports = module.exports = (dest, formalizeOptions) => {
+	return {
+		with: (...sources) => {
+			return sources.reduce((result, current) => {
+				return mergeSchema(result, current, formalizeOptions);
+			}, dest);
+		}
+	};
 };

package/lib/validate.js

@@ -323,7 +323,7 @@ const validateAny = async (data, schema, options, keyPath, validatedData) => {
 			data = await Promise.resolve(data);
 			return await validatePost(data, schema, options, keyPath, validatedData);
 		}
-		if (options.throwDeepKeyOnImplicit && schema.required === 'implicit') {
+		if (schema.required === 'implicit') {
 			data = {};
 		} else if (checkBoolValue('required', schema, options.defaults)) {
 			throw new ValidationError(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isvalid",
-  "version": "2.10.0",
+  "version": "2.10.4",
   "description": "Async JSON validation library for node.js.",
   "main": "./index.js",
   "keywords": [
@@ -21,10 +21,10 @@
     "body-parser": "^1.19.0",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
-    "eslint": "^7.18.0",
+    "eslint": "^8.2.0",
     "express": "^4.17.1",
-    "mocha": "^8.2.1",
-    "supertest": "^3.4.2"
+    "mocha": "^9.1.3",
+    "supertest": "^6.1.6"
   },
   "scripts": {
     "test": "./node_modules/mocha/bin/mocha ./test/index.js"

package/test/formalize.js

@@ -83,24 +83,24 @@ describe('schema', function() {
 		it('should come back with a Date shortcut expanded.', () => {
 			expect(formalize(Date)).to.have.property('type').equal(Date);
 		});
-		it('should come back with required set to true if object has not specified required and a nested sub-schema is required.', () => {
+		it('should come back with required set to `implicit` if object has not specified required and a nested sub-schema is required.', () => {
 			expect(formalize({
 				'a': { type: String, required: true }
-			})).to.have.property('required').to.be.equal(true);
+			})).to.have.property('required').to.be.equal('implicit');
 		});
-		it('should come back with required set to true if any deep sub-schema is required.', () => {
+		it('should come back with required set to `implicit` if any deep sub-schema is required.', () => {
 			expect(formalize({
 				'a': {
 					'b': {
 						'c': { type: String, required: true }
 					}
 				}
-			})).to.have.property('required').to.be.equal(true);
+			})).to.have.property('required').to.be.equal('implicit');
 		});
-		it('should come back with required set to true if root object has required in sub-schema.', () => {
+		it('should come back with required set to `implicit` if root object has required in sub-schema.', () => {
 			expect(formalize({
 				'a': { type: String, required: true }
-			})).to.have.property('required').to.be.equal(true);
+			})).to.have.property('required').to.be.equal('implicit');
 		});
 		it('should come back with required set to false if root object required is false and deep sub-schema is required.', () => {
 			expect(formalize({

package/test/merge.js

@@ -5,14 +5,14 @@ const expect = require('chai').expect,
 
 describe('merge', () => {
 	it ('should come back with destination type.', () => {
-		expect(merge({ type: String }, { type: Date })).to.have.property('type').equal(Date);
+		expect(merge({ type: String }).with({ type: Date })).to.have.property('type').equal(Date);
 	});
 	it ('should come back with merged validators', () => {
-		expect(merge({ type: String, required: true }, { type: String })).to.have.property('required').equal(true);
-		expect(merge({ type: String }, { type: String, required: true })).to.have.property('required').equal(true);
+		expect(merge({ type: String, required: true }).with({ type: String })).to.have.property('required').equal(true);
+		expect(merge({ type: String }).with({ type: String, required: true })).to.have.property('required').equal(true);
 	});
 	it ('should come back with array', () => {
-		const result = merge([{ type: String }], [{ type: Date }]);
+		const result = merge([{ type: String }]).with([{ type: Date }]);
 		expect(result).to.have.property('type').equal(Array);
 		expect(result.schema).to.have.property('type').equal(Date);
 	});
@@ -20,7 +20,7 @@ describe('merge', () => {
 		const result = merge({
 			'this': { type: String },
 			'is': { type: String}
-		}, {
+		}).with({
 			'is': { type: String, required: true },
 			'a': { type: Number },
 			'test': { type: Date}

package/test/validate.js

@@ -448,26 +448,14 @@ describe('validate', function() {
 				})).to.eventually.not.have.property('why');
 			});
 			describe('required', function() {
-				it ('should come back with object key path when implicit and no `throwDeepKeyOnImplicit`.', () => {
-					return expect(isvalid({}, {
-						'myObject': {
-							'myKey': {
-								type: String,
-								required: true
-							}
-						}
-					})).to.eventually.be.rejectedWith(ValidationError).and.have.property('keyPath').to.have.members(['myObject']);
-				});
-				it ('should come back with object key path when implicit and `throwDeepKeyOnImplicit` is `true`.', () => {
-					return expect(isvalid({}, {
+				it ('should come back with object key path when implicit.', () => {
+					return expect(isvalid(undefined, {
 						'myObject': {
 							'myKey': {
 								type: String,
 								required: true
 							}
 						}
-					}, {
-						throwDeepKeyOnImplicit: true
 					})).to.eventually.be.rejectedWith(ValidationError).and.have.property('keyPath').to.have.members(['myObject', 'myKey']);
 				});
 			});