isvalid 2.9.0 → 2.10.1

package/lib/formalize.js

@@ -14,11 +14,9 @@ const finalize = (formalizedSchema, nonFormalizedSchema) => {
 	Object.defineProperty(formalizedSchema, '_nonFormalizedSchema', {
 		value: nonFormalizedSchema,
 		enumerable: false,
+		writable: false
 	});
 
-	// We seal the schema so no further editing can take place.
-	Object.seal(formalizedSchema);
-
 	return formalizedSchema;
 
 };
@@ -35,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/index.js

@@ -4,3 +4,4 @@ exports = module.exports = require('./validate.js');
 exports.formalize = require('./formalize.js');
 exports.validate = require('./middleware.js');
 exports.keyPaths = require('./key-paths');
+exports.merge = require('./merge');

package/lib/key-paths.js

@@ -3,37 +3,79 @@
 const formalize = require('./formalize'),
 	utils = require('./utils');
 
-exports = module.exports = (schema, types, keyPath = []) => {
+exports = module.exports = (schema, formalizeOptions) => {
 
-	schema = formalize(schema);
+	schema = formalize(schema, formalizeOptions);
 
-	if (!types) types = [];
-	if (!Array.isArray(types)) types = [types];
+	return {
+		all: (types, keyPath = []) => {
 
-	types = types.map((type) => utils.typeName(type));
+			if (!types) types = [];
+			if (!Array.isArray(types)) types = [types];
 
-	let result = [];
+			types = types.map((type) => utils.typeName(type));
 
-	const typeName = utils.typeName(schema.type);
+			let result = [];
 
-	if (types.length == 0 || types.includes(typeName)) result.push(keyPath.join('.'));
+			const typeName = utils.typeName(schema.type);
 
-	switch (typeName) {
-	case 'object':
-		result = result.concat(...Object.keys(schema.schema).map((key) => {
-			return exports(schema.schema[key], types, keyPath.concat([key]));
-		}));
-		break;
-	case 'array':
-		result = result.concat(exports(schema.schema, types, keyPath));
-		break;
-	}
+			if (types.length == 0 || types.includes(typeName)) result.push(keyPath.join('.'));
 
-	let uniqueResult = [];
-	for (let keyPath of result) {
-		if (!uniqueResult.includes(keyPath)) uniqueResult.push(keyPath);
-	}
+			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;
+			}
 
-	return uniqueResult;
+			let uniqueResult = [];
+			for (let keyPath of result) {
+				if (!uniqueResult.includes(keyPath)) uniqueResult.push(keyPath);
+			}
+
+			return uniqueResult;
+
+		},
+		get: (keyPath = '') => {
+
+			if (!Array.isArray(keyPath)) keyPath = keyPath.split('.').filter((key) => key);
+
+			if (keyPath.length === 0) return schema;
+
+			const typeName = utils.typeName(schema.type).toLowerCase();
+
+			switch (typeName) {
+			case 'object':
+				return exports(schema.schema[keyPath[0]]).get(keyPath.slice(1));
+			case 'array':
+				return exports(schema.schema).get(keyPath);
+			default:
+				throw new Error(`Cannot get key '${[keyPath[0]].concat(keyPath).join('.')}' from type '${typeName}'.`);
+			}
+
+		},
+		set: (keyPath, newSchema) => {
+
+			keyPath = keyPath || '';
+			newSchema = formalize(newSchema, formalizeOptions);
+
+			if (!Array.isArray(keyPath)) keyPath = keyPath.split('.').filter((key) => key);
+
+			if (keyPath.length === 0) return newSchema;
+
+			let parent = exports(schema).get(keyPath.slice(0, -1));
+
+			if (utils.typeName(parent.type).toLowerCase() !== 'object') throw new Error('Cannot set keys on non-object types.');
+
+			parent.schema[keyPath.slice(-1)[0]] = newSchema;
+
+			return schema;
+
+		}
+	};
 
 };

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.9.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/index.js

@@ -5,11 +5,11 @@ const chai = require('chai'),
 
 chai.use(chaiAsPromised);
 
-require('./key-paths');
 require('./ranges.js');
 require('./equals.js');
 require('./unique.js');
 require('./formalize.js');
 require('./validate.js');
 require('./middleware/');
+require('./key-paths');
 require('./merge');

package/test/key-paths.js

@@ -7,16 +7,16 @@ describe('keyPaths', () => {
 	it ('should come back with empty key paths', () => {
 		expect(keyPaths({
 			type: Boolean
-		})).to.eql(['']);
+		}).all()).to.eql(['']);
 	});
 	it ('should come back with three key paths.', () => {
 		expect(keyPaths({
 			'first': Boolean,
 			'second': String,
 			'third': Number
-		})).to.eql(['','first','second','third']);
+		}).all()).to.eql(['','first','second','third']);
 	});
-	it ('should come back with three eight paths.', () => {
+	it ('should come back with three key paths.', () => {
 		expect(keyPaths({
 			'first': [{
 				'first': Boolean,
@@ -27,9 +27,9 @@ describe('keyPaths', () => {
 				'second': String
 			},
 			'third': Number
-		})).to.eql(['','first','first.first','first.second','second','second.first','second.second','third']);
+		}).all()).to.eql(['','first','first.first','first.second','second','second.first','second.second','third']);
 	});
-	it ('should come back with three eight paths.', () => {
+	it ('should come back with three key paths.', () => {
 		expect(keyPaths({
 			'first': [{
 				'first': Boolean,
@@ -40,9 +40,9 @@ describe('keyPaths', () => {
 				'second': String
 			},
 			'third': Number
-		}, Object)).to.eql(['','first','second']);
+		}).all(Object)).to.eql(['','first','second']);
 	});
-	it ('should come back with three eight paths.', () => {
+	it ('should come back with two key paths.', () => {
 		expect(keyPaths({
 			'first': [{
 				'first': Boolean,
@@ -53,9 +53,9 @@ describe('keyPaths', () => {
 				'second': String
 			},
 			'third': Number
-		}, Boolean)).to.eql(['first.first','second.first']);
+		}).all(Boolean)).to.eql(['first.first','second.first']);
 	});
-	it ('should come back with three eight paths.', () => {
+	it ('should come back with three key paths.', () => {
 		expect(keyPaths({
 			'first': [{
 				'first': Boolean,
@@ -66,6 +66,30 @@ describe('keyPaths', () => {
 				'second': String
 			},
 			'third': Number
-		}, [Boolean, Array])).to.eql(['first','first.first','second.first']);
+		}).all([Boolean, Array])).to.eql(['first','first.first','second.first']);
+	});
+	it ('should come back with object at key (with intermediate array).', () => {
+		expect(keyPaths({
+			'first': [{
+				'first': Boolean,
+				'second': String
+			}]
+		}).get('first.second')).to.have.property('type').equal(String);
+	});
+	it ('should come back with object at key.', () => {
+		expect(keyPaths({
+			'second': {
+				'first': Boolean,
+				'second': String
+			}
+		}).get('second.second')).to.have.property('type').equal(String);
+	});
+	it ('should come back with root.', () => {
+		expect(keyPaths(String).get('')).to.have.property('type').equal(String);
+	});
+	it ('should come back with new validators set', () => {
+		expect(keyPaths({
+			'test': String
+		}).set('my', Number)).to.have.property('schema').to.have.property('my').to.have.property('type').to.equal(Number);
 	});
 });

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