isvalid 3.0.1 → 3.1.1

package/lib/formalize.js

@@ -3,7 +3,8 @@
 const merge = require('merge'),
 	SchemaError = require('./errors/schema.js'),
 	utils = require('./utils.js'),
-	ranges = require('./ranges.js');
+	ranges = require('./ranges.js'),
+	plugins = require('./plugins');
 
 const finalize = (formalizedSchema, nonFormalizedSchema) => {
 
@@ -45,7 +46,7 @@ const formalizeObject = (formalizedSchema, nonFormalizedSchema, options) => {
 		}
 	}
 
-	return finalize(formalizedSchema, nonFormalizedSchema);
+	return formalizedSchema;
 
 };
 
@@ -64,7 +65,7 @@ const formalizeArray = (formalizedSchema, nonFormalizedSchema, options) => {
 		if (formalizedSchema.schema.required === true) formalizedSchema.required = true;
 	}
 
-	return finalize(formalizedSchema, nonFormalizedSchema);
+	return formalizedSchema;
 
 };
 
@@ -75,11 +76,11 @@ const formalizeAny = (schema, options = {}) => {
 
 	if (!schema.type && !schema.post && !schema.pre && !schema.equal) {
 		if ('object' == utils.instanceTypeName(schema)) {
-			return formalizeObject({ type: Object, schema: schema }, schema, options);
+			return formalizeAny({ type: Object, schema: schema }, schema, options);
 		}
 		if ('array' == utils.instanceTypeName(schema)) {
 			if (schema.length === 0) return formalizeAny({ type: Array }, schema. options);
-			return formalizeArray({ type: Array, schema: schema[0] }, schema, options);
+			return formalizeAny({ type: Array, schema: schema[0] }, schema, options);
 		}
 		if ((typeof schema === 'string' && schema.length) || (typeof schema === 'function' && utils.typeName(schema) !== undefined)) {
 			return formalizeAny({ type: schema }, schema, options);
@@ -131,6 +132,10 @@ 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' });
@@ -150,6 +155,7 @@ const formalizeAny = (schema, options = {}) => {
 
 		// Test for - and transform - errors in validator.
 		if (Array.isArray(test) &&
+
 			test.length === 2 &&
 			validator.includes(utils.instanceTypeName(test[0]))) {
 
@@ -260,10 +266,21 @@ const formalizeAny = (schema, options = {}) => {
 	// Finalize objects and arrays if necessary.
 	if (formalizedSchema.type) {
 		if (utils.isSameType('object', utils.typeName(formalizedSchema.type))) {
-			return formalizeObject(formalizedSchema, schema, options);
+			formalizedSchema = formalizeObject(formalizedSchema, schema, options);
 		}
-		if (utils.isSameType('array', utils.typeName(formalizedSchema.type))) {
-			return formalizeArray(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);
 		}
 	}
 

package/lib/index.js

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

package/lib/plugins.js

@@ -0,0 +1,54 @@
+'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;
+
+};

package/lib/utils.js

@@ -13,5 +13,5 @@ exports.isSameType = function(obj1, obj2) {
 	if (typeof obj1 === 'undefined' || typeof obj2 === 'undefined') {
 		return typeof obj1 === typeof obj2;
 	}
-	return obj1.toLowerCase() == obj2.toLowerCase();
+	return exports.typeName(obj1).toLowerCase() == exports.typeName(obj2).toLowerCase();
 };

package/lib/validate.js

@@ -5,7 +5,8 @@ const ValidationError = require('./errors/validation.js'),
 	unique = require('./unique.js'),
 	formalize = require('./formalize.js'),
 	utils = require('./utils.js'),
-	equals = require('./equals.js');
+	equals = require('./equals.js'),
+	plugins = require('./plugins.js');
 
 const checkBoolValue = (name, schema, defaults) => {
 	if (schema[name] === undefined) return defaults[name] === true;
@@ -403,6 +404,22 @@ 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.0.1",
+  "version": "3.1.1",
   "description": "Async JSON validation library for node.js.",
   "main": "./index.js",
   "keywords": [
@@ -18,10 +18,11 @@
     "merge": "^2.1.1"
   },
   "devDependencies": {
+    "@trenskow/caseit": "^1.2.0",
     "body-parser": "^1.20.0",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
-    "eslint": "^8.12.0",
+    "eslint": "^8.13.0",
     "express": "^4.17.3",
     "mocha": "^9.2.2",
     "supertest": "^6.2.2"

package/test/formalize.js

@@ -179,5 +179,11 @@ describe('schema', function() {
 		it ('should throw error if array len is negative.', () => {
 			expect(f({ type: Array, len: '-2-' })).to.throw(SchemaError);
 		});
+		it ('should throw error if validator is not supported', () => {
+			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);
+		});
 	});
 });

package/test/index.js

@@ -1,10 +1,27 @@
 'use strict';
 
 const chai = require('chai'),
-	chaiAsPromised = require('chai-as-promised');
+	chaiAsPromised = require('chai-as-promised'),
+	caseit = require('@trenskow/caseit'),
+	isvalid = require('../');
 
 chai.use(chaiAsPromised);
 
+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.`);
+		},
+		validate: (_, __, config, data) => {
+			if (caseit(data, config) !== data) throw new Error(`Is not ${config} case.`);
+			return data;
+		}
+	};
+});
+
 require('./ranges.js');
 require('./equals.js');
 require('./unique.js');

package/test/validate.js

@@ -756,4 +756,20 @@ describe('validate', function() {
 	describe('other validator', function() {
 		commonTests.all(Test, new Test(), 123);
 	});
+	describe('plugin validators', function() {
+		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');
+		});
+	});
 });