valgen 3.2.0 → 4.0.0-alpha.2

package/cjs/rules/is-number.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumber = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Validates if value is "number".
+ * Converts input value to number if coerce option is set to 'true'.
+ * @validator isNumber
+ */
+function isNumber(options) {
+    return (0, index_js_1.validator)('isNumber', function (input, context) {
+        if (input != null && typeof input !== 'number' && context.coerce) {
+            if (typeof input === 'string')
+                input = parseFloat(input);
+            if (typeof input === 'bigint') {
+                const v = Number(input);
+                if (input === BigInt(v))
+                    input = v;
+            }
+        }
+        if (typeof input === 'number' && !isNaN(input))
+            return input;
+        context.failure(`{{label}} not a valid number`);
+    }, options);
+}
+exports.isNumber = isNumber;

package/cjs/rules/is-object-id.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObjectId = void 0;
+const validator_1 = __importDefault(require("validator"));
+const index_js_1 = require("../core/index.js");
+/**
+ * Validates if value is an "ObjectId".
+ * @validator isObjectId
+ */
+function isObjectId(options) {
+    return (0, index_js_1.validator)('isObjectId', function (input, context) {
+        if (input != null &&
+            (_isObjectIdValue(input) ||
+                (typeof input === 'object' &&
+                    typeof input.toHexString === 'function' &&
+                    _isObjectIdValue(input.toHexString()))))
+            return input;
+        context.failure(`{{label}} is not a valid ObjectId`);
+    }, options);
+}
+exports.isObjectId = isObjectId;
+function _isObjectIdValue(input) {
+    return (input instanceof Uint8Array && input.length === 12) ||
+        (typeof input === 'string' && input.length === 24 && validator_1.default.isHexadecimal(input));
+}

package/cjs/rules/is-object.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Validates object according to schema
+ * Converts properties according to schema rules if coerce option is set to 'true'.
+ * @validator isObject
+ */
+function isObject(schema, options) {
+    const ctor = options?.ctor;
+    const ctorName = options?.name || ctor?.name;
+    const additionalFields = options?.additionalFields ?? false;
+    const caseInSensitive = !!options?.caseInSensitive;
+    const detectCircular = !!options?.detectCircular;
+    if (options) {
+        delete options.name;
+        delete options.ctor;
+        delete options.additionalFields;
+        delete options.caseInSensitive;
+        delete options.detectCircular;
+    }
+    const propertyRules = {};
+    const propertyOptions = {};
+    Object.keys(schema).forEach(k => {
+        const n = schema[k];
+        const key = caseInSensitive ? k.toLowerCase() : k;
+        if (Array.isArray(n)) {
+            if (!(0, index_js_1.isValidator)(n[0]))
+                throw new TypeError(`Invalid tuple definition in validation schema (${k})`);
+            propertyRules[key] = n[0];
+            propertyOptions[key] = { as: k, ...n[1] };
+        }
+        else if ((0, index_js_1.isValidator)(n)) {
+            propertyRules[key] = n;
+            propertyOptions[key] = { as: k };
+        }
+        else
+            throw new TypeError(`Invalid definition in validation schema (${k})`);
+    });
+    const schemaKeys = Object.keys(propertyRules);
+    const _rule = (0, index_js_1.validator)('isObject', function (input, context) {
+        if (!(input && typeof input === 'object')) {
+            context.failure(`{{label}} must be an object`);
+            return;
+        }
+        const keyMap = [...Object.keys(input), ...schemaKeys]
+            .reduce((a, k) => {
+            if (caseInSensitive)
+                a[k.toLowerCase()] = k;
+            else
+                a[k] = k;
+            return a;
+        }, {});
+        const keys = Object.keys(keyMap);
+        const l = keys.length;
+        let i = 0;
+        let inputKey;
+        let schemaKey;
+        let v;
+        let _propRule;
+        const out = {};
+        if (ctor)
+            Object.setPrototypeOf(out, ctor.prototype);
+        if (detectCircular) {
+            context.circMap = context.circMap || new Map();
+            if (context.circMap.has(input))
+                return context.circMap.get(input);
+            context.circMap.set(input, out);
+        }
+        const rootName = context.root?.input.context;
+        const location = context.input.location || '';
+        // Iterate object keys and perform rules
+        for (i = 0; i < l; i++) {
+            inputKey = keys[i];
+            schemaKey = keyMap[inputKey];
+            v = input[inputKey];
+            _propRule = propertyRules[schemaKey] ||
+                ((0, index_js_1.isValidator)(additionalFields) ? additionalFields : undefined);
+            if (_propRule) {
+                const subCtx = context.extend(_propRule);
+                if (ctorName) {
+                    if (rootName && rootName !== ctorName)
+                        subCtx.input.root = rootName;
+                    subCtx.input.context = ctorName;
+                }
+                subCtx.input.value = v;
+                subCtx.input.label = propertyOptions[schemaKey]?.label || schemaKey;
+                subCtx.input.location = location + (location ? '.' : '') + schemaKey;
+                subCtx.input.property = schemaKey;
+                v = _propRule[index_js_1.kValidatorFn](v, subCtx, _propRule);
+            }
+            else if (v !== undefined && !additionalFields)
+                context.failure(`${ctorName || 'Object'} does not accept additional fields`);
+            if (v !== undefined)
+                out[propertyOptions[schemaKey]?.as || schemaKey] = v;
+        }
+        return context.errors.length ? undefined : out;
+    }, options);
+    _rule.schema = schema;
+    return _rule;
+}
+exports.isObject = isObject;

package/cjs/rules/is-record.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRecord = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Validates record object according to given "key" and "value" rules
+ * Converts properties according to rules if coerce option is set to 'true'.
+ * @validator isRecord
+ */
+function isRecord(keyRule, valueRule, options) {
+    return (0, index_js_1.validator)('isRecord', function (input, context) {
+        if (!(input && typeof input === 'object')) {
+            context.failure(`{{label}} is not an object`);
+            return;
+        }
+        const location = context.input.location || '';
+        const keyContext = context.extend(keyRule);
+        const valueContext = context.extend(valueRule);
+        const keys = Object.keys(input);
+        const l = keys.length;
+        let i;
+        let k;
+        let v;
+        const out = {};
+        for (i = 0; i < l; i++) {
+            k = keys[i];
+            v = input[k];
+            keyContext.input.value = k;
+            keyContext.input.property = '@' + k;
+            keyContext.input.location = location + (location ? '.@' : '@') + k;
+            k = keyRule[index_js_1.kValidatorFn](k, keyContext, keyRule);
+            valueContext.input.value = v;
+            valueContext.input.property = k;
+            valueContext.input.location = location + (location ? '.' : '') + k;
+            v = valueRule[index_js_1.kValidatorFn](v, valueContext, valueRule);
+            out[k] = v;
+        }
+        return context.errors.length ? undefined : out;
+    }, options);
+}
+exports.isRecord = isRecord;

package/cjs/rules/is-string.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trimStart = exports.trimEnd = exports.trim = exports.stringSplit = exports.stringReplace = exports.isString = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Validates if value is "string".
+ * Converts input value to string if coerce option is set to 'true'.
+ * @validator isString
+ */
+function isString(options) {
+    return (0, index_js_1.validator)('isString', function (input, context) {
+        if (input != null && typeof input !== 'string' && context.coerce) {
+            if (typeof input === 'object') {
+                if (typeof input.toJSON === 'function')
+                    input = input.toJSON();
+                else
+                    input = JSON.stringify(input);
+            }
+            else
+                input = String(input);
+        }
+        if (typeof input === 'string')
+            return input;
+        context.failure(`{{label}} is not a string`);
+    }, options);
+}
+exports.isString = isString;
+function stringReplace(searchValue, replacer) {
+    return (0, index_js_1.validator)('stringReplace', function (input) {
+        if (input == null)
+            return input;
+        return String(input).replace(searchValue, replacer);
+    });
+}
+exports.stringReplace = stringReplace;
+function stringSplit(splitter, limit) {
+    return (0, index_js_1.validator)('stringSplit', function (input) {
+        if (input == null)
+            return input;
+        return String(input).split(splitter, limit);
+    });
+}
+exports.stringSplit = stringSplit;
+/**
+ * Removes whitespace from both ends of a string
+ * @validator trim
+ */
+function trim() {
+    return (0, index_js_1.validator)('trim', function (input) {
+        if (input == null)
+            return input;
+        return String(input).trim();
+    });
+}
+exports.trim = trim;
+// *************************************************************
+/**
+ * Removes whitespace from the end of a string
+ * @validator trimEnd
+ */
+const trimEnd = () => trimEndRule;
+exports.trimEnd = trimEnd;
+const trimEndRule = (0, index_js_1.validator)('trimEnd', function (input) {
+    if (input == null)
+        return input;
+    return String(input).trimEnd();
+});
+// *************************************************************
+/**
+ * Removes whitespace from the beginning of a string
+ * @validator trimStart
+ */
+const trimStart = () => trimStartRule;
+exports.trimStart = trimStart;
+const trimStartRule = (0, index_js_1.validator)('trimStart', function (input) {
+    if (input == null)
+        return input;
+    return String(input).trimStart();
+});

package/cjs/rules/is-tuple.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTuple = void 0;
+const index_js_1 = require("../core/index.js");
+function isTuple(items, options) {
+    return (0, index_js_1.validator)('isTuple', function (input, context) {
+        if (input != null && context.coerce && !Array.isArray(input))
+            input = [input];
+        if (!Array.isArray(input)) {
+            context.failure(`{{label}} is not a valid tuple`);
+            return;
+        }
+        const location = context.input.location || '';
+        let itemRule;
+        let i;
+        const l = input.length;
+        const out = [];
+        const nl = items.length;
+        for (i = 0; i < l && i < nl; i++) {
+            itemRule = items[i];
+            const itemContext = context.extend(itemRule);
+            itemContext.input.value = input[i];
+            itemContext.input.label = ((context.input.label || context.input.property) || 'Item') +
+                `[${i}]`;
+            itemContext.input.property = i;
+            itemContext.input.location = location + '[' + i + ']';
+            out.push(itemRule[index_js_1.kValidatorFn](input[i], itemContext, itemRule) ?? null);
+        }
+        return context.errors.length ? undefined : out;
+    }, options);
+}
+exports.isTuple = isTuple;

package/cjs/rules/length.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lengthMax = exports.lengthMin = exports.extractLength = void 0;
+const index_js_1 = require("../core/index.js");
+const pipe_js_1 = require("./pipe.js");
+const range_js_1 = require("./range.js");
+/**
+ * Returns length of an Array, String, ArrayBuffer, Buffer or any object with the "length" property.
+ * @validator getLength
+ */
+const extractLength = () => extractLengthRule;
+exports.extractLength = extractLength;
+const extractLengthRule = (0, index_js_1.validator)('extractLength', function (input, context) {
+    if (typeof input === 'string')
+        return input.length;
+    if (Array.isArray(input))
+        return input.length;
+    if (input instanceof ArrayBuffer)
+        return input.byteLength;
+    if (input && typeof input === 'object' && typeof input.length === 'number')
+        return input.length;
+    if (input && typeof input === 'object' && typeof input.size === 'number')
+        return input.size;
+    context.failure(`Unable to extract length of {{label}}`);
+});
+/**
+ * Checks the length is at least "minValue"
+ * @validator lengthMin
+ */
+const lengthMin = (minValue) => (0, pipe_js_1.allOf)((0, pipe_js_1.pipe)((0, exports.extractLength)(), (0, range_js_1.isGte)(minValue, {
+    onFail: () => `The length of {{label}} must be at least ${minValue}`
+})));
+exports.lengthMin = lengthMin;
+/**
+ * Checks if the length is at most "maxValue"
+ * @validator charLengthMax
+ */
+const lengthMax = (maxValue) => (0, pipe_js_1.allOf)((0, pipe_js_1.pipe)((0, exports.extractLength)(), (0, range_js_1.isLte)(maxValue, {
+    onFail: () => `The length of {{label}} must be at most ${maxValue}`
+})));
+exports.lengthMax = lengthMax;

package/cjs/rules/optional.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exists = exports.required = exports.optional = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Makes sub-rule optional
+ * @validator optional
+ */
+function optional(nested, options) {
+    return (0, index_js_1.validator)('optional', function (input, context) {
+        if (input == null)
+            return input;
+        return nested[index_js_1.kValidatorFn](input, context, nested);
+    }, options);
+}
+exports.optional = optional;
+/**
+ * Makes sub-rule required
+ * @validator required
+ */
+function required(nested, options) {
+    return (0, index_js_1.validator)('required', function (input, context) {
+        if (input == null) {
+            context.failure(`{{label}} is required`);
+            return;
+        }
+        return nested[index_js_1.kValidatorFn](input, context, nested);
+    }, options);
+}
+exports.required = required;
+/**
+ * Validates if property exists
+ * @validator exists
+ */
+function exists(options) {
+    return (0, index_js_1.validator)('exists', function (input, context) {
+        if (input !== undefined ||
+            (context.input.value && context.parent &&
+                Object.getOwnPropertyDescriptor(context.input.value, context.input.property)))
+            return input;
+        context.failure(`{{label}} must exist`);
+    }, options);
+}
+exports.exists = exists;

package/cjs/rules/pipe.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allOf = exports.pipe = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ *
+ * @validator pipe
+ */
+function pipe(...rules) {
+    const l = rules.length;
+    return (0, index_js_1.validator)('pipe', function (input, context) {
+        let i;
+        let c;
+        let v = input;
+        for (i = 0; i < l; i++) {
+            c = rules[i];
+            const subContext = context.extend(c);
+            v = c[index_js_1.kValidatorFn](v, subContext, c);
+            if (context.errors.length)
+                return;
+        }
+        return v;
+    });
+}
+exports.pipe = pipe;
+/**
+ * Test given value against to all codecs and returns original input
+ * @validator allOf
+ */
+function allOf(...rules) {
+    return (0, index_js_1.validator)('allOf', function (input, context) {
+        let i;
+        let c;
+        const l = rules.length;
+        for (i = 0; i < l; i++) {
+            c = rules[i];
+            const subContext = context.extend(c);
+            c[index_js_1.kValidatorFn](input, subContext, c);
+        }
+        return input;
+    });
+}
+exports.allOf = allOf;

package/cjs/rules/range.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.range = exports.isLte = exports.isLt = exports.isGte = exports.isGt = void 0;
+const index_js_1 = require("../core/index.js");
+function isGt(minValue, options) {
+    return (0, index_js_1.validator)('isGt', function (input, context) {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input > minValue)
+            return input;
+        if (minValue instanceof Date && input instanceof Date && input > minValue)
+            return input;
+        if (typeof minValue === 'string' && typeof input === 'string' &&
+            (input > minValue ||
+                (options?.caseInsensitive && input.toLowerCase() > minValue.toLowerCase())))
+            return input;
+        context.failure(`{{label}} must be greater than ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`);
+    }, options);
+}
+exports.isGt = isGt;
+function isGte(minValue, options) {
+    return (0, index_js_1.validator)('isGte', function (input, context) {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input >= minValue)
+            return input;
+        if (minValue instanceof Date && input instanceof Date && input >= minValue)
+            return input;
+        if (typeof minValue === 'string' && typeof input === 'string' &&
+            (input >= minValue ||
+                (options?.caseInsensitive && input.toLowerCase() >= minValue.toLowerCase())))
+            return input;
+        context.failure(`{{label}} must be greater than or equal to ${(typeof minValue === 'string' ? `"${minValue}"` : minValue)}`);
+    }, options);
+}
+exports.isGte = isGte;
+function isLt(maxValue, options) {
+    return (0, index_js_1.validator)('isLt', function (input, context) {
+        if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input < maxValue)
+            return input;
+        if (maxValue instanceof Date && input instanceof Date && input < maxValue)
+            return input;
+        if (typeof maxValue === 'string' && typeof input === 'string' &&
+            (input < maxValue ||
+                (options?.caseInsensitive && input.toLowerCase() < maxValue.toLowerCase())))
+            return input;
+        context.failure(`{{label}} must be lover than ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`);
+    }, options);
+}
+exports.isLt = isLt;
+function isLte(maxValue, options) {
+    return (0, index_js_1.validator)('isLt', function (input, context) {
+        if ((typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input <= maxValue)
+            return input;
+        if (maxValue instanceof Date && input instanceof Date && input <= maxValue)
+            return input;
+        if (typeof maxValue === 'string' && typeof input === 'string' &&
+            (input <= maxValue ||
+                (options?.caseInsensitive && input.toLowerCase() <= maxValue.toLowerCase())))
+            return input;
+        context.failure(`{{label}} must be lover than or equal to ${(typeof maxValue === 'string' ? `"${maxValue}"` : maxValue)}`);
+    }, options);
+}
+exports.isLte = isLte;
+/**
+ * Checks if value is between minValue and maxValue
+ * @validator range
+ */
+function range(minValue, maxValue, options) {
+    return (0, index_js_1.validator)('range', function (input, context) {
+        if ((typeof minValue === 'number' || typeof minValue === 'bigint') &&
+            (typeof maxValue === 'number' || typeof maxValue === 'bigint') &&
+            (typeof input === 'number' || typeof input === 'bigint') &&
+            input >= minValue && input <= maxValue)
+            return input;
+        if (minValue instanceof Date && maxValue instanceof Date &&
+            input instanceof Date && input >= minValue && input <= maxValue)
+            return input;
+        if (typeof minValue === 'string' && typeof maxValue === 'string' &&
+            typeof input === 'string' && input >= minValue && input <= maxValue)
+            return input;
+        context.failure(`{{label}} must be between ${minValue} and ${maxValue}`);
+    }, options);
+}
+exports.range = range;