@korbiniankuhn/validator
Version:
Validate object schemas for js, expressjs, angular and mongoose.
311 lines • 10.7 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const utils_1 = require("../../../utils");
exports.validateObjectBeforeProperties = (value, { defaultValue, allowed, required, message, parse, empty, min, max, length, nullAsUndefined }) => {
if (utils_1.isUndefined(value) || (nullAsUndefined && utils_1.isNull(value))) {
if (utils_1.isNotUndefined(defaultValue)) {
return [false, defaultValue];
}
if (required) {
throw message.get('required', { value });
}
else {
return [false, undefined];
}
}
if (allowed && allowed.indexOf(value) !== -1) {
return [false, value];
}
if (value === null) {
throw message.get('not_null', { value });
}
if (parse && utils_1.isString(value)) {
try {
value = JSON.parse(value);
}
catch (err) {
}
}
if (!utils_1.isPlainObject(value)) {
throw message.get('wrong_type', {
expected: 'object',
actual: typeof value
});
}
const numKeys = utils_1.keys(value).length;
if (numKeys === 0 && empty === false) {
throw message.get('object_empty');
}
if (min && numKeys < min) {
throw message.get('object_min', { expected: min, actual: numKeys });
}
if (max && numKeys > max) {
throw message.get('object_max', { expected: max, actual: numKeys });
}
if (length && numKeys !== length) {
throw message.get('object_length', { expected: length, actual: numKeys });
}
return [true, value];
};
exports.validateObjectPropertiesSync = (value, object) => {
const errors = {};
for (const key in object) {
const schema = object[key];
if (!schema._required && utils_1.isUndefined(value[key])) {
continue;
}
try {
const ret = object[key].validateSync(value[key]);
if (utils_1.isNotUndefined(ret)) {
value[key] = ret;
}
}
catch (err) {
errors[key] = err;
}
}
if (utils_1.keys(errors).length > 0) {
throw errors;
}
return value;
};
exports.validateObjectPropertiesAsync = (value, object) => __awaiter(this, void 0, void 0, function* () {
const errors = {};
for (const key in object) {
try {
const ret = yield object[key].validate(value[key]);
if (utils_1.isNotUndefined(ret)) {
value[key] = ret;
}
}
catch (err) {
errors[key] = err;
}
}
if (utils_1.keys(errors).length > 0) {
throw errors;
}
return value;
});
exports.validateObjectAfterProperties = (value, { unknown, conditions, object, message }) => {
if (unknown === false) {
const errors = {};
for (const key in value) {
if (!utils_1.has(object, key)) {
errors[key] = message.get('object_unknown', { key });
}
}
if (utils_1.keys(errors).length > 0) {
throw errors;
}
}
if (conditions) {
exports.validateObjectConditions(message, value, conditions);
}
};
exports.isGreaterThan = (message, keyA, keyB, a, b) => {
if (utils_1.isNil(a) || utils_1.isNil(b) || utils_1.isPlainObject(a) || utils_1.isPlainObject(b)) {
return;
}
if (!(a > b)) {
throw message.get('condition_gt', { keyA, keyB });
}
};
exports.isGreaterOrEqualThan = (message, keyA, keyB, a, b) => {
if (utils_1.isNil(a) || utils_1.isNil(b) || utils_1.isPlainObject(a) || utils_1.isPlainObject(b)) {
return;
}
if (!(a >= b)) {
throw message.get('condition_gte', { keyA, keyB });
}
};
exports.isLessThan = (message, keyA, keyB, a, b) => {
if (utils_1.isNil(a) || utils_1.isNil(b) || utils_1.isPlainObject(a) || utils_1.isPlainObject(b)) {
return;
}
if (!(a < b)) {
throw message.get('condition_lt', { keyA, keyB });
}
};
exports.isLessOrEqualThan = (message, keyA, keyB, a, b) => {
if (utils_1.isNil(a) || utils_1.isNil(b) || utils_1.isPlainObject(a) || utils_1.isPlainObject(b)) {
return;
}
if (!(a <= b)) {
throw message.get('condition_lte', { keyA, keyB });
}
};
exports.isEqualCondition = (message, keyA, keyB, a, b) => {
if (!utils_1.isEqual(a, b)) {
throw message.get('condition_equals', { keyA, keyB });
}
};
exports.isNotEqual = (message, keyA, keyB, a, b) => {
if (utils_1.isEqual(a, b)) {
throw message.get('condition_not_equals', { keyA, keyB });
}
};
exports.xor = (message, keyA, keyB, a, b) => {
if ((a !== undefined && b !== undefined) || (a === undefined && b === undefined)) {
throw message.get('condition_xor', { keyA, keyB });
}
};
exports.or = (message, keyA, keyB, a, b) => {
if (a !== undefined && b !== undefined) {
throw message.get('condition_or', { keyA, keyB });
}
};
exports.dependsOn = (message, keyA, keyB, a, b) => {
if (a !== undefined && b === undefined) {
throw message.get('condition_depends_on', { keyA, keyB });
}
};
exports.validateCondition = (message, method, keyA, keyB, a, b) => {
switch (method) {
case 'gt':
return exports.isGreaterThan(message, keyA, keyB, a, b);
case 'gte':
return exports.isGreaterOrEqualThan(message, keyA, keyB, a, b);
case 'lt':
return exports.isLessThan(message, keyA, keyB, a, b);
case 'lte':
return exports.isLessOrEqualThan(message, keyA, keyB, a, b);
case 'equals':
return exports.isEqualCondition(message, keyA, keyB, a, b);
case 'notEquals':
return exports.isNotEqual(message, keyA, keyB, a, b);
case 'xor':
return exports.xor(message, keyA, keyB, a, b);
case 'or':
return exports.or(message, keyA, keyB, a, b);
case 'dependsOn':
return exports.dependsOn(message, keyA, keyB, a, b);
}
};
exports.validateObjectConditions = (message, value, conditions) => {
const errors = {};
for (const condition of conditions) {
const keyA = condition.keyA;
const keyB = condition.keyB;
const a = utils_1.get(value, keyA);
const b = utils_1.get(value, keyB);
try {
exports.validateCondition(message, condition.method, keyA, keyB, a, b);
}
catch (err) {
if (keyA in errors) {
errors[keyA] = `${errors[keyA]} ${err}`;
}
else {
errors[keyA] = err;
}
}
}
if (utils_1.keys(errors).length > 0) {
throw errors;
}
};
exports.validateObjectFunctionSync = (value, func) => {
if (func) {
const errors = {};
const fn = func.fn;
const values = [];
for (const key of func.keys) {
values.push(utils_1.get(value, key, null));
}
try {
fn(...values);
}
catch (err) {
errors[`[${func.keys.join(', ')}]`] = utils_1.getErrorMessage(err);
}
if (utils_1.keys(errors).length > 0) {
throw errors;
}
}
return value;
};
exports.validateObjectFunctionAsync = (value, func) => __awaiter(this, void 0, void 0, function* () {
if (func) {
const errors = {};
const fn = func.fn;
const values = [];
for (const key of func.keys) {
values.push(utils_1.get(value, key, null));
}
try {
if (utils_1.isAsyncFunction(fn)) {
yield fn(...values);
}
else {
fn(...values);
}
}
catch (err) {
errors[`[${func.keys.join(', ')}]`] = utils_1.getErrorMessage(err);
}
if (utils_1.keys(errors).length > 0) {
throw errors;
}
}
return value;
});
exports.validateObjectSync = (value, { defaultValue, allowed, required, message, parse, empty, min, max, length, object, func, unknown, conditions, nullAsUndefined }) => {
let [continueValidation, checkedValue] = exports.validateObjectBeforeProperties(value, {
defaultValue,
allowed,
required,
message,
parse,
empty,
min,
max,
length,
nullAsUndefined
});
if (continueValidation) {
checkedValue = exports.validateObjectPropertiesSync(checkedValue, object);
exports.validateObjectAfterProperties(checkedValue, {
unknown,
conditions,
message,
object
});
exports.validateObjectFunctionSync(checkedValue, func);
}
return checkedValue;
};
exports.validateObjectAsync = (value, { defaultValue, allowed, required, message, parse, empty, min, max, length, object, func, unknown, conditions, nullAsUndefined }) => __awaiter(this, void 0, void 0, function* () {
let [continueValidation, checkedValue] = exports.validateObjectBeforeProperties(value, {
defaultValue,
allowed,
required,
message,
parse,
empty,
min,
max,
length,
nullAsUndefined
});
if (continueValidation) {
checkedValue = yield exports.validateObjectPropertiesAsync(checkedValue, object);
exports.validateObjectAfterProperties(checkedValue, {
unknown,
conditions,
message,
object
});
yield exports.validateObjectFunctionAsync(checkedValue, func);
}
return checkedValue;
});
//# sourceMappingURL=object.js.map