isvalid 3.1.1 → 3.2.0

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`.');
 	}
@@ -132,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' });
@@ -146,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) &&
@@ -171,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];
@@ -269,18 +297,7 @@ const formalizeAny = (schema, options = {}) => {
 			formalizedSchema = formalizeObject(formalizedSchema, schema, options);
 		}
 		else if (utils.isSameType('array', utils.typeName(formalizedSchema.type))) {
-			formalizedSchema = formalizeArray(formalizedSchema, 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);
+			formalizedSchema = formalizeArray(formalizedSchema, options);
 		}
 	}
 
@@ -288,7 +305,11 @@ const formalizeAny = (schema, options = {}) => {
 
 };
 
-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) {
-	return Object.fromEntries(Object.entries(merge(...this._plugins
-		.filter((plugin) => 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(type, identifier, config);
-		}, 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(type, identifier, config, data);
-	}
-
-	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;
@@ -299,16 +298,39 @@ 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 plugins = Object.keys(schema.plugins || {})
+		.filter((key) => schema.plugins[key].phase === phase)
+		.map((key) => [key, schema.plugins[key].validator]);
+
+	for (let idx = 0 ; idx < plugins.length ; idx++) {
+		const [key, validator] = plugins[idx];
+		try {
+			data = await validator(data, schema[key], key, schema.type);
+		} catch (error) {
+			throw new ValidationError(
+				keyPath,
+				schema._nonFormalizedSchema,
+				key,
+				(schema.errors || {})[key] || customErrorMessage((options.errorMessages || {})[key] || 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,22 +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) {
-		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)
-			);
-		}
-	}
-
 	return await validatePost(data, schema, options, keyPath, validatedData);
 
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isvalid",
-  "version": "3.1.1",
+  "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,11 +11,10 @@ isvalid.plugins.use(function (utils) {
 	return {
 		supportsType: (type) => utils.isSameType(type, String),
 		validatorsForType: () => { return { ensureCase: 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.`);
+		formalize: (config) => {
+			if (config && !caseit.supported.includes(config)) throw new Error(`Only case types: ${caseit.supported.map((casing) => `\`${casing}\``).join(', ')} are supported.`);
 		},
-		validate: (_, __, config, data) => {
+		validate: (data, config) => {
 			if (caseit(data, config) !== data) throw new Error(`Is not ${config} case.`);
 			return data;
 		}