isvalid 3.1.0 → 3.1.3

package/lib/formalize.js

@@ -27,7 +27,9 @@ const formalizeObject = (formalizedSchema, nonFormalizedSchema, options) => {
 
 	formalizedSchema.schema = formalizedSchema.schema || {};
 
-	if (utils.instanceTypeName(formalizedSchema.schema) !== 'object') throw new SchemaError(formalizedSchema.schema, 'Object schemas must be an object.');
+	if (utils.instanceTypeName(formalizedSchema.schema) !== 'object') {
+		throw new SchemaError(formalizedSchema.schema, 'Object schemas must be an object.');
+	}
 
 	// Build new formalized schema into this.
 	let formalizedSubSchema = {};
@@ -38,7 +40,7 @@ const formalizeObject = (formalizedSchema, nonFormalizedSchema, options) => {
 			formalizedSubSchema[key] = formalizeAny(formalizedSchema.schema[key], options);
 		});
 
-	formalizedSchema.schema = formalizedSubSchema;
+	formalizedSchema.schema = finalize(formalizedSubSchema, nonFormalizedSchema.schema);
 
 	if (typeof formalizedSchema.required === 'undefined') {
 		if (Object.keys(formalizedSubSchema).some((key) => formalizedSubSchema[key].required === true || formalizedSubSchema[key].required === 'implicit')) {
@@ -50,13 +52,13 @@ const formalizeObject = (formalizedSchema, nonFormalizedSchema, options) => {
 
 };
 
-const formalizeArray = (formalizedSchema, nonFormalizedSchema, options) => {
+const formalizeArray = (formalizedSchema, options) => {
 
 	// formalizedSchema has been pre-processed by formalizeAny, so
 	// we only need to formalize the sub-schema.
 
 	// If no sub-schema is provided we consider the schema final.
-	if (typeof formalizedSchema.schema === 'undefined') return finalize(formalizedSchema, nonFormalizedSchema);
+	if (typeof formalizedSchema.schema === 'undefined') return formalizedSchema;
 
 	formalizedSchema.schema = formalizeAny(formalizedSchema.schema, options);
 
@@ -76,14 +78,14 @@ const formalizeAny = (schema, options = {}) => {
 
 	if (!schema.type && !schema.post && !schema.pre && !schema.equal) {
 		if ('object' == utils.instanceTypeName(schema)) {
-			return formalizeAny({ type: Object, schema: schema }, schema, options);
+			return formalizeAny({ type: Object, schema: schema }, options);
 		}
 		if ('array' == utils.instanceTypeName(schema)) {
-			if (schema.length === 0) return formalizeAny({ type: Array }, schema. options);
-			return formalizeAny({ type: Array, schema: schema[0] }, schema, options);
+			if (schema.length === 0) return formalizeAny({ type: Array }, options);
+			return formalizeAny({ type: Array, schema: schema[0] }, options);
 		}
 		if ((typeof schema === 'string' && schema.length) || (typeof schema === 'function' && utils.typeName(schema) !== undefined)) {
-			return formalizeAny({ type: schema }, schema, options);
+			return formalizeAny({ type: schema }, options);
 		}
 		throw new SchemaError(schema, 'Schemas must have at least on validator of `type`, `post`/`pre` and/or `equal`.');
 	}
@@ -269,7 +271,7 @@ const formalizeAny = (schema, options = {}) => {
 			formalizedSchema = formalizeObject(formalizedSchema, schema, options);
 		}
 		else if (utils.isSameType('array', utils.typeName(formalizedSchema.type))) {
-			formalizedSchema = formalizeArray(formalizedSchema, schema, options);
+			formalizedSchema = formalizeArray(formalizedSchema, options);
 		}
 	}
 

package/lib/plugins.js

@@ -23,9 +23,9 @@ exports.use = function(plugin) {
 	}));
 };
 
-exports.validatorsForType = function(type) {
+exports.validatorsForType = function(type, phase) {
 	return Object.fromEntries(Object.entries(merge(...this._plugins
-		.filter((plugin) => plugin.supportsType(type))
+		.filter((plugin) => (!phase || (plugin.phase || 'post') === phase) && plugin.supportsType(type))
 		.map((plugin) => plugin._validatorsForType(type)))));
 
 };
@@ -36,7 +36,7 @@ exports.formalizeValidator = function(type, identifier, config) {
 		.filter((plugin) => Object.keys(plugin._validatorsForType(type)).includes(identifier))
 		.reduce((config, plugin) => {
 			if (typeof plugin.formalizeValidator !== 'function') return config;
-			return plugin.formalizeValidator(type, identifier, config);
+			return plugin.formalizeValidator(config, identifier, type);
 		}, config);
 };
 
@@ -46,7 +46,7 @@ exports.validate = async function(type, identifier, config, data) {
 		.filter((plugin) => plugin.supportsType(type));
 
 	for (const plugin of plugins) {
-		data = await plugin.validate(type, identifier, config, data);
+		data = await plugin.validate(data, config, identifier, type);
 	}
 
 	return data;

package/lib/validate.js

@@ -299,16 +299,38 @@ const validateOther = async (data, schema, options, keyPath) => {
 
 };
 
-const validateCustom = async (type, data, schema, options, keyPath, validatedData) => {
+const validateCustom = async (phase, data, schema, options, keyPath, validatedData) => {
 
-	if (!schema[type]) return data;
+	if (!schema[phase]) return data;
 
-	for (let idx = 0 ; idx < schema[type].length ; idx++) {
+	for (let idx = 0 ; idx < schema[phase].length ; idx++) {
 		try {
-			let result = await Promise.resolve(schema[type][idx](data, schema, { options, keyPath, data: validatedData }));
+			let result = await Promise.resolve(schema[phase][idx](data, schema, { options, keyPath, data: validatedData }));
 			if (typeof result !== 'undefined') data = result;
 		} catch (error) {
-			throw ValidationError.fromError(keyPath, schema._nonFormalizedSchema, type, error);
+			throw ValidationError.fromError(keyPath, schema._nonFormalizedSchema, phase, error);
+		}
+	}
+
+	return data;
+
+};
+
+const validatePlugins = async (phase, data, schema, options, keyPath) => {
+
+	const pluginValidators = Object.keys(plugins.validatorsForType(schema.type, phase))
+		.filter((validator) => typeof schema[validator] !== 'undefined');
+
+	for (const pluginValidator of pluginValidators) {
+		try {
+			data = await plugins.validate(schema.type, pluginValidator, schema[pluginValidator], data);
+		} catch (error) {
+			throw new ValidationError(
+				keyPath,
+				schema._nonFormalizedSchema,
+				pluginValidator,
+				(schema.errors || {})[pluginValidator] || customErrorMessage((options.errorMessages || {})[pluginValidator] || error.message)
+			);
 		}
 	}
 
@@ -317,10 +339,12 @@ const validateCustom = async (type, data, schema, options, keyPath, validatedDat
 };
 
 const validatePre = async (data, schema, options, keyPath, validatedData) => {
-	return await validateCustom('pre', data, schema, options, keyPath, validatedData);
+	data = await validateCustom('pre', data, schema, options, keyPath, validatedData);
+	return await validatePlugins('pre', data, schema, options, keyPath);
 };
 
 const validatePost = async (data, schema, options, keyPath, validatedData) => {
+	data = await validatePlugins('post', data, schema, options, keyPath);
 	return await validateCustom('post', data, schema, options, keyPath, validatedData);
 };
 
@@ -404,13 +428,6 @@ const validateAny = async (data, schema, options, keyPath, validatedData) => {
 		}
 	}
 
-	const pluginValidators = Object.keys(plugins.validatorsForType(schema.type))
-		.filter((validator) => typeof schema[validator] !== 'undefined');
-
-	for (const pluginValidator of pluginValidators) {
-		data = await plugins.validate(schema.type, pluginValidator, schema[pluginValidator], data);
-	}
-
 	return await validatePost(data, schema, options, keyPath, validatedData);
 
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isvalid",
-  "version": "3.1.0",
+  "version": "3.1.3",
   "description": "Async JSON validation library for node.js.",
   "main": "./index.js",
   "keywords": [

package/test/index.js

@@ -10,12 +10,14 @@ chai.use(chaiAsPromised);
 isvalid.plugins.use(function (utils) {
 	return {
 		supportsType: (type) => utils.isSameType(type, String),
-		validatorsForType: () => { return { casing: String }; },
-		formalizeValidator: (_, __, config) => {
-			if (!config) return;
-			if (!caseit.supported.includes(config)) throw new Error(`Only case types: ${caseit.supported.map((casing) => `\`${casing}\``).join(', ')} are supported.`);
+		validatorsForType: () => { return { ensureCase: String }; },
+		formalizeValidator: (config) => {
+			if (config && !caseit.supported.includes(config)) throw new Error(`Only case types: ${caseit.supported.map((casing) => `\`${casing}\``).join(', ')} are supported.`);
 		},
-		validate: (_, __, config, data) => caseit(data, config)
+		validate: (data, config) => {
+			if (caseit(data, config) !== data) throw new Error(`Is not ${config} case.`);
+			return data;
+		}
 	};
 });
 

package/test/validate.js

@@ -757,8 +757,19 @@ describe('validate', function() {
 		commonTests.all(Test, new Test(), 123);
 	});
 	describe('plugin validators', function() {
-		it ('should come back with correct case value.', function() {
-			return expect(isvalid('my-string', { type: String, casing: 'camel' })).to.eventually.eql('myString');
+		it ('should throw error if casing does not match.', function() {
+			return expect(isvalid('my-string', { type: String, ensureCase: 'camel' }))
+				.to.eventually.rejectedWith(ValidationError)
+				.and.to.have.property('message', 'Is not camel case.');
+		});
+		it ('should throw error with custom message if casing does not match.', function() {
+			return expect(isvalid('my-string', { type: String, ensureCase: ['camel', 'Something is not right!'] }))
+				.to.eventually.rejectedWith(ValidationError)
+				.and.to.have.property('message', 'Something is not right!');
+		});
+		it ('should come back with correct value.', function() {
+			return expect(isvalid('myString', { type: String, ensureCase: 'camel' }))
+				.to.eventually.equal('myString');
 		});
 	});
 });