isvalid 3.1.2 → 3.1.3

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,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.2",
+  "version": "3.1.3",
   "description": "Async JSON validation library for node.js.",
   "main": "./index.js",
   "keywords": [

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.`);
+		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) => {
+		validate: (data, config) => {
 			if (caseit(data, config) !== data) throw new Error(`Is not ${config} case.`);
 			return data;
 		}