isvalid 3.2.7 → 4.0.2

package/{.eslintrc.js → .eslintrc.cjs}

@@ -5,7 +5,8 @@ module.exports = {
 		'mocha': true
 	},
 	'parserOptions': {
-		'ecmaVersion': 2018
+		'ecmaVersion': 2018,
+		'sourceType': 'module'
 	},
 	'extends': 'eslint:recommended',
 	'rules': {

package/History.md

@@ -2,6 +2,15 @@
 
 NOTICE: If your version number is not explicitly specified, it contains bug fixes or changes to internal workings.
 
+## Version 4.0.0
+
+* Converted to use ES modules.
+* The `allowNull` validator has been changed to `null`.
+
+## Version 3.0.0
+
+* The minimum ECMAScript version supported has been bumped to 2018.
+
 ## Version 2.7.0
 
 * The ability for custom errors has been under the hood for some time - just not very well tested. Now it's official.

package/README.md

@@ -22,7 +22,6 @@
         * [Synchronous Functions](#synchronous-functions)
       - [`required`](#required)
         * [Implicitly Required](#implicitly-required)
-      - [`allowNull`](#allownull)
       - [`equal`](#equal)
       - [`errors` (Custom Error Messages)](#errors-custom-error-messages)
         * [Error Shortcuts](#error-shortcuts)
@@ -280,19 +279,6 @@ In the above example the data will validate if the object is not present in the
 
 > If `required` is not specified, then `Object` and `Array` types are by default `'implicit'`. All other types are by default non-required. Also `required` is ignored if `default` is specified.
 
-#### `allowNull`
-Type: `Boolean`
-
-This validator allows for `null`-values to pass through - even if the input is required.
-
-````javascript
-{ type: String, required: true, allowNull: true }
-````
-
-In the above example input must be of type `String`, it is required, but a value of `null` is allowed.
-
-> By default `allowNull` is set to `false`.
-
 #### `equal`
 Type: Any
 

package/index.js

@@ -1,3 +1,12 @@
-'use strict';
+//
+// index.js
+//
+// Created by Kristian Trenskow on 2014-06-02
+//
+// See license in LICENSE
+//
 
-exports = module.exports = require('./lib');
+import validate, { formalize, keyPaths, merge, plugins } from './lib/index.js';
+
+export default validate;
+export { formalize, keyPaths, merge, plugins };

package/lib/equals.js

@@ -1,6 +1,12 @@
-'use strict';
+//
+// equals.js
+//
+// Created by Kristian Trenskow on 2014-06-06
+//
+// See license in LICENSE
+//
 
-const utils = require('./utils.js');
+import { instanceTypeName } from './utils.js';
 
 const objectEquals = async (obj1, obj2) => {
 
@@ -41,12 +47,12 @@ const equals = async (obj1, obj2) => {
 	if (typeof obj2.is === 'function') return obj2.is(obj1);
 
 	if (typeof obj1 === 'object') {
-		if (utils.instanceTypeName(obj1) === 'object') return await objectEquals(obj1, obj2);
-		if (utils.instanceTypeName(obj1) === 'array') return await arrayEquals(obj1, obj2);
+		if (instanceTypeName(obj1) === 'object') return await objectEquals(obj1, obj2);
+		if (instanceTypeName(obj1) === 'array') return await arrayEquals(obj1, obj2);
 	}
 
 	return obj1 === obj2;
 
 };
 
-exports = module.exports = equals;
+export default equals;

package/lib/errors/schema.js

@@ -1,6 +1,12 @@
-'use strict';
+//
+// schema.js
+//
+// Created by Kristian Trenskow on 2014-06-06
+//
+// See license in LICENSE
+//
 
-module.exports = exports = class SchemaError extends Error {
+export default class SchemaError extends Error {
 
 	constructor(schema, message) {
 		super();
@@ -15,4 +21,4 @@ module.exports = exports = class SchemaError extends Error {
 
 	}
 
-};
+}

package/lib/errors/validation.js

@@ -1,6 +1,12 @@
-'use strict';
+//
+// validation.js
+//
+// Created by Kristian Trenskow on 2014-06-06
+//
+// See license in LICENSE
+//
 
-module.exports = exports = class ValidationError extends Error {
+export default class ValidationError extends Error {
 
 	constructor(keyPath, schema, validator, message) {
 		super();
@@ -23,4 +29,4 @@ module.exports = exports = class ValidationError extends Error {
 		return validationError;
 	}
 
-};
+}

package/lib/formalize.js

@@ -1,10 +1,16 @@
-'use strict';
-
-const merge = require('merge'),
-	SchemaError = require('./errors/schema.js'),
-	utils = require('./utils.js'),
-	ranges = require('./ranges.js'),
-	plugins = require('./plugins');
+//
+// formalize.js
+//
+// Created by Kristian Trenskow on 2014-06-09
+//
+// See license in LICENSE
+//
+
+import merge from 'merge';
+import SchemaError from './errors/schema.js';
+import { instanceTypeName, typeName, isSameType } from './utils.js';
+import { formalize as _formalize } from './ranges.js';
+import { all as allPlugins } from './plugins.js';
 
 const finalize = (formalizedSchema, nonFormalizedSchema) => {
 
@@ -27,7 +33,7 @@ const formalizeObject = (formalizedSchema, nonFormalizedSchema, options) => {
 
 	formalizedSchema.schema = formalizedSchema.schema || {};
 
-	if (utils.instanceTypeName(formalizedSchema.schema) !== 'object') {
+	if (instanceTypeName(formalizedSchema.schema) !== 'object') {
 		throw new SchemaError(formalizedSchema.schema, 'Object schemas must be an object.');
 	}
 
@@ -77,14 +83,14 @@ const formalizeAny = (schema, options = {}) => {
 	if (typeof schema._nonFormalizedSchema !== 'undefined') return schema;
 
 	if (!schema.type && !schema.post && !schema.pre && !schema.equal) {
-		if ('object' == utils.instanceTypeName(schema)) {
+		if ('object' == instanceTypeName(schema)) {
 			return formalizeAny({ type: Object, schema: schema }, options);
 		}
-		if ('array' == utils.instanceTypeName(schema)) {
+		if ('array' == instanceTypeName(schema)) {
 			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)) {
+		if ((typeof schema === 'string' && schema.length) || (typeof schema === 'function' && typeName(schema) !== undefined)) {
 			return formalizeAny({ type: schema }, options);
 		}
 		throw new SchemaError(schema, 'Schemas must have at least on validator of `type`, `post`/`pre` and/or `equal`.');
@@ -102,7 +108,7 @@ const formalizeAny = (schema, options = {}) => {
 		'equal': 'any',
 		'required': ['boolean', 'string'],
 		'default': 'any',
-		'allowNull': ['boolean'],
+		'null': ['string'],
 		'errors': ['object'],
 		'pre': ['function', 'array', 'asyncfunction'],
 		'post': ['function', 'array', 'asyncfunction'],
@@ -112,23 +118,23 @@ const formalizeAny = (schema, options = {}) => {
 	// Validators specific to type.
 	const type = Array.isArray(formalizedSchema.type) ? formalizedSchema.type[0] : formalizedSchema.type;
 	if (type !== undefined) {
-		if (utils.isSameType('object', utils.typeName(type))) merge(validators, {
+		if (isSameType('object', typeName(type))) merge(validators, {
 			'schema': 'any',
 			'unknownKeys': [ 'string' ]
 		});
-		if (utils.isSameType('array', utils.typeName(type))) merge(validators, {
+		if (isSameType('array', typeName(type))) merge(validators, {
 			'schema': 'any',
 			'len': [ 'string', 'number' ],
 			'unique': [ 'boolean' ],
 			'autowrap': [ 'boolean' ]
 		});
-		if (utils.isSameType('string', utils.typeName(type))) merge(validators, {
+		if (isSameType('string', typeName(type))) merge(validators, {
 			'len': [ 'string', 'number' ],
 			'match': [ 'regexp' ],
 			'trim': [ 'boolean' ],
 			'enum': [ 'array' ]
 		});
-		if (utils.isSameType('number', utils.typeName(type))) merge(validators, {
+		if (isSameType('number', typeName(type))) merge(validators, {
 			'range': [ 'string', 'number' ],
 			'float': [ 'string' ]
 		});
@@ -157,7 +163,7 @@ const formalizeAny = (schema, options = {}) => {
 					if (Object.keys(validators).includes(key)) {
 						validators = validators[key];
 						if (!Array.isArray(validators)) validators = [validators];
-						return [plugin, validators.map((validator) => utils.typeName(validator))];
+						return [plugin, validators.map((validator) => typeName(validator))];
 					}
 					return plugins;
 				}, []);
@@ -177,7 +183,7 @@ const formalizeAny = (schema, options = {}) => {
 		if (Array.isArray(test) &&
 
 			test.length === 2 &&
-			validator.includes(utils.instanceTypeName(test[0]))) {
+			validator.includes(instanceTypeName(test[0]))) {
 
 			formalizedSchema.errors = formalizedSchema.errors || {};
 			formalizedSchema.errors[key] = test[1];
@@ -191,7 +197,7 @@ const formalizeAny = (schema, options = {}) => {
 		}
 
 		// Ensure validator is of correct type.
-		if (typeof validator !== 'undefined' && validator !== 'any' && validator.indexOf(utils.instanceTypeName(test)) == -1) {
+		if (typeof validator !== 'undefined' && validator !== 'any' && validator.indexOf(instanceTypeName(test)) == -1) {
 			throw new SchemaError(
 				schema,
 				`Validator '${key}' must be of type(s) ${validators[key].join(', ')}.`
@@ -214,7 +220,7 @@ const formalizeAny = (schema, options = {}) => {
 	}
 
 	// Check for supported type.
-	if (typeof formalizedSchema.type !== 'undefined' && utils.typeName(formalizedSchema.type) === undefined) {
+	if (typeof formalizedSchema.type !== 'undefined' && typeName(formalizedSchema.type) === undefined) {
 		throw new SchemaError(formalizedSchema, `Cannot validate schema of type ${formalizedSchema.type}.`);
 	}
 
@@ -245,6 +251,15 @@ const formalizeAny = (schema, options = {}) => {
 		);
 	}
 
+	// Check null
+	if (typeof formalizedSchema.null === 'string' &&
+			['allow', 'deny', 'undefine'].indexOf(formalizedSchema.null) == -1) {
+		throw new SchemaError(
+			schema,
+			'Validator `null` must have value `\'allow\'`, `\'deny\'`, `\'undefined\'`.'
+		);
+	}
+
 	// Check number float
 	if (typeof formalizedSchema.float === 'string' &&
 			['allow', 'deny', 'round', 'floor', 'ceil'].indexOf(formalizedSchema.float) == -1) {
@@ -256,7 +271,7 @@ const formalizeAny = (schema, options = {}) => {
 
 	// Check len
 	if (typeof formalizedSchema.len !== 'undefined') {
-		formalizedSchema.len = ranges.formalize(formalizedSchema.len, {
+		formalizedSchema.len = _formalize(formalizedSchema.len, {
 			allowNegative: false,
 			allowNonIntegers: false
 		});
@@ -264,7 +279,7 @@ const formalizeAny = (schema, options = {}) => {
 
 	// Check range
 	if (typeof formalizedSchema.range !== 'undefined') {
-		formalizedSchema.range = ranges.formalize(formalizedSchema.range, {
+		formalizedSchema.range = _formalize(formalizedSchema.range, {
 			allowNegative: true,
 			allowNonIntegers: true
 		});
@@ -293,10 +308,10 @@ const formalizeAny = (schema, options = {}) => {
 
 	// Finalize objects and arrays if necessary.
 	if (formalizedSchema.type) {
-		if (utils.isSameType('object', utils.typeName(formalizedSchema.type))) {
+		if (isSameType('object', typeName(formalizedSchema.type))) {
 			formalizedSchema = formalizeObject(formalizedSchema, schema, options);
 		}
-		else if (utils.isSameType('array', utils.typeName(formalizedSchema.type))) {
+		else if (isSameType('array', typeName(formalizedSchema.type))) {
 			formalizedSchema = formalizeArray(formalizedSchema, options);
 		}
 	}
@@ -305,17 +320,17 @@ const formalizeAny = (schema, options = {}) => {
 
 };
 
-exports = module.exports = (schema, options = {}) => {
+export default (schema, options = {}) => {
 	return formalizeAny(schema, Object.assign({}, options, {
-		plugins: plugins._plugins.concat((options.plugins || []).map((plugin) => plugin(utils)))
+		plugins: allPlugins().concat((options.plugins || []).map((plugin) => plugin({ instanceTypeName, typeName, isSameType })))
 	}));
 };
 
-exports.strip = (schema) => {
+export function strip(schema) {
 	return Object.keys(schema)
 		.filter((key) => key !== '_nonFormalizedSchema')
 		.reduce((result, key) => {
 			result[key] = schema[key];
 			return result;
 		}, {});
-};
+}

package/lib/index.js

@@ -1,8 +1,18 @@
-'use strict';
+//
+// index.js
+//
+// Created by Kristian Trenskow on 2021-08-18
+//
+// See license in LICENSE
+//
 
-exports = module.exports = require('./validate.js');
-exports.formalize = require('./formalize.js');
-exports.validate = require('./middleware.js');
-exports.keyPaths = require('./key-paths');
-exports.merge = require('./merge');
-exports.plugins = require('./plugins');
+import validate from './validate.js';
+import formalize from './formalize.js';
+import keyPaths from './key-paths.js';
+import merge from './merge.js';
+import { use } from './plugins.js';
+
+const plugins = { use };
+
+export default validate;
+export { formalize, keyPaths, merge, plugins };

package/lib/key-paths.js

@@ -1,9 +1,15 @@
-'use strict';
+//
+// key-paths.js
+//
+// Created by Kristian Trenskow on 2021-08-18
+//
+// See license in LICENSE
+//
 
-const formalize = require('./formalize'),
-	utils = require('./utils');
+import formalize from './formalize.js';
+import { typeName as _typeName } from './utils.js';
 
-exports = module.exports = (schema, formalizeOptions) => {
+const keyPaths = (schema, formalizeOptions) => {
 
 	schema = formalize(schema, formalizeOptions);
 
@@ -23,11 +29,11 @@ exports = module.exports = (schema, formalizeOptions) => {
 			if (!types) types = [];
 			if (!Array.isArray(types)) types = [types];
 
-			types = types.map((type) => utils.typeName(type));
+			types = types.map((type) => _typeName(type));
 
 			let result = [];
 
-			const typeName = utils.typeName(schema.type);
+			const typeName = _typeName(schema.type);
 
 			if (types.length == 0 || types.includes(typeName)) result.push(keyPath.join('.'));
 
@@ -36,11 +42,11 @@ exports = module.exports = (schema, formalizeOptions) => {
 				switch (typeName) {
 				case 'object':
 					result = result.concat(...Object.keys(schema.schema).map((key) => {
-						return exports(schema.schema[key]).all(types, options, keyPath.concat([key]), level + 1);
+						return keyPaths(schema.schema[key]).all(types, options, keyPath.concat([key]), level + 1);
 					}));
 					break;
 				case 'array':
-					result = result.concat(exports(schema.schema).all(types, options, keyPath, level + 1));
+					result = result.concat(keyPaths(schema.schema).all(types, options, keyPath, level + 1));
 					break;
 				}
 
@@ -60,13 +66,13 @@ exports = module.exports = (schema, formalizeOptions) => {
 
 			if (keyPath.length === 0) return schema;
 
-			const typeName = utils.typeName(schema.type).toLowerCase();
+			const typeName = _typeName(schema.type).toLowerCase();
 
 			switch (typeName) {
 			case 'object':
-				return exports(schema.schema[keyPath[0]]).get(keyPath.slice(1));
+				return keyPaths(schema.schema[keyPath[0]]).get(keyPath.slice(1));
 			case 'array':
-				return exports(schema.schema).get(keyPath);
+				return keyPaths(schema.schema).get(keyPath);
 			default:
 				throw new Error(`Cannot get key '${[keyPath[0]].concat(keyPath).join('.')}' from type '${typeName}'.`);
 			}
@@ -81,9 +87,9 @@ exports = module.exports = (schema, formalizeOptions) => {
 
 			if (keyPath.length === 0) return newSchema;
 
-			let parent = exports(schema).get(keyPath.slice(0, -1));
+			let parent = keyPaths(schema).get(keyPath.slice(0, -1));
 
-			if (utils.typeName(parent.type).toLowerCase() !== 'object') throw new Error('Cannot set keys on non-object types.');
+			if (_typeName(parent.type).toLowerCase() !== 'object') throw new Error('Cannot set keys on non-object types.');
 
 			parent.schema[keyPath.slice(-1)[0]] = newSchema;
 
@@ -93,3 +99,5 @@ exports = module.exports = (schema, formalizeOptions) => {
 	};
 
 };
+
+export default keyPaths;

package/lib/merge.js

@@ -1,17 +1,23 @@
-'use strict';
+//
+// merge.js
+//
+// Created by Kristian Trenskow on 2021-10-02
+//
+// See license in LICENSE
+//
 
-const merge = require('merge');
+import merge from 'merge';
 
-const formalize = require('./formalize'),
-	utils = require('./utils');
+import formalize, { strip } from './formalize.js';
+import { typeName } from './utils.js';
 
 const mergeSchema = (dest, src, formalizeOptions) => {
 
 	dest = formalize(dest, formalizeOptions);
 	src = formalize(src, formalizeOptions);
 
-	const destType = utils.typeName(dest.type).toLowerCase();
-	const srcType = utils.typeName(src.type).toLowerCase();
+	const destType = typeName(dest.type).toLowerCase();
+	const srcType = typeName(src.type).toLowerCase();
 
 	if (destType !== srcType) return src;
 
@@ -34,21 +40,21 @@ const mergeSchema = (dest, src, formalizeOptions) => {
 			else schema[key] = mergeSchema(destSchema[key], srcSchema[key]);
 		});
 
-		return formalize(merge(formalize.strip(dest), formalize.strip(src), { schema }), formalizeOptions);
+		return formalize(merge(strip(dest), strip(src), { schema }), formalizeOptions);
 
 	}
 	case 'array': {
 		return merge(dest, src, {
-			schema: formalize(mergeSchema(formalize.strip(dest.schema), formalize.strip(src.schema)), formalizeOptions)
+			schema: formalize(mergeSchema(strip(dest.schema), strip(src.schema)), formalizeOptions)
 		});
 	}
 	default:
-		return formalize(merge(formalize.strip(dest), formalize.strip(src)), formalizeOptions);
+		return formalize(merge(strip(dest), strip(src)), formalizeOptions);
 	}
 
 };
 
-exports = module.exports = (dest, formalizeOptions) => {
+export default (dest, formalizeOptions) => {
 	return {
 		with: (...sources) => {
 			return sources.reduce((result, current) => {

package/lib/middleware.js

@@ -1,10 +1,16 @@
-'use strict';
+//
+// middleware.js
+//
+// Created by Kristian Trenskow on 2015-06-28
+//
+// See license in LICENSE
+//
 
-var formalize = require('./formalize.js'),
-	isvalid = require('./validate.js'),
-	merge = require('merge');
+import formalize from './formalize.js';
+import isvalid from './validate.js';
+import merge from 'merge';
 
-exports.body = module.exports.body = function(schema, options) {
+export function body(schema, options) {
 
 	let formalizedSchema = formalize(schema, options);
 
@@ -23,9 +29,9 @@ exports.body = module.exports.body = function(schema, options) {
 			});
 	};
 
-};
+}
 
-exports.query = module.exports.query = function(schema, options) {
+export function query(schema, options) {
 
 	let formalizedSchema = formalize(schema, options);
 
@@ -44,9 +50,9 @@ exports.query = module.exports.query = function(schema, options) {
 			});
 	};
 
-};
+}
 
-exports.param = module.exports.param = function(schema, options) {
+export function param(schema, options) {
 
 	let formalizedSchema = formalize(schema, options);
 
@@ -65,9 +71,9 @@ exports.param = module.exports.param = function(schema, options) {
 			});
 	};
 
-};
+}
 
-exports.parameter = module.exports.parameter = function(id, schema, options) {
+export function parameter(id, schema, options) {
 
 	let formalizedSchema = formalize(schema, options);
 
@@ -86,4 +92,4 @@ exports.parameter = module.exports.parameter = function(id, schema, options) {
 			});
 	};
 
-};
+}

package/lib/plugins.js

@@ -1,12 +1,20 @@
-'use strict';
+//
+// plugins.js
+//
+// Created by Kristian Trenskow on 2022-04-13
+//
+// See license in LICENSE
+//
 
-const
-	utils = require('./utils');
 
-exports = module.exports = {
-	_plugins: []
-};
+import { isSameType, instanceTypeName, typeName } from './utils.js';
 
-exports.use = (plugin) => {
-	exports._plugins.push(plugin(utils));
-};
+const plugins = [];
+
+export function use(plugin) {
+	plugins.push(plugin({ isSameType, instanceTypeName, typeName }));
+}
+
+export function all() {
+	return plugins;
+}

package/lib/ranges.js

@@ -1,15 +1,14 @@
 'use strict';
 
-const
-	SchemaError = require('./errors/schema.js');
+import SchemaError from './errors/schema.js';
 
-module.exports.testIndex = function(ranges, value) {
+export function testIndex(ranges, value) {
 	return ranges.some(({ lower, upper }) => {
 		return lower <= value && upper >= value;
 	});
-};
+}
 
-module.exports.formalize = function(ranges, options) {
+export function formalize(ranges, options) {
 
 	// Convert to string if ranges is a Number.
 	if (ranges !== undefined && typeof ranges === 'number') {
@@ -67,4 +66,4 @@ module.exports.formalize = function(ranges, options) {
 
 		});
 
-};
+}

package/lib/unique.js

@@ -1,8 +1,14 @@
-'use strict';
+//
+// unique.js
+//
+// Created by Kristian Trenskow on 2014-06-06
+//
+// See license in LICENSE
+//
 
-const equals = require('./equals.js');
+import equals from './equals.js';
 
-exports = module.exports = async (arr) => {
+export default async (arr) => {
 
 	if (arr.length <= 1) return true;
 

package/lib/utils.js

@@ -1,17 +1,23 @@
-'use strict';
+//
+// utils.js
+//
+// Created by Kristian Trenskow on 2017-01-18
+//
+// See license in LICENSE
+//
 
-exports.typeName = function(obj) {
+export function typeName(obj) {
 	if (typeof obj === 'string') return obj;
 	return (obj.name || (this.toString().match(/function\s*([^\s(]+)/) || [])[1]).toLowerCase();
-};
+}
 
-exports.instanceTypeName = function(obj) {
-	return exports.typeName(obj.constructor);
-};
+export function instanceTypeName(obj) {
+	return typeName(obj.constructor);
+}
 
-exports.isSameType = function(obj1, obj2) {
+export function isSameType(obj1, obj2) {
 	if (typeof obj1 === 'undefined' || typeof obj2 === 'undefined') {
 		return typeof obj1 === typeof obj2;
 	}
-	return exports.typeName(obj1).toLowerCase() == exports.typeName(obj2).toLowerCase();
-};
+	return typeName(obj1).toLowerCase() == typeName(obj2).toLowerCase();
+}

package/lib/validate.js

@@ -1,11 +1,17 @@
-'use strict';
-
-const ValidationError = require('./errors/validation.js'),
-	ranges = require('./ranges.js'),
-	unique = require('./unique.js'),
-	formalize = require('./formalize.js'),
-	utils = require('./utils.js'),
-	equals = require('./equals.js');
+//
+// validate.js
+//
+// Created by Kristian Trenskow on 2014-06-06
+//
+// See license in LICENSE
+//
+
+import ValidationError from './errors/validation.js';
+import { testIndex } from './ranges.js';
+import unique from './unique.js';
+import formalize from './formalize.js';
+import { isSameType, instanceTypeName, typeName } from './utils.js';
+import equals from './equals.js';
 
 const checkBoolValue = (name, schema, defaults) => {
 	if (schema[name] === undefined) return defaults[name] === true;
@@ -96,7 +102,7 @@ const validateArray = async (data, schema, options, keyPath, validatedData) => {
 			}));
 		}
 
-		if ((schema.len || options.defaults.len) && !ranges.testIndex((schema.len || options.defaults.len), data.length)) {
+		if ((schema.len || options.defaults.len) && !testIndex((schema.len || options.defaults.len), data.length)) {
 			throw new ValidationError(
 				keyPath,
 				schema._nonFormalizedSchema,
@@ -136,7 +142,7 @@ const validateString = async (data, schema, options, keyPath) => {
 	}
 
 	if (schema.len || options.defaults.len) {
-		if (!ranges.testIndex(schema.len || options.defaults.len, data.length)) {
+		if (!testIndex(schema.len || options.defaults.len, data.length)) {
 			throw new ValidationError(
 				keyPath,
 				schema._nonFormalizedSchema,
@@ -196,7 +202,7 @@ const validateNumber = async (data, schema, options, keyPath) => {
 	}
 
 	if (schema.range || options.defaults.range) {
-		if (!ranges.testIndex(schema.range || options.defaults.range, data)) {
+		if (!testIndex(schema.range || options.defaults.range, data)) {
 			throw new ValidationError(
 				keyPath,
 				schema._nonFormalizedSchema,
@@ -262,7 +268,7 @@ const validateDate = async (data, schema, options, keyPath) => {
 
 	}
 
-	if (!utils.isSameType('date', utils.instanceTypeName(data))) {
+	if (!isSameType('date', instanceTypeName(data))) {
 		throw new ValidationError(
 			keyPath,
 			schema._nonFormalizedSchema,
@@ -277,12 +283,12 @@ const validateDate = async (data, schema, options, keyPath) => {
 
 const validateOther = async (data, schema, options, keyPath) => {
 
-	if (!utils.isSameType(utils.typeName(schema.type), utils.instanceTypeName(data))) {
+	if (!isSameType(typeName(schema.type), instanceTypeName(data))) {
 		throw new ValidationError(
 			keyPath,
 			schema._nonFormalizedSchema,
 			'type',
-			(schema.errors || {}).type || customErrorMessage(((options.errorMessages || {}).other || {}).type || ((type) => `Is not of type ${type}.`), utils.typeName(schema.type))
+			(schema.errors || {}).type || customErrorMessage(((options.errorMessages || {}).other || {}).type || ((type) => `Is not of type ${type}.`), typeName(schema.type))
 		);
 	}
 
@@ -351,14 +357,14 @@ const validateAny = async (data, schema, options, keyPath, validatedData) => {
 
 	if (typeof data === 'undefined' || data === null) {
 		if (data === null) {
-			if (checkBoolValue('allowNull', schema, options.defaults)) {
-				return await validatePost(data, schema, options, keyPath, validatedData);
-			}
-			throw new ValidationError(
+			let nul = schema.null || options.defaults.null || 'deny';
+			if (nul === 'undefine') data = undefined;
+			else if (nul === 'allow') return await validatePost(data, schema, options, keyPath, validatedData);
+			else throw new ValidationError(
 				keyPath,
 				schema._nonFormalizedSchema,
-				'allowNull',
-				(schema.errors || {}).allowNull || customErrorMessage((options.errorMessages || {}).allowNull || 'Cannot be null.')
+				'null',
+				(schema.errors || {}).null || customErrorMessage((options.errorMessages || {}).null || 'Cannot be null.')
 			);
 		}
 		if (typeof schema.default !== 'undefined') {
@@ -395,7 +401,7 @@ const validateAny = async (data, schema, options, keyPath, validatedData) => {
 	}
 
 	if (schema.type !== undefined) {
-		switch (utils.typeName(schema.type).toLowerCase()) {
+		switch (typeName(schema.type).toLowerCase()) {
 		case 'object':
 			data = await validateObject(data, schema, options, keyPath, validatedData);
 			break;
@@ -424,7 +430,7 @@ const validateAny = async (data, schema, options, keyPath, validatedData) => {
 
 };
 
-module.exports = exports = async (data, schema, options = {}, keyPath = '') => {
+export default async (data, schema, options = {}, keyPath = '') => {
 
 	if (typeof schema === 'undefined') throw new Error('Missing parameter schema.');
 

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "isvalid",
-  "version": "3.2.7",
+  "version": "4.0.2",
   "description": "Async JSON validation library for node.js.",
   "main": "./index.js",
+  "type": "module",
   "keywords": [
     "schema",
     "validation",
@@ -23,12 +24,12 @@
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
     "eslint": "^8.13.0",
-    "express": "^4.17.3",
-    "mocha": "^9.2.2",
+    "express": "^4.18.1",
+    "mocha": "^10.0.0",
     "supertest": "^6.2.2"
   },
   "scripts": {
-    "test": "./node_modules/mocha/bin/mocha ./test/index.js"
+    "test": "./node_modules/mocha/bin/mocha.js ./test/index.js"
   },
   "repository": {
     "type": "git",

package/test/equals.js

@@ -1,8 +1,13 @@
-/*jshint expr: true*/
-'use strict';
+//
+// equals.js
+//
+// Created by Kristian Trenskow on 2015-08-30
+//
+// See license in LICENSE
+//
 
-const expect = require('chai').expect,
-	equals = require('../lib/equals.js');
+import { expect } from 'chai';
+import equals from '../lib/equals.js';
 
 describe('equals', function() {
 	it('should return false if data is not of the same type (null).', () => {

package/test/formalize.js

@@ -1,8 +1,14 @@
-'use strict';
+//
+// formalize.js
+//
+// Created by Kristian Trenskow on 2018-12-12
+//
+// See license in LICENSE
+//
 
-const expect = require('chai').expect,
-	formalize = require('../lib/formalize.js'),
-	SchemaError = require('../lib/errors/schema.js');
+import { expect } from 'chai';
+import formalize from '../lib/formalize.js';
+import SchemaError from '../lib/errors/schema.js';
 
 const f = (...args) => {
 	return () => {
@@ -49,6 +55,9 @@ describe('schema', function() {
 		it('should throw an error if unknownKeys is not \'allow\', \'deny\' or \'remove\'.', () => {
 			expect(f({ type: Object, unknownKeys: 'test' })).to.throw(SchemaError);
 		});
+		it('should throw an error if null is not \'allow\', \'deny\' or \'undefine\'.', () => {
+			expect(f({ type: String, null: 'test' })).to.throw(SchemaError);
+		});
 		it('should throw an error if object schema is unknown type.', () => {
 			expect(f({ type: Object, schema: RegExp })).to.throw(SchemaError);
 		});

package/test/index.js

@@ -1,18 +1,24 @@
-'use strict';
+//
+// index.js
+//
+// Created by Kristian Trenskow on 2015-09-27
+//
+// See license in LICENSE
+//
 
-const chai = require('chai'),
-	chaiAsPromised = require('chai-as-promised'),
-	caseit = require('@trenskow/caseit'),
-	isvalid = require('../');
+import { use as chaiUse } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import caseit, { supported } from '@trenskow/caseit';
+import { use } from '../lib/plugins.js';
 
-chai.use(chaiAsPromised);
+chaiUse(chaiAsPromised);
 
-isvalid.plugins.use(function (utils) {
+use(function (utils) {
 	return {
 		supportsType: (type) => utils.isSameType(type, String),
 		validatorsForType: () => { return { ensureCase: String }; },
 		formalize: (config) => {
-			if (config && !caseit.supported.includes(config)) throw new Error(`Only case types: ${caseit.supported.map((casing) => `\`${casing}\``).join(', ')} are supported.`);
+			if (config && !supported.includes(config)) throw new Error(`Only case types: ${supported.map((casing) => `\`${casing}\``).join(', ')} are supported.`);
 		},
 		validate: (data, config) => {
 			if (caseit(data, config) !== data) throw new Error(`Is not ${config} case.`);
@@ -21,11 +27,11 @@ isvalid.plugins.use(function (utils) {
 	};
 });
 
-require('./ranges.js');
-require('./equals.js');
-require('./unique.js');
-require('./formalize.js');
-require('./validate.js');
-require('./middleware/');
-require('./key-paths');
-require('./merge');
+import './ranges.js';
+import './equals.js';
+import './unique.js';
+import './formalize.js';
+import './validate.js';
+import './middleware/index.js';
+import './key-paths.js';
+import './merge.js';

package/test/key-paths.js

@@ -1,7 +1,13 @@
-'use strict';
+//
+// key-paths.js
+//
+// Created by Kristian Trenskow on 2021-08-18
+//
+// See license in LICENSE
+//
 
-const expect = require('chai').expect,
-	keyPaths = require('../lib/key-paths.js');
+import { expect } from 'chai';
+import keyPaths from '../lib/key-paths.js';
 
 describe('keyPaths', () => {
 	it ('should come back with empty key paths', () => {

package/test/merge.js

@@ -1,7 +1,13 @@
-'use strict';
+//
+// merge.js
+//
+// Created by Kristian Trenskow on 2021-10-02
+//
+// See license in LICENSE
+//
 
-const expect = require('chai').expect,
-	merge = require('../lib/merge.js');
+import { expect } from 'chai';
+import merge from '../lib/merge.js';
 
 describe('merge', () => {
 	it ('should come back with destination type.', () => {

package/test/middleware/index.js

@@ -1,14 +1,17 @@
-'use strict';
+//
+// index.js
+//
+// Created by Kristian Trenskow on 2015-08-25
+//
+// See license in LICENSE
+//
 
-var request = require('supertest'),
-	expect = require('chai').expect;
+import request from 'supertest';
+import { expect } from 'chai';
 
-describe('middleware', function() {
+import app from './tools/server.js';
 
-	var app;
-	before(function() {
-		app = require('./tools/server.js');
-	});
+describe('middleware', function() {
 
 	describe('param validator', function() {
 

package/test/middleware/tools/server.js

@@ -1,8 +1,14 @@
-'use strict';
+//
+// server.js
+//
+// Created by Kristian Trenskow on 2015-07-27
+//
+// See license in LICENSE
+//
 
-var validate = require('../../../lib/middleware.js'),
-	express = require('express'),
-	bodyParser = require('body-parser');
+import { param, parameter, query, body } from '../../../lib/middleware.js';
+import express from 'express';
+import bodyParser from 'body-parser';
 
 // We build a simple express test in order to test the middleware
 //
@@ -10,11 +16,11 @@ var app = express();
 
 app.use(bodyParser.json());
 
-app.param('testParam', validate.param({
+app.param('testParam', param({
 	type: Number, required: true
 }));
 
-app.param('cbTestParam', validate.param({
+app.param('cbTestParam', param({
 	type: String,
 	required: true,
 	post: (data, schema, { options }) => {
@@ -23,7 +29,7 @@ app.param('cbTestParam', validate.param({
 }));
 
 app.get('/parameter/:testParam',
-	validate.parameter('testParam', {
+	parameter('testParam', {
 		type: Number,
 		post: (data) => data + 1
 	}),
@@ -38,7 +44,7 @@ app.get('/param/:testParam', function(req, res) {
 app.get('/cbParam/:cbTestParam', function() {});
 
 app.get('/query',
-	validate.query({
+	query({
 		'test': { type: String, match: /^.*?test$/i }
 	}),
 	function(req, res) {
@@ -47,7 +53,7 @@ app.get('/query',
 );
 
 app.post('/post',
-	validate.body({
+	body({
 		'test': [ { type: String, match: /^.*?test$/i } ]
 	}),
 	function(req, res) {
@@ -68,4 +74,4 @@ app.use(function(err, req, res, _) {
 	res.status(500).json({error: 'internal-server-error'});
 });
 
-exports = module.exports = app;
+export default app;

package/test/ranges.js

@@ -1,11 +1,17 @@
-'use strict';
+//
+// ranges.js
+//
+// Created by Kristian Trenskow on 2014-06-06
+//
+// See license in LICENSE
+//
 
-const expect = require('chai').expect,
-	ranges = require('../lib/ranges.js');
+import { expect } from 'chai';
+import { formalize, testIndex } from '../lib/ranges.js';
 
 function r(range, value) {
-	const formalized = ranges.formalize(range);
-	return ranges.testIndex(formalized, value);
+	const formalized = formalize(range);
+	return testIndex(formalized, value);
 }
 
 describe('ranges', function() {

package/test/unique.js

@@ -1,8 +1,13 @@
-/*jshint expr: true*/
-'use strict';
+//
+// unique.js
+//
+// Created by Kristian Trenskow on 2014-06-06
+//
+// See license in LICENSE
+//
 
-const expect = require('chai').expect,
-	unique = require('../lib/unique.js');
+import { expect } from 'chai';
+import unique from '../lib/unique.js';
 
 describe('unique', function() {
 	it('should return false if array of objects is not unique.', () => {

package/test/validate.js

@@ -1,12 +1,15 @@
-/*jshint expr: true*/
-'use strict';
+//
+// validate.js
+//
+// Created by Kristian Trenskow on 2014-06-06
+//
+// See license in LICENSE
+//
 
-const chai = require('chai'),
-	expect = chai.expect,
-	assert = chai.assert,
-	ValidationError = require('../lib/errors/validation.js'),
-	isvalid = require('../'),
-	utils = require('../lib/utils.js');
+import { expect, assert } from 'chai';
+import ValidationError from '../lib/errors/validation.js';
+import isvalid from '../index.js';
+import { typeName, instanceTypeName, isSameType } from '../lib/utils.js';
 
 class Test {
 	constructor() {
@@ -17,21 +20,21 @@ class Test {
 const commonTests = {
 	type: function(type, validData, invalidData) {
 		describe('type', function() {
-			it(`should come back with an error if input is not a(n) ${utils.typeName(type)}.`, () => {
+			it(`should come back with an error if input is not a(n) ${typeName(type)}.`, () => {
 				return expect(isvalid(invalidData, type))
-					.to.eventually.be.rejectedWith(`Is not of type ${utils.typeName(type)}.`)
+					.to.eventually.be.rejectedWith(`Is not of type ${typeName(type)}.`)
 					.and.to.be.instanceOf(ValidationError)
 					.and.to.have.property('validator', 'type');
 			});
-			it(`should come back with no error if input is a(n) ${utils.typeName(type)}.`, () => {
+			it(`should come back with no error if input is a(n) ${typeName(type)}.`, () => {
 				return expect(isvalid(validData, {
 					type: type
 				})).to.eventually.satisfy((data) => {
-					return utils.isSameType(utils.instanceTypeName(data), utils.typeName(type)) || (typeof type !== 'string' && data instanceof type);
+					return isSameType(instanceTypeName(data), typeName(type)) || (typeof type !== 'string' && data instanceof type);
 				});
 			});
 			describe('#errors', function() {
-				it(`should come back with an error of custom message if input is not a(n) ${utils.typeName(type)}.`, () => {
+				it(`should come back with an error of custom message if input is not a(n) ${typeName(type)}.`, () => {
 					return expect(isvalid(invalidData, {
 						type: type,
 						errors: {
@@ -59,7 +62,7 @@ const commonTests = {
 					type: type,
 					required: true
 				})).to.eventually.satisfy((data) => {
-					return utils.isSameType(utils.instanceTypeName(data), utils.typeName(type)) || (typeof type !== 'string' && data instanceof type);
+					return isSameType(instanceTypeName(data), typeName(type)) || (typeof type !== 'string' && data instanceof type);
 				});
 			});
 			it('should prioritize concrete over defaults.', () => {
@@ -83,43 +86,36 @@ const commonTests = {
 			});
 		});
 	},
-	allowNull: function(type) {
-		describe('allowNull', function() {
+	null: function(type) {
+		describe('null', function() {
 			it('should come back with an error if required and does not allow null and input is null.', () => {
 				return expect(isvalid(null, {
 					type: type,
+					null: 'deny',
 					required: true}))
 					.to.eventually.be.rejectedWith('Cannot be null.')
 					.and.to.be.instanceOf(ValidationError)
-					.and.to.have.property('validator', 'allowNull');
+					.and.to.have.property('validator', 'null');
 			});
-			it('should come back with no error if required and allows null and input is null.', () => {
+			it('should come back with no error if required and null is allowed and input is null.', () => {
 				return expect(isvalid(null, {
 					type: type,
 					required: true,
-					allowNull: true
+					null: 'allow'
 				})).to.eventually.be.null;
 			});
-			it('should prioritize concrete over defaults.', () => {
+			it('should come back with no error if required and null is allowed and input is null.', () => {
 				return expect(isvalid(null, {
 					type: type,
-					allowNull: false}, { defaults: { allowNull: true }}))
-					.to.eventually.be.rejectedWith('Cannot be null.')
-					.and.to.be.instanceOf(ValidationError)
-					.and.to.have.property('validator', 'allowNull');
+					required: true,
+					null: 'allow'
+				})).to.eventually.be.null;
 			});
-			describe('#errors', function() {
-				it('should come back with an error with custom message if required and does not allow null and input is null.', () => {
-					expect(isvalid(null, {
-						type: type,
-						required: true,
-						errors: {
-							allowNull: 'Allow null custom error message.'
-						}}))
-						.to.eventually.be.rejectedWith('Allow null custom error message.')
-						.and.to.be.instanceOf(ValidationError)
-						.and.has.property('validator', 'allowNull');
-				});
+			it('should come back with no error and undefined if null is set to undefine input and input is null.', () => {
+				return expect(isvalid(null, {
+					type: type,
+					null: 'undefine'
+				})).to.eventually.be.undefined;
 			});
 		});
 	},
@@ -129,19 +125,19 @@ const commonTests = {
 				return expect(isvalid(undefined, { type: type, default: async () => {
 					return validData;
 				}})).to.eventually.satisfy((data) => {
-					return utils.isSameType(utils.instanceTypeName(data), utils.typeName(type)) || (typeof type !== 'string' && data instanceof type);
+					return isSameType(instanceTypeName(data), typeName(type)) || (typeof type !== 'string' && data instanceof type);
 				});
 			});
 			it('should call default if default is a function.', () => {
 				return expect(isvalid(undefined, { type: type, default: () => {
 					return validData;
 				}})).to.eventually.satisfy((data) => {
-					return utils.isSameType(utils.instanceTypeName(data), utils.typeName(type)) || (typeof type !== 'string' && data instanceof type);
+					return isSameType(instanceTypeName(data), typeName(type)) || (typeof type !== 'string' && data instanceof type);
 				});
 			});
 			it('should call default if default is a value.', () => {
 				return expect(isvalid(undefined, { type: type, default: validData })).to.eventually.satisfy((data) => {
-					return utils.isSameType(utils.instanceTypeName(data), utils.typeName(type)) || (typeof type !== 'string' && data instanceof type);
+					return isSameType(instanceTypeName(data), typeName(type)) || (typeof type !== 'string' && data instanceof type);
 				});
 			});
 			it('should call default with options if options are provided.', () => {
@@ -314,7 +310,7 @@ const commonTests = {
 		});
 	},
 	all: function(type, validData, invalidData) { var self = this;
-		['type', 'required', 'allowNull', 'default', 'equal', 'post'].forEach(function(test) {
+		['type', 'required', 'null', 'default', 'equal', 'post'].forEach(function(test) {
 			self[test](type, validData, invalidData);
 		});
 	}

package/test/utils.js

@@ -1,17 +0,0 @@
-'use strict';
-
-module.exports = exports = {};
-
-exports.testPromise = (method, desc, s, expects) => {
-	it ('[promise] ' + desc, (done) => {
-		method(s)
-			.then((res) => {
-				expects(res);
-				done();
-			})
-			.catch((err) => {
-				expects(err);
-				done();
-			});
-	});
-};