isvalid 4.0.20 → 4.0.22

package/lib/formalize.js

@@ -136,7 +136,7 @@ const formalizeAny = (schema, options = {}) => {
 			'len': [ 'string', 'number' ],
 			'match': [ 'regexp' ],
 			'trim': [ 'boolean' ],
-			'enum': [ 'array' ]
+			'enum': [ 'array', 'object' ]
 		});
 		if (isSameType('number', typeName(type))) merge(validators, {
 			'range': [ 'string', 'number', testFormalizedRange ],
@@ -293,20 +293,38 @@ const formalizeAny = (schema, options = {}) => {
 
 	// Check string enums
 	if (typeof formalizedSchema.enum !== 'undefined') {
-		if (formalizedSchema.enum.length < 1) {
+
+		let wasArray = false;
+
+		if (Array.isArray(formalizedSchema.enum)) {
+			wasArray = true;
+			for (let value of formalizedSchema.enum) {
+				if (typeof value !== 'string') {
+					throw new SchemaError(
+						schema,
+						wasArray ? 'Validator `enum` must be an array of strings.' : 'Validator `enum` must be an object with string keys.'
+					);
+				}
+			}
+			formalizedSchema.enum = Object.fromEntries(formalizedSchema.enum.map((value) => [value, value]));
+		}
+
+		if (typeof formalizedSchema.enum !== 'object' || formalizedSchema.enum === null) {
 			throw new SchemaError(
 				schema,
-				'Validator `enum` must have at least one item.'
+				'Validator `enum` must be an array or object.'
 			);
 		}
-		for (var idx in formalizedSchema.enum) {
-			if (typeof formalizedSchema.enum[idx] !== 'string') {
-				throw new SchemaError(
-					schema,
-					'Validator `enum` must be an array of strings.'
-				);
-			}
+
+		const keys = Object.keys(formalizedSchema.enum);
+
+		if (keys.length < 1) {
+			throw new SchemaError(
+				schema,
+				'Validator `enum` must have at least one item.'
+			);
 		}
+
 	}
 
 	// Add priority if not added.

package/lib/validate.js

@@ -165,13 +165,13 @@ const validateString = async (data, schema, options, keyPath) => {
 	}
 
 	// Validate enums
-	if ((schema.enum || options.defaults.enum) && (schema.enum || options.defaults.enum).indexOf(data) == -1) {
+	if ((schema.enum || options.defaults.enum) && Object.keys(schema.enum || options.defaults.enum).indexOf(data) == -1) {
 		throw new ValidationError(
 			keyPath,
 			schema._nonFormalizedSchema,
 			'enum',
 			(schema.errors || {}).enum || customErrorMessage(((options.errorMessages || {}).string || {}).enum || ((values) => {
-				return `Possible values are ${values.map(function(val) {
+				return `Possible values are ${Object.keys(values).map(function(val) {
 					return '"' + val + '"';
 				}).reduce(function(prev, cur, idx, arr) {
 					return prev + (idx == arr.length - 1 ? ' and ' : ', ') + cur;

package/package.json

@@ -1,47 +1,47 @@
 {
-  "name": "isvalid",
-  "version": "4.0.20",
-  "description": "Async JSON validation library for node.js.",
-  "main": "./index.js",
-  "type": "module",
-  "keywords": [
-    "schema",
-    "validation",
-    "JSON",
-    "rest",
-    "api",
-    "blob",
-    "validate",
-    "express",
-    "connect"
-  ],
-  "dependencies": {
-    "merge": "^2.1.1"
-  },
-  "devDependencies": {
-    "@trenskow/caseit": "^1.3.11",
-    "body-parser": "^1.20.2",
-    "chai": "^5.0.0",
-    "chai-as-promised": "^7.1.1",
-    "eslint": "^8.56.0",
-    "express": "^4.18.2",
-    "mocha": "^10.2.0",
-    "supertest": "^6.3.4"
-  },
-  "scripts": {
-    "test": "./node_modules/mocha/bin/mocha.js ./test/index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/trenskow/isvalid.git"
-  },
-  "license": "MIT",
-  "author": {
-    "name": "Kristian Trenskow",
-    "email": "trenskow@me.com",
-    "url": "https://github.com/trenskow"
-  },
-  "overrides": {
-    "chai": "^5.0.0"
-  }
+	"name": "isvalid",
+	"version": "4.0.22",
+	"description": "Async JSON validation library for node.js.",
+	"main": "./index.js",
+	"type": "module",
+	"keywords": [
+		"schema",
+		"validation",
+		"JSON",
+		"rest",
+		"api",
+		"blob",
+		"validate",
+		"express",
+		"connect"
+	],
+	"dependencies": {
+		"merge": "^2.1.1"
+	},
+	"devDependencies": {
+		"@trenskow/caseit": "^1.3.11",
+		"body-parser": "^1.20.2",
+		"chai": "^5.0.0",
+		"chai-as-promised": "^7.1.1",
+		"eslint": "^8.56.0",
+		"express": "^4.18.2",
+		"mocha": "^10.2.0",
+		"supertest": "^6.3.4"
+	},
+	"scripts": {
+		"test": "./node_modules/mocha/bin/mocha.js ./test/index.js"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/trenskow/isvalid.git"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "Kristian Trenskow",
+		"email": "trenskow@me.com",
+		"url": "https://github.com/trenskow"
+	},
+	"overrides": {
+		"chai": "^5.0.0"
+	}
 }

package/test/equals.js

@@ -44,14 +44,14 @@ describe('equals', function() {
 	it('should return false if dates are not equal.', () => {
 		return expect(equals(d1, d2)).to.eventually.be.false;
 	});
-	it ('should return true if objects are equal.', () => {
+	it('should return true if objects are equal.', () => {
 		return expect(equals({
 			awesome: true
 		}, {
 			awesome: true
 		})).to.eventually.be.true;
 	});
-	it ('should return false if object are not equal.', () => {
+	it('should return false if object are not equal.', () => {
 		return expect(equals({
 			awesome: true
 		}, {
@@ -64,14 +64,14 @@ describe('equals', function() {
 	it('should return false if arrays are not equal.', () => {
 		return expect(equals(['This','is','an','array'], ['This','is','another','array'])).to.eventually.be.false;
 	});
-	it ('should return true if objects with arrays are equal.', () => {
+	it('should return true if objects with arrays are equal.', () => {
 		return expect(equals({
 			obj: ['This','is','an','array']
 		}, {
 			obj: ['This','is','an','array']
 		})).to.eventually.be.true;
 	});
-	it ('should return false if objects with arrays are not equal.', () => {
+	it('should return false if objects with arrays are not equal.', () => {
 		return expect(equals({
 			obj: ['This','is','an','array']
 		}, {

package/test/formalize.js

@@ -42,13 +42,24 @@ describe('schema', function() {
 		it('should come back with enum intact', () => {
 			expect(formalize({ type: String, enum: ['this', 'test']}))
 				.to.have.property('enum')
-				.to.have.property(1, 'test');
+				.to.eql({
+					'this': 'this',
+					'test': 'test'
+				});
 		});
 		it('should come back with enum intact (custom error message)', () => {
 			expect(formalize({ type: String, enum: [['this', 'test'], 'Must be this or test.'] }))
 				.to.have.property('errors')
 				.to.have.property('enum', 'Must be this or test.');
 		});
+		it('should come back with enum allowed if it is an object.', () => {
+			expect(formalize({ type: String, enum: { this: 'this is', test: 'a test' } }))
+				.to.have.property('enum')
+				.to.eql({
+					'this': 'this is',
+					'test': 'a test'
+				});
+		});
 		it('should throw an error if schema type cannot be determined.', () => {
 			expect(f({ type: '' })).to.throw(SchemaError);
 		});

package/test/middleware/tools/server.js

@@ -12,7 +12,7 @@ import bodyParser from 'body-parser';
 
 // We build a simple express test in order to test the middleware
 //
-var app = express();
+const app = express();
 
 app.use(bodyParser.json());
 

package/test/validate.js

@@ -309,7 +309,7 @@ const commonTests = {
 			});
 		});
 	},
-	all: function(type, validData, invalidData) { var self = this;
+	all: function(type, validData, invalidData) { let self = this;
 		['type', 'required', 'null', 'default', 'equal', 'post'].forEach(function(test) {
 			self[test](type, validData, invalidData);
 		});