nope-validator/lib/cjs/NopeObject.js

Fast and simple JS validator

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var utils = require('./utils.js');

var NopeObject = /** @class */ (function () {
    function NopeObject(objectShape) {
        this.validationRules = [];
        this._type = 'object';
        this.objectShape = objectShape || {};
    }
    NopeObject.prototype.getType = function () {
        return this._type;
    };
    NopeObject.prototype.shape = function (shape) {
        Object.assign(this.objectShape, shape);
        return this;
    };
    NopeObject.prototype.extend = function (Base) {
        Object.assign(this.objectShape, Base.objectShape);
        return this;
    };
    NopeObject.prototype.noUnknown = function (message) {
        var _this = this;
        if (message === void 0) { message = 'Input contains invalid keys'; }
        var rule = function (entry) {
            var objectIsDefined = false;
            // eslint-disable-next-line @typescript-eslint/no-unused-vars
            for (var _ in _this.objectShape) {
                objectIsDefined = true;
                break;
            }
            if (!objectIsDefined) {
                throw Error('noUnknown must be used with a schema');
            }
            var unknownKeys = false;
            for (var key in entry) {
                unknownKeys = unknownKeys || !(key in _this.objectShape);
            }
            if (unknownKeys) {
                return message;
            }
        };
        this.validationRules.push(rule);
        return this;
    };
    NopeObject.prototype.validate = function (entry, context, options) {
        for (var _i = 0, _a = this.validationRules; _i < _a.length; _i++) {
            var rule = _a[_i];
            var localErrors = rule(entry);
            if (localErrors) {
                return localErrors;
            }
        }
        var areErrors = false;
        var abortEarly = options === null || options === void 0 ? void 0 : options.abortEarly;
        var errors = {};
        var ctx = Object.assign({ ___parent: context }, entry);
        for (var key in this.objectShape) {
            var validator = this.objectShape[key];
            var error = validator.validate(entry[key], ctx, options);
            if (error) {
                areErrors = true;
                errors[key] = error;
                if (abortEarly) {
                    return errors;
                }
            }
        }
        if (areErrors) {
            return errors;
        }
        return undefined;
    };
    NopeObject.prototype.validateAsync = function (entry, context, options) {
        var _this = this;
        return utils.runValidators(this.validationRules, entry, context).then(function (localError) {
            if (localError) {
                return localError;
            }
            var keys = [];
            var results = [];
            var ctx = Object.assign({ ___parent: context }, entry);
            for (var key in _this.objectShape) {
                var validator = _this.objectShape[key];
                var error = validator.validateAsync(entry[key], ctx, options);
                keys.push(key);
                results.push(error);
            }
            return Promise.all(results).then(function (resolvedErrors) {
                var errors = {};
                var areErrors = false;
                for (var i = 0; i < keys.length; i++) {
                    var error = resolvedErrors[i];
                    if (error) {
                        areErrors = true;
                        errors[keys[i]] = error;
                    }
                }
                if (areErrors) {
                    return errors;
                }
                return undefined;
            });
        });
    };
    NopeObject.prototype.validateAt = function (path, entry) {
        var _a, _b;
        var arrayPath = utils.pathToArray(path);
        var validator = this.objectShape;
        for (var _i = 0, arrayPath_1 = arrayPath; _i < arrayPath_1.length; _i++) {
            var p = arrayPath_1[_i];
            if (!isNaN(parseInt(p, 10))) {
                continue;
            }
            if ((_a = validator[p]) === null || _a === void 0 ? void 0 : _a.objectShape) {
                validator = validator[p].objectShape;
            }
            else if ((_b = validator[p]) === null || _b === void 0 ? void 0 : _b.ofShape) {
                validator = validator[p].ofShape.objectShape || validator[p].ofShape;
            }
            else {
                validator = validator[p];
            }
        }
        var parentValue = utils.getFromPath(path, entry, true);
        var value = utils.getFromPath(path, entry);
        return validator.validate(value, parentValue);
    };
    return NopeObject;
}());

exports.NopeObject = NopeObject;
//# sourceMappingURL=NopeObject.js.map