valgen 3.2.0 → 4.0.0-alpha.2

package/esm/rules/is-empty.js

@@ -0,0 +1,63 @@
+import { validator } from '../core/index.js';
+/**
+ * Checks if value is an empty. Value should be string, array, set, map or object
+ * @validator isEmpty
+ */
+export function isEmpty(options) {
+    return validator('isEmpty', function (input, context) {
+        if (input != null) {
+            if (typeof input === 'string') {
+                if (!input)
+                    return input;
+            }
+            else if (Array.isArray(input)) {
+                if (!input.length)
+                    return input;
+            }
+            else if (input instanceof Set) {
+                if (!input.size)
+                    return input;
+            }
+            else if (input instanceof Map) {
+                if (!input.size)
+                    return input;
+            }
+            else if (typeof input === 'object') {
+                if (!Object.keys(input).length)
+                    return input;
+            }
+        }
+        context.failure(`{{label}} is not empty`);
+    }, options);
+}
+/**
+ * Checks if value is a not empty. Value should be string, array, set, map or object
+ * @validator isNotEmpty
+ */
+export function isNotEmpty(options) {
+    return validator('isNotEmpty', function (input, context) {
+        if (input != null) {
+            if (typeof input === 'string') {
+                if (input)
+                    return input;
+            }
+            else if (Array.isArray(input)) {
+                if (input.length)
+                    return input;
+            }
+            else if (input instanceof Set) {
+                if (input.size)
+                    return input;
+            }
+            else if (input instanceof Map) {
+                if (input.size)
+                    return input;
+            }
+            else if (typeof input === 'object') {
+                if (Object.keys(input).length)
+                    return input;
+            }
+        }
+        context.failure(`{{label}} is empty`);
+    }, options);
+}

package/esm/rules/is-enum.js

@@ -0,0 +1,26 @@
+import { validator } from '../core/index.js';
+/**
+ * Validates if given value is one of enum values.
+ * @validator isEnum
+ */
+export function isEnum(values, options) {
+    const caseInSensitive = !!(options?.caseInSensitive);
+    const enumName = options?.enumName;
+    // Prepare an object for fast lookup
+    const valObj = (Array.isArray(values) ? values : [values])
+        .reduce((a, v) => {
+        if (typeof v === 'string' && caseInSensitive)
+            a[v.toUpperCase()] = true;
+        else
+            a[v] = true;
+        return a;
+    }, {});
+    return validator('isEnum', function (input, context) {
+        if (input != null && valObj[typeof input === 'string' && caseInSensitive ? input.toUpperCase() : input])
+            return input;
+        context.failure({
+            message: `Value must be one of enumeration member${enumName ? ` (${enumName})` : ''}`,
+            enum: enumName
+        });
+    }, options);
+}

package/esm/rules/is-integer.js

@@ -0,0 +1,22 @@
+import { validator } from '../core/index.js';
+/**
+ * Validates if value is "integer".
+ * Converts input value to integer number if coerce option is set to 'true'.
+ * @validator isInteger
+ */
+export function isInteger(options) {
+    return validator('isInteger', 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) && Number.isInteger(input))
+            return input;
+        context.failure(`{{label}} is not a valid integer number`);
+    }, options);
+}

package/esm/rules/is-matches.js

@@ -0,0 +1,20 @@
+import { validator } from '../core/index.js';
+/**
+ * Coerces given value to "UUID" format or returns undefined if nullish
+ * @validator uuid
+ */
+export function isMatches(format, options) {
+    const regExp = format instanceof RegExp ? format : new RegExp(format);
+    const formatName = options?.formatName;
+    return validator('matches', function (input, context) {
+        if (input == null)
+            return;
+        if (typeof input === 'string' && regExp.test(input))
+            return input;
+        context.failure({
+            message: `{{label}} does not match ${formatName || 'requested'} format`,
+            format,
+            formatName
+        });
+    }, options);
+}

package/esm/rules/is-null.js

@@ -0,0 +1,34 @@
+import { validator } from '../core/index.js';
+/**
+ * Validates if value is "null".
+ * @validator isNull
+ */
+export function isNull(options) {
+    return validator('isNull', function (input, context) {
+        if (input === null)
+            return input;
+        context.failure(`{{label}} is not null`);
+    }, options);
+}
+/**
+ * Validates if value is not "undefined" nor "null"
+ * @validator isDefined
+ */
+export function isDefined(options) {
+    return validator('is-defined', function (input, context) {
+        if (input !== undefined)
+            return input;
+        context.failure(`{{label}} is not defined`);
+    }, options);
+}
+/**
+ * Validates if value is "undefined"
+ * @validator isNotDefined
+ */
+export function isUndefined(options) {
+    return validator('isUndefined', function (input, context) {
+        if (input === undefined)
+            return;
+        context.failure(`{{label}} defined`);
+    }, options);
+}

package/esm/rules/is-number.js

@@ -0,0 +1,22 @@
+import { validator } from '../core/index.js';
+/**
+ * Validates if value is "number".
+ * Converts input value to number if coerce option is set to 'true'.
+ * @validator isNumber
+ */
+export function isNumber(options) {
+    return 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);
+}

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

@@ -0,0 +1,21 @@
+import validatorJS from 'validator';
+import { validator } from '../core/index.js';
+/**
+ * Validates if value is an "ObjectId".
+ * @validator isObjectId
+ */
+export function isObjectId(options) {
+    return 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);
+}
+function _isObjectIdValue(input) {
+    return (input instanceof Uint8Array && input.length === 12) ||
+        (typeof input === 'string' && input.length === 24 && validatorJS.isHexadecimal(input));
+}

package/esm/rules/is-object.js

@@ -0,0 +1,99 @@
+import { isValidator, kValidatorFn, validator } from '../core/index.js';
+/**
+ * Validates object according to schema
+ * Converts properties according to schema rules if coerce option is set to 'true'.
+ * @validator isObject
+ */
+export 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 (!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 (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 = 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] ||
+                (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[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;
+}

package/esm/rules/is-record.js

@@ -0,0 +1,37 @@
+import { kValidatorFn, validator, } from '../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
+ */
+export function isRecord(keyRule, valueRule, options) {
+    return 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[kValidatorFn](k, keyContext, keyRule);
+            valueContext.input.value = v;
+            valueContext.input.property = k;
+            valueContext.input.location = location + (location ? '.' : '') + k;
+            v = valueRule[kValidatorFn](v, valueContext, valueRule);
+            out[k] = v;
+        }
+        return context.errors.length ? undefined : out;
+    }, options);
+}

package/esm/rules/is-string.js

@@ -0,0 +1,70 @@
+import { validator } from '../core/index.js';
+/**
+ * Validates if value is "string".
+ * Converts input value to string if coerce option is set to 'true'.
+ * @validator isString
+ */
+export function isString(options) {
+    return 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);
+}
+export function stringReplace(searchValue, replacer) {
+    return validator('stringReplace', function (input) {
+        if (input == null)
+            return input;
+        return String(input).replace(searchValue, replacer);
+    });
+}
+export function stringSplit(splitter, limit) {
+    return validator('stringSplit', function (input) {
+        if (input == null)
+            return input;
+        return String(input).split(splitter, limit);
+    });
+}
+/**
+ * Removes whitespace from both ends of a string
+ * @validator trim
+ */
+export function trim() {
+    return validator('trim', function (input) {
+        if (input == null)
+            return input;
+        return String(input).trim();
+    });
+}
+// *************************************************************
+/**
+ * Removes whitespace from the end of a string
+ * @validator trimEnd
+ */
+export const trimEnd = () => trimEndRule;
+const trimEndRule = validator('trimEnd', function (input) {
+    if (input == null)
+        return input;
+    return String(input).trimEnd();
+});
+// *************************************************************
+/**
+ * Removes whitespace from the beginning of a string
+ * @validator trimStart
+ */
+export const trimStart = () => trimStartRule;
+const trimStartRule = validator('trimStart', function (input) {
+    if (input == null)
+        return input;
+    return String(input).trimStart();
+});

package/esm/rules/is-tuple.js

@@ -0,0 +1,28 @@
+import { kValidatorFn, validator } from '../core/index.js';
+export function isTuple(items, options) {
+    return 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[kValidatorFn](input[i], itemContext, itemRule) ?? null);
+        }
+        return context.errors.length ? undefined : out;
+    }, options);
+}

package/esm/rules/length.js

@@ -0,0 +1,35 @@
+import { validator } from '../core/index.js';
+import { allOf, pipe } from './pipe.js';
+import { isGte, isLte } from './range.js';
+/**
+ * Returns length of an Array, String, ArrayBuffer, Buffer or any object with the "length" property.
+ * @validator getLength
+ */
+export const extractLength = () => extractLengthRule;
+const extractLengthRule = 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
+ */
+export const lengthMin = (minValue) => allOf(pipe(extractLength(), isGte(minValue, {
+    onFail: () => `The length of {{label}} must be at least ${minValue}`
+})));
+/**
+ * Checks if the length is at most "maxValue"
+ * @validator charLengthMax
+ */
+export const lengthMax = (maxValue) => allOf(pipe(extractLength(), isLte(maxValue, {
+    onFail: () => `The length of {{label}} must be at most ${maxValue}`
+})));

package/esm/rules/optional.js

@@ -0,0 +1,38 @@
+import { kValidatorFn, validator } from '../core/index.js';
+/**
+ * Makes sub-rule optional
+ * @validator optional
+ */
+export function optional(nested, options) {
+    return validator('optional', function (input, context) {
+        if (input == null)
+            return input;
+        return nested[kValidatorFn](input, context, nested);
+    }, options);
+}
+/**
+ * Makes sub-rule required
+ * @validator required
+ */
+export function required(nested, options) {
+    return validator('required', function (input, context) {
+        if (input == null) {
+            context.failure(`{{label}} is required`);
+            return;
+        }
+        return nested[kValidatorFn](input, context, nested);
+    }, options);
+}
+/**
+ * Validates if property exists
+ * @validator exists
+ */
+export function exists(options) {
+    return 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);
+}

package/esm/rules/pipe.js

@@ -0,0 +1,38 @@
+import { kValidatorFn, validator } from '../core/index.js';
+/**
+ *
+ * @validator pipe
+ */
+export function pipe(...rules) {
+    const l = rules.length;
+    return 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[kValidatorFn](v, subContext, c);
+            if (context.errors.length)
+                return;
+        }
+        return v;
+    });
+}
+/**
+ * Test given value against to all codecs and returns original input
+ * @validator allOf
+ */
+export function allOf(...rules) {
+    return 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[kValidatorFn](input, subContext, c);
+        }
+        return input;
+    });
+}

package/esm/rules/range.js

@@ -0,0 +1,81 @@
+import { validator } from '../core/index.js';
+export function isGt(minValue, options) {
+    return 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);
+}
+export function isGte(minValue, options) {
+    return 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);
+}
+export function isLt(maxValue, options) {
+    return 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);
+}
+export function isLte(maxValue, options) {
+    return 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);
+}
+/**
+ * Checks if value is between minValue and maxValue
+ * @validator range
+ */
+export function range(minValue, maxValue, options) {
+    return 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);
+}