isvalid 2.10.4 → 3.0.1

package/.eslintrc.js

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

package/README.md

@@ -42,6 +42,7 @@
         * [`enum`](#enum)
       - [`Number` Validators](#number-validators)
         * [`range`](#range)
+        * [`float`](#float)
       - [Custom Types](#custom-types)
   * [`post`](#post)
     + [Example](#example-1)
@@ -448,6 +449,26 @@ Examples:
 }
 ````
 
+> Negative values can be wrapped in parentheses.
+
+````javascript
+{
+	type: Array,
+	len: '(-2)-2',
+	schema: { … }
+}
+````
+
+> It also supports non-integer values.
+
+````javascript
+{
+	type: Array,
+	len: '(-2.2)-2.2',
+	schema: { … }
+}
+````
+
 > An array that should have at least 2 items, exactly 5 items or 8 or more items.
 
 ##### `unique`
@@ -498,7 +519,7 @@ This does not do any actual validation. Instead it trims the input in both ends
 ##### `len`
 Type: `String` or `Number`
 
-This ensures that the string's length is within a specified range. You can use the same formatting as [`Array`'s `len`](#len) validator.
+This ensures that the string's length is within a specified range. You can use the same formatting as [`Array`'s `len`](#len) validator described above (except it does not support ranges with negative values or non-integers).
 
 ##### `match`
 Type: `RegExp`
@@ -535,7 +556,21 @@ Type: `Number`or `String`
 
 This ensures that the number is within a certain range. If not the validator throws an error.
 
-The `range` validator uses the same formatting as the [`Array`'s `len`](#len) validator described above.
+The `range` validator uses the same formatting as the [`Array`'s `len`](#len) validator described above (except it does not support ranges with negative values or non-integers).
+
+##### `float`
+Type: `String` of value: `'allow'`, `'deny'`, `'round'`, `'floor'`, `'ceil'`
+
+This tells the validator how to handle non-integers.
+
+The validator has five options:
+* `'allow'` Allow non-integer values.
+* `'deny'` Throw a `ValidationError` if the value is a non-integer.
+* `'round'` Round value to nearest integer.
+* `'floor'` Round to integer less than or equal to value.
+* `'ceil'` Round to integer bigger than or equal to value.
+
+> Default is `'allow'`.
 
 #### Custom Types
 

package/lib/errors/validation.js

@@ -17,7 +17,7 @@ module.exports = exports = class ValidationError extends Error {
 	}
 
 	static fromError(keyPath, schema, validator, err) {
-		let validationError = new ValidationError(keyPath, schema, validator, err.message);
+		let validationError = new ValidationError(err.keyPath || keyPath, err.schema || schema, err.validator || validator, err.message);
 		validationError.stack = err.stack;
 		validationError.underlying = err;
 		return validationError;

package/lib/formalize.js

@@ -2,7 +2,8 @@
 
 const merge = require('merge'),
 	SchemaError = require('./errors/schema.js'),
-	utils = require('./utils.js');
+	utils = require('./utils.js'),
+	ranges = require('./ranges.js');
 
 const finalize = (formalizedSchema, nonFormalizedSchema) => {
 
@@ -77,7 +78,7 @@ const formalizeAny = (schema, options = {}) => {
 			return formalizeObject({ type: Object, schema: schema }, schema, options);
 		}
 		if ('array' == utils.instanceTypeName(schema)) {
-			if (schema.length === 0) throw new SchemaError(schema, 'Array must have exactly one schema.');
+			if (schema.length === 0) return formalizeAny({ type: Array }, schema. options);
 			return formalizeArray({ type: Array, schema: schema[0] }, schema, options);
 		}
 		if ((typeof schema === 'string' && schema.length) || (typeof schema === 'function' && utils.typeName(schema) !== undefined)) {
@@ -125,7 +126,8 @@ const formalizeAny = (schema, options = {}) => {
 			'enum': [ 'array' ]
 		});
 		if (utils.isSameType('number', utils.typeName(type))) merge(validators, {
-			'range': [ 'string', 'number' ]
+			'range': [ 'string', 'number' ],
+			'float': [ 'string' ]
 		});
 	}
 
@@ -209,6 +211,31 @@ const formalizeAny = (schema, options = {}) => {
 		);
 	}
 
+	// Check number float
+	if (typeof formalizedSchema.float === 'string' &&
+			['allow', 'deny', 'round', 'floor', 'ceil'].indexOf(formalizedSchema.float) == -1) {
+		throw new SchemaError(
+			schema,
+			'Validator `float` must have value `\'allow\'`, `\'deny\'`, `\'round\'`, `\'floor\'` or `\'ceil\'`.'
+		);
+	}
+
+	// Check len
+	if (typeof formalizedSchema.len !== 'undefined') {
+		formalizedSchema.len = ranges.formalize(formalizedSchema.len, {
+			allowNegative: false,
+			allowNonIntegers: false
+		});
+	}
+
+	// Check range
+	if (typeof formalizedSchema.range !== 'undefined') {
+		formalizedSchema.range = ranges.formalize(formalizedSchema.range, {
+			allowNegative: true,
+			allowNonIntegers: true
+		});
+	}
+
 	// Check string enums
 	if (typeof formalizedSchema.enum !== 'undefined') {
 		if (formalizedSchema.enum.length < 1) {

package/lib/ranges.js

@@ -1,6 +1,15 @@
 'use strict';
 
-module.exports.testIndex = function(ranges, index) {
+const
+	SchemaError = require('./errors/schema.js');
+
+module.exports.testIndex = function(ranges, value) {
+	return ranges.some(({ lower, upper }) => {
+		return lower <= value && upper >= value;
+	});
+};
+
+module.exports.formalize = function(ranges, options) {
 
 	// Convert to string if ranges is a Number.
 	if (ranges !== undefined && typeof ranges === 'number') {
@@ -12,45 +21,50 @@ module.exports.testIndex = function(ranges, index) {
 		throw new Error('Ranges must be a number or a string expressed as: ex. \'-2,4-6,8,10-\'.');
 	}
 
-	// Throw if index is not a number.
-	if (index === undefined || typeof index !== 'number') {
-		throw new Error('Index is not a number.');
-	}
+	return ranges
+		.split(',')
+		.map((range) => {
 
-	// Split into individual ranges.
-	let r = ranges.split(',');
-	for (let idx in r) {
+			// Get the boundaries of the range.
+			let boundaries = range.split(/(?<!\()-/);
 
-		// Get the boundaries of the range.
-		let boundaries = r[idx].split('-');
+			// Low and high boundaries are the same where only one number is specified.
+			if (boundaries.length == 1) boundaries = [ boundaries[0], boundaries[0] ];
+			// Throw an error if there is not exactly to boundaries.
+			if (boundaries.length != 2) throw new SchemaError('Malformed range \'' + range + '\'.');
 
-		// Low and high boundaries are the same where only one number is specified.
-		if (boundaries.length == 1) boundaries = [ boundaries[0], boundaries[0] ];
-		// Throw an error if there is not exactly to boundaries.
-		if (boundaries.length != 2) throw new Error('Malformed range \'' + r[idx] + '\'.');
+			// Test for malformed boundaries
+			for (let bIdx = 0 ; bIdx < 2 ; bIdx++) {
+				if (!/^\(?[-0-9.]*\)?$/.test(boundaries[bIdx])) throw new SchemaError('Malformed boundary \'' + boundaries[bIdx] + '\'.');
+			}
 
-		// Test for malformed boundaries
-		for (let bIdx = 0 ; bIdx < 2 ; bIdx++) {
-			if (!/^[0-9]*$/.test(boundaries[bIdx])) throw new Error('Malformed boundary \'' + boundaries[bIdx] + '\'.');
-		}
+			boundaries = boundaries.map((boundary) => boundary.match(/^\(?([-0-9.]*)\)?$/)[1] || '');
 
-		let lowBoundary = boundaries[0];
-		let highBoundary = boundaries[1];
+			let lower = boundaries[0];
+			let upper = boundaries[1];
 
-		// If no lower boundary is specified we use -Infinity
-		if (lowBoundary.length === 0) lowBoundary = -Infinity;
-		else lowBoundary = parseInt(lowBoundary);
+			if ((options || {}).allowNegative === false && (lower < 0 || upper < 0)) {
+				throw new SchemaError('Boundary cannot be a negative value.');
+			}
 
-		// If no higher boundary is specified we use Infinity;
-		if (highBoundary.length === 0) highBoundary = Infinity;
-		else highBoundary = parseInt(highBoundary);
+			if ((options || {}).allowNonInteger === false && (!Number.isInteger(lower) || !Number.isInteger(upper))) {
+				throw new SchemaError('Boundary cannot be a non-integer value.');
+			}
 
-		// If index is within boundaries return true;
-		if (index >= lowBoundary && index <= highBoundary) return true;
+			// If no lower boundary is specified we use -Infinity
+			if (lower.length === 0) lower = -Infinity;
+			else lower = parseFloat(lower);
 
-	}
+			// If no higher boundary is specified we use Infinity;
+			if (upper.length === 0) upper = Infinity;
+			else upper = parseFloat(upper);
+
+			if (lower > upper) {
+				throw new SchemaError('Malformed range \'' + range +'\'');
+			}
+
+			return { lower, upper };
 
-	// Index was not matched to any range.
-	return false;
+		});
 
 };

package/lib/validate.js

@@ -30,6 +30,9 @@ const validateObject = async (data, schema, options, keyPath, validatedData) =>
 			);
 		}
 
+		// If there is no schema we just return the object.
+		if (typeof schema.schema === 'undefined') return data;
+
 		// Find unknown keys
 		for (let key in data) {
 			if (schema.schema[key] === undefined) {
@@ -87,9 +90,11 @@ const validateArray = async (data, schema, options, keyPath, validatedData) => {
 			}
 		}
 
-		data = await Promise.all(data.map((data, idx) => {
-			return validateAny(data, schema.schema, options, keyPath.concat([idx]), validatedData);
-		}));
+		if (typeof schema.schema !== 'undefined') {
+			data = await Promise.all(data.map((data, idx) => {
+				return validateAny(data, schema.schema, options, keyPath.concat([idx]), validatedData);
+			}));
+		}
 
 		if ((schema.len || options.defaults.len) && !ranges.testIndex((schema.len || options.defaults.len), data.length)) {
 			throw new ValidationError(
@@ -201,6 +206,30 @@ const validateNumber = async (data, schema, options, keyPath) => {
 		}
 	}
 
+	if (schema.float || options.defaults.float) {
+		if (!Number.isInteger(data)) {
+			switch (schema.float) {
+			case 'deny':
+				throw new ValidationError(
+					keyPath,
+					schema._nonFormalizedSchema,
+					'unknownKeys',
+					(schema.errors || {}).float || customErrorMessage(((options.errorMessages || {}).number || {}).float || 'Number must be an integer.'));
+			case 'round':
+				data = Math.round(data);
+				break;
+			case 'floor':
+				data = Math.floor(data);
+				break;
+			case 'ceil':
+				data = Math.ceil(data);
+				break;
+			default:
+				break;
+			}
+		}
+	}
+
 	return data;
 
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isvalid",
-  "version": "2.10.4",
+  "version": "3.0.1",
   "description": "Async JSON validation library for node.js.",
   "main": "./index.js",
   "keywords": [
@@ -18,13 +18,13 @@
     "merge": "^2.1.1"
   },
   "devDependencies": {
-    "body-parser": "^1.19.0",
-    "chai": "^4.2.0",
+    "body-parser": "^1.20.0",
+    "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
-    "eslint": "^8.2.0",
-    "express": "^4.17.1",
-    "mocha": "^9.1.3",
-    "supertest": "^6.1.6"
+    "eslint": "^8.12.0",
+    "express": "^4.17.3",
+    "mocha": "^9.2.2",
+    "supertest": "^6.2.2"
   },
   "scripts": {
     "test": "./node_modules/mocha/bin/mocha ./test/index.js"

package/test/formalize.js

@@ -12,9 +12,6 @@ const f = (...args) => {
 
 describe('schema', function() {
 	describe('formalizer', function() {
-		it('should throw an error if array shortcut contains no object.', () => {
-			expect(f([])).to.throw(SchemaError);
-		});
 		it('should throw an error if schema is garbage value.', () => {
 			expect(f(123)).to.throw(SchemaError);
 		});
@@ -168,10 +165,19 @@ describe('schema', function() {
 				equal: '123'
 			})).to.have.property('equal').equal('123');
 		});
-		it('should come back with a priority if non is provided', () => {
+		it('should come back with a priority if non is provided.', () => {
 			expect(formalize({
 				type: Number
 			})).to.have.property('priority').equal(10);
 		});
+		it ('should throw error if number range is not valid.', () => {
+			expect(f({ type: Number, range: 'abc-abc' })).to.throw(SchemaError);
+		});
+		it ('should throw error if string len is negative.', () => {
+			expect(f({ type: String, len: '-2-' })).to.throw(SchemaError);
+		});
+		it ('should throw error if array len is negative.', () => {
+			expect(f({ type: Array, len: '-2-' })).to.throw(SchemaError);
+		});
 	});
 });

package/test/ranges.js

@@ -3,31 +3,42 @@
 const expect = require('chai').expect,
 	ranges = require('../lib/ranges.js');
 
+function r(range, value) {
+	const formalized = ranges.formalize(range);
+	return ranges.testIndex(formalized, value);
+}
+
 describe('ranges', function() {
 	it ('should throw an error if ranges is not a string.', function() {
 		expect(function() {
-			ranges.testIndex([123], 1);
+			r([123], 1);
 		}).to.throw(Error);
 	});
 	it ('should throw no error if ranges is a number.', function() {
 		expect(function() {
-			ranges.testIndex(1, 1);
+			r(1, 1);
 		}).not.to.throw(Error);
 	});
 	it ('should throw error if ranges is string but format is invalid.', function() {
 		expect(function() {
-			ranges.testIndex('abc', 1);
+			r('abc', 1);
 		}).to.throw(Error);
 	});
 	it ('should throw error if index is not set.', function() {
 		expect(function() {
-			ranges.testIndex(1);
+			r(1);
 		});
 	});
 	it ('should return true if index is within range.', function() {
-		expect(ranges.testIndex('-2,4-6,8,10-', 2)).to.equal(true);
+		expect(r('-2,4-6,8,10-', 2)).to.equal(true);
 	});
 	it ('should return false if index is not within range.', function() {
-		expect(ranges.testIndex('-2,4-6,8,10-', 3)).to.equal(false);
+		expect(r('-2,4-6,8,10-', 3)).to.equal(false);
+	});
+	it ('should allow negative values wrapped in parentheses.', function() {
+		expect(r('(-2)-', -1)).to.equal(true);
+	});
+	it ('should allow for decimal values.', function() {
+		expect(r('(-2.2)-2.2', 0.1)).to.equal(true);
 	});
 });

package/test/validate.js

@@ -360,6 +360,9 @@ describe('validate', function() {
 	});
 	describe('object validator', function() {
 		commonTests.all(Object, {}, 123);
+		it('should come back with same input if sub-schema is not provided.', () => {
+			return expect(isvalid({}, {})).to.eventually.eql({});
+		});
 		it('should come out with same input as output if keys can validate.', () => {
 			let s = isvalid({
 				awesome: true,
@@ -480,7 +483,10 @@ describe('validate', function() {
 	});
 	describe('array validator', function() {
 		commonTests.all(Array, [], 123);
-		it('should come out with same input as output if array can validate.', () => {
+		it('should come back with same input if no sub-schema is provided.', () => {
+			return expect(isvalid([], [])).to.eventually.eql([]);
+		});
+		it('should come back with same input as output if array can validate.', () => {
 			let s = isvalid([{
 				awesome: true,
 				why: 'it just is!'
@@ -706,6 +712,21 @@ describe('validate', function() {
 			return expect(isvalid(123, Number))
 				.to.eventually.equal(123);
 		});
+		it('should throw error if non-integers are not allowed.', () => {
+			expect(isvalid(2.2, { type: Number, float: 'deny' })).to.eventually.throw(ValidationError);
+		});
+		it ('should come back with non-integer values if they are allowed.', () => {
+			expect(isvalid(2.2, { type: Number })).to.eventually.equal(2.2);
+		});
+		it ('should come back with number rounded if `float` is set to `round`.', () => {
+			expect(isvalid(2.5, { type: Number, float: 'round' })).to.eventually.equal(3);
+		});
+		it ('should come back with number ceiled if `float` is set to `ceil`.', () => {
+			expect(isvalid(2.2, { type: Number, float: 'ceil' })).to.eventually.equal(3);
+		});
+		it ('should come back with number floored if `float` is set to `floor`.', () => {
+			expect(isvalid(2.8, { type: Number, float: 'ceil' })).to.eventually.equal(2);
+		});
 		describe('range', function() {
 			it('should come back with error if input is not within range.', () => {
 				return expect(isvalid(1, { type: Number, range: '2-4' }))