isvalid 2.10.0 → 2.10.1

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,9 +3,9 @@
 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 = []) => {
@@ -61,7 +61,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.1",
   "description": "Async JSON validation library for node.js.",
   "main": "./index.js",
   "keywords": [

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']);
 				});
 			});