isvalid 3.1.3 → 3.2.0

package/lib/formalize.js

@@ -134,10 +134,6 @@ const formalizeAny = (schema, options = {}) => {
 		});
 	}
 
-	const pluginValidators = plugins.validatorsForType(type);
-
-	merge(validators, pluginValidators);
-
 	// If post validator is provided allow for options.
 	if (formalizedSchema.pre !== undefined || formalizedSchema.post !== undefined) {
 		merge(validators, { 'options': 'any' });
@@ -148,12 +144,34 @@ const formalizeAny = (schema, options = {}) => {
 	for (let key in formalizedSchema) {
 
 		let validator = validators[key];
+		let test = formalizedSchema[key];
 
-		if (validator === undefined) {
-			throw new SchemaError(schema, `Validator \`${key}\` is unknown in this context.`);
-		}
+		if (typeof validator === 'undefined') {
 
-		let test = formalizedSchema[key];
+			let plugin;
+
+			[plugin, validator] = options.plugins
+				.filter((plugin) => plugin.supportsType(type))
+				.map((plugin) => [plugin, plugin.validatorsForType(type)])
+				.reduce((plugins, [plugin, validators]) => {
+					if (Object.keys(validators).includes(key)) {
+						validators = validators[key];
+						if (!Array.isArray(validators)) validators = [validators];
+						return [plugin, validators.map((validator) => utils.typeName(validator))];
+					}
+					return plugins;
+				}, []);
+
+			if (typeof plugin === 'undefined') throw new SchemaError(schema, `Validator \`${key}\` is unknown in this context.`);
+
+			formalizedSchema.plugins = formalizedSchema.plugins || {};
+			formalizedSchema.plugins[key] = {
+				phase: plugin.phase || 'post',
+				validator: plugin.validate,
+				formalize: plugin.formalize
+			};
+
+		}
 
 		// Test for - and transform - errors in validator.
 		if (Array.isArray(test) &&
@@ -173,13 +191,21 @@ const formalizeAny = (schema, options = {}) => {
 		}
 
 		// Ensure validator is of correct type.
-		if (validator !== 'any' && validator.indexOf(utils.instanceTypeName(test)) == -1) {
+		if (typeof validator !== 'undefined' && validator !== 'any' && validator.indexOf(utils.instanceTypeName(test)) == -1) {
 			throw new SchemaError(
 				schema,
 				`Validator '${key}' must be of type(s) ${validators[key].join(', ')}.`
 			);
 		}
 
+		if (typeof (formalizedSchema.plugins || {})[key] !== 'undefined') {
+			try {
+				formalizedSchema[key] = formalizedSchema.plugins[key].formalize(formalizedSchema[key], key, type) || formalizedSchema[key];
+			} catch (error) {
+				throw new SchemaError(schema, error.message);
+			}
+		}
+
 		if (typeof (options.transform || {}).post === 'function') {
 			const transformed = options.transform.post(key, formalizedSchema[key], { schema: formalizedSchema }) || formalizedSchema[key];
 			formalizedSchema[key] = typeof transformed !== 'undefined' ? transformed : formalizedSchema[key];
@@ -275,22 +301,15 @@ const formalizeAny = (schema, options = {}) => {
 		}
 	}
 
-	for (const validator of Object.keys(pluginValidators)) {
-		try {
-			const result = plugins.formalizeValidator(type, validator, formalizedSchema[validator]) || formalizedSchema[validator];
-			if (typeof result !== 'undefined') formalizedSchema[validator] = result;
-		} catch (error) {
-			throw new SchemaError(
-				schema,
-				error.message);
-		}
-	}
-
 	return finalize(formalizedSchema, schema);
 
 };
 
-exports = module.exports = formalizeAny;
+exports = module.exports = (schema, options = {}) => {
+	return formalizeAny(schema, Object.assign({}, options, {
+		plugins: plugins._plugins.concat(options.plugins || [])
+	}));
+};
 
 exports.strip = (schema) => {
 	return Object.keys(schema)

package/lib/plugins.js

@@ -1,54 +1,12 @@
 'use strict';
 
 const
-	merge = require('merge'),
 	utils = require('./utils');
 
 exports = module.exports = {
 	_plugins: []
 };
 
-exports.use = function(plugin) {
-	this._plugins.push(merge(plugin(utils), {
-		_validatorsForType: function(type) {
-			return Object.fromEntries(
-				Object.entries(
-					this.validatorsForType(type))
-					.map(([key, value]) => {
-						if (typeof value !== 'string') value = utils.typeName(value);
-						return [key, !Array.isArray(value) ? [value] : value];
-					})
-			);
-		}
-	}));
-};
-
-exports.validatorsForType = function(type, phase) {
-	return Object.fromEntries(Object.entries(merge(...this._plugins
-		.filter((plugin) => (!phase || (plugin.phase || 'post') === phase) && plugin.supportsType(type))
-		.map((plugin) => plugin._validatorsForType(type)))));
-
-};
-
-exports.formalizeValidator = function(type, identifier, config) {
-	return this._plugins
-		.filter((plugin) => plugin.supportsType(type))
-		.filter((plugin) => Object.keys(plugin._validatorsForType(type)).includes(identifier))
-		.reduce((config, plugin) => {
-			if (typeof plugin.formalizeValidator !== 'function') return config;
-			return plugin.formalizeValidator(config, identifier, type);
-		}, config);
-};
-
-exports.validate = async function(type, identifier, config, data) {
-
-	const plugins = this._plugins
-		.filter((plugin) => plugin.supportsType(type));
-
-	for (const plugin of plugins) {
-		data = await plugin.validate(data, config, identifier, type);
-	}
-
-	return data;
-
+exports.use = (plugin) => {
+	exports._plugins.push(plugin(utils));
 };

package/lib/validate.js

@@ -5,8 +5,7 @@ const ValidationError = require('./errors/validation.js'),
 	unique = require('./unique.js'),
 	formalize = require('./formalize.js'),
 	utils = require('./utils.js'),
-	equals = require('./equals.js'),
-	plugins = require('./plugins.js');
+	equals = require('./equals.js');
 
 const checkBoolValue = (name, schema, defaults) => {
 	if (schema[name] === undefined) return defaults[name] === true;
@@ -318,19 +317,20 @@ const validateCustom = async (phase, data, schema, options, keyPath, validatedDa
 
 const validatePlugins = async (phase, data, schema, options, keyPath) => {
 
-	const pluginValidators = Object.keys(plugins.validatorsForType(schema.type, phase))
-		.filter((validator) => typeof schema[validator] !== 'undefined');
+	const plugins = Object.keys(schema.plugins || {})
+		.filter((key) => schema.plugins[key].phase === phase)
+		.map((key) => [key, schema.plugins[key].validator]);
 
-	for (const pluginValidator of pluginValidators) {
+	for (let idx = 0 ; idx < plugins.length ; idx++) {
+		const [key, validator] = plugins[idx];
 		try {
-			data = await plugins.validate(schema.type, pluginValidator, schema[pluginValidator], data);
+			data = await validator(data, schema[key], key, schema.type);
 		} catch (error) {
 			throw new ValidationError(
 				keyPath,
 				schema._nonFormalizedSchema,
-				pluginValidator,
-				(schema.errors || {})[pluginValidator] || customErrorMessage((options.errorMessages || {})[pluginValidator] || error.message)
-			);
+				key,
+				(schema.errors || {})[key] || customErrorMessage((options.errorMessages || {})[key] || error.message));
 		}
 	}
 

package/package.json

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

package/test/formalize.js

@@ -6,7 +6,7 @@ const expect = require('chai').expect,
 
 const f = (...args) => {
 	return () => {
-		formalize(...args);
+		return formalize(...args);
 	};
 };
 
@@ -183,7 +183,9 @@ describe('schema', function() {
 			expect(f({ type: String, nonExistingValidator: 'myValue' })).to.throw(SchemaError);
 		});
 		it ('should throw error if plugin validator fails formalizing.', () => {
-			expect(f({ type: String, casing: 'not-supported' })).to.throw(SchemaError);
+			expect(f({ type: String, ensureCase: 'not-supported' }))
+				.to.throw(SchemaError)
+				.with.property('message', 'Only case types: `camel`, `domain`, `http`, `kebab`, `lower`, `pascal`, `snake`, `title`, `upper` are supported.');
 		});
 	});
 });

package/test/index.js

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