@vsaas/loopback-datasource-juggler 10.0.0

package/dist/lib/validations.js

@@ -0,0 +1,742 @@
+"use strict";
+const require_runtime = require("../_virtual/_rolldown/runtime.js");
+const require_lib_globalize = require("./globalize.js");
+//#region src/lib/validations.ts
+var require_validations = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	const g = require_lib_globalize();
+	const util = require("util");
+	/*!
+	* Module exports
+	*/
+	exports.ValidationError = ValidationError;
+	exports.Validatable = Validatable;
+	/**
+	* This class provides methods that add validation cababilities to models.
+	* Each of the validations runs when the `obj.isValid()` method is called.
+	*
+	* All of the methods have an options object parameter that has a
+	* `message` property.  When there is only a single error message, this property is just a string;
+	* for example: `Post.validatesPresenceOf('title', { message: 'can not be blank' });`
+	*
+	* In more complicated cases it can be a set of messages, for each possible error condition; for example:
+	* `User.validatesLengthOf('password', { min: 6, max: 20, message: {min: 'too short', max: 'too long'}});`
+	* @class Validatable
+	*/
+	function Validatable() {}
+	/**
+	* Validate presence of one or more specified properties.
+	*
+	* Requires a model to include a property to be considered valid; fails when validated field is blank.
+	*
+	* For example, validate presence of title
+	* ```
+	* Post.validatesPresenceOf('title');
+	* ```
+	* Validate that model has first, last, and age properties:
+	* ```
+	* User.validatesPresenceOf('first', 'last', 'age');
+	* ```
+	* Example with custom message
+	* ```
+	* Post.validatesPresenceOf('title', {message: 'Cannot be blank'});
+	* ```
+	*
+	* @param {String} propertyName  One or more property names.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {String} message Error message to use instead of default.
+	* @property {String} if Validate only if `if` exists.
+	* @property {String} unless Validate only if `unless` exists.
+	*/
+	Validatable.validatesPresenceOf = getConfigurator("presence");
+	/**
+	* Validate absence of one or more specified properties.
+	*
+	* A model should not include a property to be considered valid; fails when validated field is not blank.
+	*
+	* For example, validate absence of reserved
+	* ```
+	* Post.validatesAbsenceOf('reserved', { unless: 'special' });
+	* ```
+	*
+	* @param {String} propertyName  One or more property names.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {String} message Error message to use instead of default.
+	* @property {String} if Validate only if `if` exists.
+	* @property {String} unless Validate only if `unless` exists.
+	*/
+	Validatable.validatesAbsenceOf = getConfigurator("absence");
+	/**
+	* Validate length.
+	*
+	* Require a property length to be within a specified range.
+	*
+	* There are three kinds of validations: min, max, is.
+	*
+	* Default error messages:
+	*
+	* - min: too short
+	* - max: too long
+	* - is: length is wrong
+	*
+	* Example: length validations
+	* ```
+	* User.validatesLengthOf('password', {min: 7});
+	* User.validatesLengthOf('email', {max: 100});
+	* User.validatesLengthOf('state', {is: 2});
+	* User.validatesLengthOf('nick', {min: 3, max: 15});
+	* ```
+	* Example: length validations with custom error messages
+	* ```
+	* User.validatesLengthOf('password', {min: 7, message: {min: 'too weak'}});
+	* User.validatesLengthOf('state', {is: 2, message: {is: 'is not valid state name'}});
+	* ```
+	*
+	* @param {String} propertyName  Property name to validate.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {Number} is Value that property must equal to validate.
+	* @property {Number} min Value that property must be less than to be valid.
+	* @property {Number} max Value that property must be less than to be valid.
+	* @property {Object} message Optional object with string properties for custom error message for each validation: is, min, or max.
+	*/
+	Validatable.validatesLengthOf = getConfigurator("length");
+	/**
+	* Validate numericality.
+	*
+	* Requires a value for property to be either an integer or number.
+	*
+	* Example
+	* ```
+	* User.validatesNumericalityOf('age', { message: { number: 'is not a number' }});
+	* User.validatesNumericalityOf('age', {int: true, message: { int: 'is not an integer' }});
+	* ```
+	*
+	* @param {String} propertyName  Property name to validate.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {Boolean} int If true, then property must be an integer to be valid.
+	* @property {Boolean} allowBlank Allow property to be blank.
+	* @property {Boolean} allowNull Allow property to be null.
+	* @property {Object} message Optional object with string properties for 'int' for integer validation. Default error messages:
+	* - number: is not a number
+	* - int: is not an integer
+	*/
+	Validatable.validatesNumericalityOf = getConfigurator("numericality");
+	/**
+	* Validate inclusion in set.
+	*
+	* Require a value for property to be in the specified array.
+	*
+	* Example:
+	* ```
+	* User.validatesInclusionOf('gender', {in: ['male', 'female']});
+	* User.validatesInclusionOf('role', {
+	*     in: ['admin', 'moderator', 'user'], message: 'is not allowed'
+	* });
+	* ```
+	*
+	* @param {String} propertyName  Property name to validate.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {Array} in Property must match one of the values in the array to be valid.
+	* @property {String} message Optional error message if property is not valid.
+	* Default error message: "is not included in the list".
+	* @property {Boolean} allowNull Whether null values are allowed.
+	*/
+	Validatable.validatesInclusionOf = getConfigurator("inclusion");
+	/**
+	* Validate exclusion in a set.
+	*
+	* Require a property value not be in the specified array.
+	*
+	* Example: `Company.validatesExclusionOf('domain', {in: ['www', 'admin']});`
+	*
+	* @param {String} propertyName  Property name to validate.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {Array} in Property must not match any of the values in the array to be valid.
+	* @property {String} message Optional error message if property is not valid. Default error message: "is reserved".
+	* @property {Boolean} allowNull Whether null values are allowed.
+	*/
+	Validatable.validatesExclusionOf = getConfigurator("exclusion");
+	/**
+	* Validate format.
+	*
+	* Require a model to include a property that matches the given format.
+	*
+	* Example: `User.validatesFormatOf('name', {with: /\w+/});`
+	*
+	* @param {String} propertyName  Property name to validate.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {RegExp} with Regular expression to validate format.
+	* @property {String} message Optional error message if property is not valid. Default error message: " is invalid".
+	* @property {Boolean} allowNull Whether null values are allowed.
+	*/
+	Validatable.validatesFormatOf = getConfigurator("format");
+	/**
+	* Validate using custom validation function.
+	*
+	* Example:
+	*```javascript
+	*     User.validate('name', customValidator, {message: 'Bad name'});
+	*     function customValidator(err) {
+	*         if (this.name === 'bad') err();
+	*     });
+	*     var user = new User({name: 'Peter'});
+	*     user.isValid(); // true
+	*     user.name = 'bad';
+	*     user.isValid(); // false
+	* ```
+	*
+	* @param {String} propertyName  Property name to validate.
+	* @param {Function} validatorFn Custom validation function.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {String} message Optional error message if property is not valid. Default error message: " is invalid".
+	* @property {Boolean} allowNull Whether null values are allowed.
+	*/
+	Validatable.validate = getConfigurator("custom");
+	/**
+	* Validate using custom asynchronous validation function.
+	*
+	* Example:
+	*```js
+	*     User.validateAsync('name', customValidator, {message: 'Bad name'});
+	*     function customValidator(err, done) {
+	*         process.nextTick(function () {
+	*             if (this.name === 'bad') err();
+	*             done();
+	*         });
+	*     });
+	*     var user = new User({name: 'Peter'});
+	*     user.isValid(); // false (because async validation setup)
+	*     user.isValid(function (isValid) {
+	*         isValid; // true
+	*     })
+	*     user.name = 'bad';
+	*     user.isValid(); // false
+	*     user.isValid(function (isValid) {
+	*         isValid; // false
+	*     })
+	* ```
+	*
+	* @param {String} propertyName  Property name to validate.
+	* @param {Function} validatorFn Custom validation function.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {String} message Optional error message if property is not valid. Default error message: " is invalid".
+	* @property {Boolean} allowNull Whether null values are allowed.
+	*/
+	Validatable.validateAsync = getConfigurator("custom", { async: true });
+	/**
+	* Validate uniqueness of the value for a property in the collection of models.
+	*
+	* Not available for all connectors. Currently supported with these connectors:
+	*  - In Memory
+	*  - Oracle
+	*  - MongoDB
+	*
+	* ```
+	* // The login must be unique across all User instances.
+	* User.validatesUniquenessOf('login');
+	*
+	* // Assuming SiteUser.belongsTo(Site)
+	* // The login must be unique within each Site.
+	* SiteUser.validateUniquenessOf('login', { scopedTo: ['siteId'] });
+	* ```
+	*
+	* @param {String} propertyName  Property name to validate.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {RegExp} with Regular expression to validate format.
+	* @property {Array.<String>} scopedTo List of properties defining the scope.
+	* @property {String} message Optional error message if property is not valid. Default error message: "is not unique".
+	* @property {Boolean} allowNull Whether null values are allowed.
+	* @property {String} ignoreCase Make the validation case insensitive.
+	* @property {String} if Validate only if `if` exists.
+	* @property {String} unless Validate only if `unless` exists.
+	*/
+	Validatable.validatesUniquenessOf = getConfigurator("uniqueness", { async: true });
+	/**
+	* Validate if a value for a property is a Date.
+	*
+	* Example
+	* ```
+	* User.validatesDateOf('today', {message: 'today is not a date!'});
+	* ```
+	*
+	* @param {String} propertyName  Property name to validate.
+	* @options {Object} options Configuration parameters; see below.
+	* @property {String} message Error message to use instead of default.
+	*/
+	Validatable.validatesDateOf = getConfigurator("date");
+	/*!
+	* Presence validator
+	*/
+	function validatePresence(attr, conf, err, _options) {
+		if (blank(this[attr])) err();
+	}
+	/*!
+	* Absence validator
+	*/
+	function validateAbsence(attr, conf, err, _options) {
+		if (!blank(this[attr])) err();
+	}
+	/*!
+	* Length validator
+	*/
+	function validateLength(attr, conf, err, _options) {
+		if (nullCheck.call(this, attr, conf, err)) return;
+		const len = this[attr].length;
+		if (conf.min && len < conf.min) err("min");
+		if (conf.max && len > conf.max) err("max");
+		if (conf.is && len !== conf.is) err("is");
+	}
+	/*!
+	* Numericality validator
+	*/
+	function validateNumericality(attr, conf, err, _options) {
+		if (nullCheck.call(this, attr, conf, err)) return;
+		if (typeof this[attr] !== "number" || isNaN(this[attr])) return err("number");
+		if (conf.int && this[attr] !== Math.round(this[attr])) return err("int");
+	}
+	/*!
+	* Inclusion validator
+	*/
+	function validateInclusion(attr, conf, err, _options) {
+		if (nullCheck.call(this, attr, conf, err)) return;
+		if (!~conf.in.indexOf(this[attr])) err();
+	}
+	/*!
+	* Exclusion validator
+	*/
+	function validateExclusion(attr, conf, err, _options) {
+		if (nullCheck.call(this, attr, conf, err)) return;
+		if (~conf.in.indexOf(this[attr])) err();
+	}
+	/*!
+	* Format validator
+	*/
+	function validateFormat(attr, conf, err, _options) {
+		if (nullCheck.call(this, attr, conf, err)) return;
+		if (typeof this[attr] === "string" || typeof this[attr] === "number") {
+			if (!new RegExp(conf["with"]).test(this[attr])) err();
+		} else err();
+	}
+	/*!
+	* Custom validator
+	*/
+	function validateCustom(attr, conf, err, options, done) {
+		if (typeof options === "function") {
+			done = options;
+			options = {};
+		}
+		if (!done) conf.customValidator.call(this, err, options);
+		else if (conf.customValidator.length === 3) conf.customValidator.call(this, err, options, done);
+		else conf.customValidator.call(this, err, done);
+	}
+	function escapeStringRegexp(str) {
+		if (typeof str !== "string") throw new TypeError("Expected a string");
+		return str.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+	}
+	/*!
+	* Uniqueness validator
+	*/
+	function validateUniqueness(attr, conf, err, options, done) {
+		if (typeof options === "function") {
+			done = options;
+			options = {};
+		}
+		if (blank(this[attr])) return process.nextTick(done);
+		const cond = { where: {} };
+		if (conf && conf.ignoreCase) cond.where[attr] = new RegExp("^" + escapeStringRegexp(this[attr]) + "$", "i");
+		else cond.where[attr] = this[attr];
+		if (conf && conf.scopedTo) conf.scopedTo.forEach(function(k) {
+			if (this[k] !== void 0) cond.where[k] = this[k];
+		}, this);
+		const idName = this.constructor.definition.idName();
+		const isNewRecord = this.isNewRecord();
+		this.constructor.find(cond, options, function(error, found) {
+			if (error) err(error);
+			else if (found.length > 1) err();
+			else if (found.length === 1 && idName === attr && isNewRecord) err();
+			else if (found.length === 1 && (!this.id || !found[0].id || found[0].id.toString() != this.id.toString())) err();
+			done();
+		}.bind(this));
+	}
+	/*!
+	* Date validator
+	*/
+	function validateDate(attr, conf, err) {
+		if (this[attr] === null || this[attr] === void 0) return;
+		const date = new Date(this[attr]);
+		if (isNaN(date.getTime())) return err();
+	}
+	const validators = {
+		presence: validatePresence,
+		absence: validateAbsence,
+		length: validateLength,
+		numericality: validateNumericality,
+		inclusion: validateInclusion,
+		exclusion: validateExclusion,
+		format: validateFormat,
+		custom: validateCustom,
+		uniqueness: validateUniqueness,
+		date: validateDate
+	};
+	function getConfigurator(name, opts) {
+		return function() {
+			const args = Array.prototype.slice.call(arguments);
+			args[1] = args[1] || {};
+			configure(this, name, args, opts);
+		};
+	}
+	/**
+	* This method performs validation and triggers validation hooks.
+	* Before validation the `obj.errors` collection is cleaned.
+	* Each validation can add errors to `obj.errors` collection.
+	* If collection is not blank, validation failed.
+	*
+	* NOTE: This method can be called as synchronous only when no asynchronous validation is
+	* configured. It's strongly recommended to run all validations as asyncronous.
+	*
+	* Example: ExpressJS controller - render user if valid, show flash otherwise
+	* ```javascript
+	* user.isValid(function (valid) {
+	*     if (valid) res.render({user: user});
+	*     else res.flash('error', 'User is not valid'), console.log(user.errors), res.redirect('/users');
+	* });
+	* ```
+	* Another example:
+	* ```javascript
+	* user.isValid(function (valid) {
+	*     if (!valid) {
+	*           console.log(user.errors);
+	*         // => hash of errors
+	*         // => {
+	*         // => username: [errmessage, errmessage, ...],
+	*         // => email: ...
+	*         // => }
+	*     }
+	* });
+	* ```
+	* @callback {Function} callback Called with (valid).
+	* @param {Object} data Data to be validated.
+	* @param {Object} options Options to be specified upon validation.
+	* @returns {Boolean} True if no asynchronous validation is configured and all properties pass validation.
+	*/
+	Validatable.prototype.isValid = function(callback, data, options) {
+		options = options || {};
+		let valid = true, wait = 0, async = false;
+		const inst = this;
+		const validations = this.constructor.validations;
+		const reportDiscardedProperties = this.__strict && this.__unknownProperties && this.__unknownProperties.length;
+		if (typeof validations !== "object" && !reportDiscardedProperties) {
+			cleanErrors(this);
+			if (callback) this.trigger("validate", function(validationsDone) {
+				validationsDone.call(inst, function() {
+					callback(valid);
+				});
+			}, data, callback);
+			return valid;
+		}
+		Object.defineProperty(this, "errors", {
+			enumerable: false,
+			configurable: true,
+			value: new Errors()
+		});
+		this.trigger("validate", function(validationsDone) {
+			const inst = this;
+			let asyncFail = false;
+			Object.keys(validations || {}).forEach(function(attr) {
+				(validations[attr] || []).forEach(function(v) {
+					if (v.options && v.options.async) {
+						async = true;
+						wait += 1;
+						process.nextTick(function() {
+							validationFailed(inst, attr, v, options, done);
+						});
+					} else if (validationFailed(inst, attr, v, options)) valid = false;
+				});
+			});
+			if (reportDiscardedProperties) for (const ix in inst.__unknownProperties) {
+				const key = inst.__unknownProperties[ix];
+				const code = "unknown-property";
+				const msg = defaultMessages[code];
+				inst.errors.add(key, msg, code);
+				valid = false;
+			}
+			if (!async) validationsDone.call(inst, function() {
+				if (valid) cleanErrors(inst);
+				if (callback) callback(valid);
+			});
+			function done(fail) {
+				asyncFail = asyncFail || fail;
+				if (--wait === 0) validationsDone.call(inst, function() {
+					if (valid && !asyncFail) cleanErrors(inst);
+					if (callback) callback(valid && !asyncFail);
+				});
+			}
+		}, data, callback);
+		if (async) return;
+		else return valid;
+	};
+	function cleanErrors(inst) {
+		Object.defineProperty(inst, "errors", {
+			enumerable: false,
+			configurable: true,
+			value: false
+		});
+	}
+	function validationFailed(inst, attr, conf, options, cb) {
+		conf.options;
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		if (typeof attr !== "string") return false;
+		if (skipValidation(inst, conf, "if") || skipValidation(inst, conf, "unless")) {
+			if (cb) cb(false);
+			return false;
+		}
+		let fail = false;
+		const validator = validators[conf.validation];
+		const validatorArguments = [];
+		validatorArguments.push(attr);
+		validatorArguments.push(conf);
+		validatorArguments.push(function onerror(kind) {
+			let message, code = conf.code || conf.validation;
+			if (conf.message) message = conf.message;
+			if (!message && defaultMessages[conf.validation]) message = defaultMessages[conf.validation];
+			if (!message) message = "is invalid";
+			if (kind) {
+				code += "." + kind;
+				if (message[kind]) message = message[kind];
+				else if (defaultMessages.common[kind]) message = defaultMessages.common[kind];
+				else message = "is invalid";
+			}
+			if (kind !== false) inst.errors.add(attr, message, code);
+			fail = true;
+		});
+		validatorArguments.push(options);
+		if (cb) validatorArguments.push(function() {
+			cb(fail);
+		});
+		validator.apply(inst, validatorArguments);
+		return fail;
+	}
+	function skipValidation(inst, conf, kind) {
+		let doValidate = true;
+		if (typeof conf[kind] === "function") {
+			doValidate = conf[kind].call(inst);
+			if (kind === "unless") doValidate = !doValidate;
+		} else if (typeof conf[kind] === "string") if (typeof inst[conf[kind]] === "function") {
+			doValidate = inst[conf[kind]].call(inst);
+			if (kind === "unless") doValidate = !doValidate;
+		} else if (inst.__data.hasOwnProperty(conf[kind])) {
+			doValidate = inst[conf[kind]];
+			if (kind === "unless") doValidate = !doValidate;
+		} else doValidate = kind === "if";
+		return !doValidate;
+	}
+	const defaultMessages = {
+		presence: "can't be blank",
+		absence: "can't be set",
+		"unknown-property": "is not defined in the model",
+		length: {
+			min: "too short",
+			max: "too long",
+			is: "length is wrong"
+		},
+		common: {
+			blank: "is blank",
+			null: "is null"
+		},
+		numericality: {
+			int: "is not an integer",
+			number: "is not a number"
+		},
+		inclusion: "is not included in the list",
+		exclusion: "is reserved",
+		uniqueness: "is not unique",
+		date: "is not a valid date"
+	};
+	/**
+	* Checks if attribute is undefined or null. Calls err function with 'blank' or 'null'.
+	* See defaultMessages. You can affect this behaviour with conf.allowBlank and conf.allowNull.
+	* @private
+	* @param {String} attr Property name of attribute
+	* @param {Object} conf conf object for validator
+	* @param {Function} err
+	* @return {Boolean} returns true if attribute is null or blank
+	*/
+	function nullCheck(attr, conf, err) {
+		if (typeof this[attr] === "undefined" || this[attr] === "") {
+			if (!conf.allowBlank) err("blank");
+			return true;
+		} else if (this[attr] === null) {
+			if (!conf.allowNull) err("null");
+			return true;
+		}
+		return false;
+	}
+	/*!
+	* Return true when v is undefined, blank array, null or empty string
+	* otherwise returns false
+	*
+	* @param {Mix} v
+	* Returns true if `v` is blank.
+	*/
+	function blank(v) {
+		if (typeof v === "undefined") return true;
+		if (v instanceof Array && v.length === 0) return true;
+		if (v === null) return true;
+		if (typeof v === "number" && isNaN(v)) return true;
+		if (typeof v == "string" && v === "") return true;
+		return false;
+	}
+	function configure(cls, validation, args, opts) {
+		if (!cls.validations) Object.defineProperty(cls, "validations", {
+			writable: true,
+			configurable: true,
+			enumerable: false,
+			value: {}
+		});
+		args = [].slice.call(args);
+		let conf;
+		if (typeof args[args.length - 1] === "object") conf = args.pop();
+		else conf = {};
+		if (validation === "custom" && typeof args[args.length - 1] === "function") conf.customValidator = args.pop();
+		conf.validation = validation;
+		args.forEach(function(attr) {
+			if (typeof attr === "string") {
+				const validation = Object.assign({}, conf);
+				validation.options = opts || {};
+				cls.validations[attr] = cls.validations[attr] || [];
+				cls.validations[attr].push(validation);
+			}
+		});
+	}
+	function Errors() {
+		Object.defineProperty(this, "codes", {
+			enumerable: false,
+			configurable: true,
+			value: {}
+		});
+	}
+	Errors.prototype.add = function(field, message, code) {
+		code = code || "invalid";
+		if (!this[field]) {
+			this[field] = [];
+			this.codes[field] = [];
+		}
+		this[field].push(message);
+		this.codes[field].push(code);
+	};
+	/**
+	* ValidationError is raised when the application attempts to save an invalid model instance.
+	* Example:
+	* ```
+	* {
+	*   "name": "ValidationError",
+	*   "status": 422,
+	*   "message": "The Model instance is not valid. \
+	*  See `details` property of the error object for more info.",
+	*   "statusCode": 422,
+	*   "details": {
+	*     "context": "user",
+	*    "codes": {
+	*      "password": [
+	*         "presence"
+	*       ],
+	*       "email": [
+	*         "uniqueness"
+	*       ]
+	*    },
+	*     "messages": {
+	*       "password": [
+	*        "can't be blank"
+	*      ],
+	*       "email": [
+	*         "Email already exists"
+	*       ]
+	*     }
+	*   },
+	* }
+	* ```
+	* You might run into situations where you need to raise a validation error yourself, for example in a "before" hook or a
+	* custom model method.
+	* ```
+	* MyModel.prototype.preflight = function(changes, callback) {
+	*   // Update properties, do not save to db
+	*   for (var key in changes) {
+	*     model[key] = changes[key];
+	*   }
+	*
+	*   if (model.isValid()) {
+	*     return callback(null, { success: true });
+	*   }
+	*
+	*   // This line shows how to create a ValidationError
+	*   var err = new MyModel.ValidationError(model);
+	*   callback(err);
+	* }
+	* ```
+	*
+	* @private
+	*/
+	function ValidationError(obj) {
+		if (!(this instanceof ValidationError)) return new ValidationError(obj);
+		this.name = "ValidationError";
+		const context = obj && obj.constructor && obj.constructor.modelName;
+		this.message = g.f("The %s instance is not valid. Details: %s.", context ? "`" + context + "`" : "model", formatErrors(obj.errors, obj.toJSON()) || "(unknown)");
+		this.statusCode = 422;
+		this.details = {
+			context,
+			codes: obj.errors && obj.errors.codes,
+			messages: obj.errors
+		};
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+		else if (errorHasStackProperty) this.stack = (/* @__PURE__ */ new Error()).stack;
+	}
+	util.inherits(ValidationError, Error);
+	const errorHasStackProperty = !!(/* @__PURE__ */ new Error()).stack;
+	ValidationError.maxPropertyStringLength = 32;
+	function formatErrors(errors, propertyValues) {
+		const DELIM = "; ";
+		errors = errors || {};
+		return Object.getOwnPropertyNames(errors).filter(function(propertyName) {
+			return Array.isArray(errors[propertyName]);
+		}).map(function(propertyName) {
+			const messages = errors[propertyName];
+			const propertyValue = propertyValues[propertyName];
+			return messages.map(function(msg) {
+				return formatPropertyError(propertyName, propertyValue, msg);
+			}).join(DELIM);
+		}).join(DELIM);
+	}
+	function formatPropertyError(propertyName, propertyValue, errorMessage) {
+		let formattedValue;
+		const valueType = typeof propertyValue;
+		if (valueType === "string") formattedValue = JSON.stringify(truncatePropertyString(propertyValue));
+		else if (propertyValue instanceof Date) formattedValue = isNaN(propertyValue.getTime()) ? propertyValue.toString() : propertyValue.toISOString();
+		else if (valueType === "object") {
+			formattedValue = util.inspect(propertyValue, {
+				showHidden: false,
+				color: false,
+				depth: Array.isArray(propertyValue) ? 1 : 0
+			});
+			formattedValue = truncatePropertyString(formattedValue);
+		} else formattedValue = truncatePropertyString("" + propertyValue);
+		return "`" + propertyName + "` " + errorMessage + " (value: " + formattedValue + ")";
+	}
+	function truncatePropertyString(value) {
+		let len = ValidationError.maxPropertyStringLength;
+		if (value.length <= len) return value;
+		let tail;
+		const m = value.match(/([ \t})\]]+)$/);
+		if (m) {
+			tail = m[1].slice(-3);
+			len -= tail.length;
+		} else {
+			tail = value.slice(-3);
+			len -= 3;
+		}
+		return value.slice(0, len - 4) + "..." + tail;
+	}
+}));
+//#endregion
+module.exports = require_validations();