isvalid 2.10.2 → 2.10.5

package/lib/formalize.js

@@ -77,7 +77,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)) {

package/lib/key-paths.js

@@ -8,7 +8,17 @@ exports = module.exports = (schema, formalizeOptions) => {
 	schema = formalize(schema, formalizeOptions);
 
 	return {
-		all: (types, keyPath = []) => {
+		all: (types, options, keyPath = [], level = 0) => {
+
+			if (typeof types === 'object' && types !== null && !Array.isArray(types)) {
+				options = types;
+				types = [];
+			}
+
+			options = options || {};
+			options.maxDepth = typeof options.maxDepth !== 'undefined' ? options.maxDepth : Infinity;
+
+			if (typeof options.maxDepth !== 'number') throw new Error('Maximum depth must be a number.');
 
 			if (!types) types = [];
 			if (!Array.isArray(types)) types = [types];
@@ -21,15 +31,19 @@ exports = module.exports = (schema, formalizeOptions) => {
 
 			if (types.length == 0 || types.includes(typeName)) result.push(keyPath.join('.'));
 
-			switch (typeName) {
-			case 'object':
-				result = result.concat(...Object.keys(schema.schema).map((key) => {
-					return exports(schema.schema[key]).all(types, keyPath.concat([key]));
-				}));
-				break;
-			case 'array':
-				result = result.concat(exports(schema.schema).all(types, keyPath));
-				break;
+			if (level < options.maxDepth) {
+
+				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);
+					}));
+					break;
+				case 'array':
+					result = result.concat(exports(schema.schema).all(types, options, keyPath, level + 1));
+					break;
+				}
+
 			}
 
 			let uniqueResult = [];

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(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "isvalid",
-  "version": "2.10.2",
+  "version": "2.10.5",
   "description": "Async JSON validation library for node.js.",
   "main": "./index.js",
   "keywords": [
@@ -21,10 +21,10 @@
     "body-parser": "^1.19.0",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
-    "eslint": "^7.18.0",
+    "eslint": "^8.2.0",
     "express": "^4.17.1",
-    "mocha": "^8.2.1",
-    "supertest": "^3.4.2"
+    "mocha": "^9.1.3",
+    "supertest": "^6.1.6"
   },
   "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);
 		});

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!'