valgen 3.2.0 → 4.0.0-alpha.2

package/cjs/rules/string-formats.js

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUppercase = exports.isLowercase = exports.isJWT = exports.isHexColor = exports.isHash = exports.isETHAddress = exports.isBtcAddress = exports.isVAT = exports.isISSN = exports.isFQDN = exports.isEAN = exports.isPassportNumber = exports.isIBAN = exports.isCreditCard = exports.isBIC = exports.isBase64 = exports.isURL = exports.isPort = exports.isMACAddress = exports.isIPRange = exports.isIP = exports.isMobilePhone = exports.isEmail = exports.isUUID = void 0;
+const validator_1 = __importDefault(require("validator"));
+const index_js_1 = require("../core/index.js");
+/**
+ * Validates if value is an "UUID".
+ * @validator isUUID
+ */
+function isUUID(version, options) {
+    return (0, index_js_1.validator)('isUUID', function (input, context) {
+        if (input != null && typeof input === 'string' && validator_1.default.isUUID(input, version))
+            return input;
+        context.failure(`{{label}} is not a valid UUID${version ? ' v' + version : ''}`);
+    }, options);
+}
+exports.isUUID = isUUID;
+/**
+ * Validates if value is a valid Email
+ * @validator isEmail
+ */
+function isEmail(options) {
+    return (0, index_js_1.validator)('isEmail', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isEmail(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid a EMail`);
+    }, options);
+}
+exports.isEmail = isEmail;
+/**
+ * Validates if value is a valid Email
+ * @validator isMobilePhone
+ */
+function isMobilePhone(options) {
+    return (0, index_js_1.validator)('isMobilePhone', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isMobilePhone(input, options?.locale, options))
+            return input;
+        context.failure(`{{label}} is not a valid a Mobile Phone Number`);
+    }, options);
+}
+exports.isMobilePhone = isMobilePhone;
+/**
+ * Validates if value is an IP
+ * @validator isIP
+ */
+function isIP(version, options) {
+    return (0, index_js_1.validator)('isIP', function (input, context) {
+        if (input != null && typeof input === 'string' && validator_1.default.isIP(input, version))
+            return input;
+        context.failure(`{{label}} is not a valid IP${version ? ' v' + version : ''}`);
+    }, options);
+}
+exports.isIP = isIP;
+/**
+ * Validates if value is an IP
+ * @validator isUUID
+ */
+function isIPRange(version, options) {
+    return (0, index_js_1.validator)('isIPRange', function (input, context) {
+        if (input != null && typeof input === 'string' && validator_1.default.isIPRange(input, version))
+            return input;
+        context.failure(`{{label}} is not a valid IP${version ? ' v' + version : ''} range`);
+    }, options);
+}
+exports.isIPRange = isIPRange;
+/**
+ * Validates if value is an MACAddress
+ * @validator isMACAddress
+ */
+function isMACAddress(options) {
+    return (0, index_js_1.validator)('isMACAddress', function (input, context) {
+        if (input != null && typeof input === 'string' && validator_1.default.isMACAddress(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid MAC address`);
+    }, options);
+}
+exports.isMACAddress = isMACAddress;
+/**
+ * Validates if value is a port number
+ * @validator isPort
+ */
+function isPort(options) {
+    return (0, index_js_1.validator)('isPort', function (input, context) {
+        if (input != null && typeof input === 'string' && validator_1.default.isPort(input))
+            return input;
+        context.failure(`{{label}} is not a valid port number`);
+    }, options);
+}
+exports.isPort = isPort;
+/**
+ * Validates if value is an MACAddress
+ * @validator isURL
+ */
+function isURL(options) {
+    return (0, index_js_1.validator)('isURL', function (input, context) {
+        if (input != null && typeof input === 'string' && validator_1.default.isURL(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid URL`);
+    }, options);
+}
+exports.isURL = isURL;
+/**
+ * Validates if value is a "Base64" string.
+ * @validator isBase64
+ */
+function isBase64(options) {
+    return (0, index_js_1.validator)('isBase64', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isBase64(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid a Base64 string`);
+    }, options);
+}
+exports.isBase64 = isBase64;
+/**
+ * Validates if value is a BIC (Bank Identification Code) or SWIFT code
+ * @validator isBIC
+ */
+function isBIC(options) {
+    return (0, index_js_1.validator)('isBIC', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isBIC(input))
+            return input;
+        context.failure(`{{label}}is not a valid a BIC (Bank Identification Code) or SWIFT code`);
+    }, options);
+}
+exports.isBIC = isBIC;
+/**
+ * Validates if value is a "Base64" formatted string.
+ * @validator isCreditCard
+ */
+function isCreditCard(options) {
+    return (0, index_js_1.validator)('isCreditCard', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isCreditCard(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid Credit Card number`);
+    }, options);
+}
+exports.isCreditCard = isCreditCard;
+/**
+ * Validates if value is an IBAN (International Bank Account Number)
+ * @validator isEAN
+ */
+function isIBAN(options) {
+    return (0, index_js_1.validator)('isIBAN', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isIBAN(input))
+            return input;
+        context.failure(`{{label}} is not a valid IBAN (International Bank Account Number)`);
+    }, options);
+}
+exports.isIBAN = isIBAN;
+/**
+ * Validates if value is an passport number
+ * @validator isPassportNumber
+ */
+function isPassportNumber(countryCode, options) {
+    return (0, index_js_1.validator)('isPassportNumber', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isPassportNumber(input, countryCode))
+            return input;
+        context.failure(`{{label}} is not a valid ${countryCode} PassportNumber)`);
+    }, options);
+}
+exports.isPassportNumber = isPassportNumber;
+/**
+ * Validates if value is an EAN (European Article Number)
+ * @validator isEAN
+ */
+function isEAN(options) {
+    return (0, index_js_1.validator)('isEAN', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isEAN(input))
+            return input;
+        context.failure(`{{label}} is not a valid EAN (European Article Number)`);
+    }, options);
+}
+exports.isEAN = isEAN;
+/**
+ * Validates if value is an FQDN
+ * @validator isFQDN
+ */
+function isFQDN(options) {
+    return (0, index_js_1.validator)('isFQDN', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isFQDN(input, options))
+            return input;
+        context.failure(`{{label}} is not valid FQDN`);
+    }, options);
+}
+exports.isFQDN = isFQDN;
+/**
+ * Validates if value is an ISSN
+ * @validator isISSN
+ */
+function isISSN(options) {
+    return (0, index_js_1.validator)('isISSN', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isISSN(input, options))
+            return input;
+        context.failure(`{{label}} is not a valid ISSN`);
+    }, options);
+}
+exports.isISSN = isISSN;
+/**
+ * Validates if value is an VAT number
+ * @validator isVAT
+ */
+function isVAT(countryCode, options) {
+    return (0, index_js_1.validator)('isVAT', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isVAT(input, countryCode))
+            return input;
+        context.failure(`{{label}} is not a valid VAT number`);
+    }, options);
+}
+exports.isVAT = isVAT;
+/**
+ * Validates if value is a BTC address.
+ * @validator isBtcAddress
+ */
+function isBtcAddress(options) {
+    return (0, index_js_1.validator)('isBtcAddress', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isBtcAddress(input))
+            return input;
+        context.failure(`{{label}} is not a valid a BTC address`);
+    }, options);
+}
+exports.isBtcAddress = isBtcAddress;
+/**
+ * Validates if value is a ETH (Ethereum) address.
+ * @validator isBtcAddress
+ */
+function isETHAddress(options) {
+    return (0, index_js_1.validator)('isETHAddress', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isEthereumAddress(input))
+            return input;
+        context.failure(`{{label}} is not a valid a ETH (Ethereum) address`);
+    }, options);
+}
+exports.isETHAddress = isETHAddress;
+/**
+ * Validates if value a hash of type algorithm
+ * @validator isHash
+ */
+function isHash(algorithm, options) {
+    return (0, index_js_1.validator)('isHash', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isHash(input, algorithm))
+            return input;
+        context.failure(`{{label}} is not a valid ${algorithm} hash`);
+    }, options);
+}
+exports.isHash = isHash;
+/**
+ * Validates if value is a Hex Color
+ * @validator isHexColor
+ */
+function isHexColor(options) {
+    return (0, index_js_1.validator)('isHexColor', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isHexColor(input))
+            return input;
+        context.failure(`{{label}} is not a valid Hex Color`);
+    }, options);
+}
+exports.isHexColor = isHexColor;
+/**
+ * Validates if value a valid JWT token
+ * @validator isHash
+ */
+function isJWT(options) {
+    return (0, index_js_1.validator)('isJWT', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isJWT(input))
+            return input;
+        context.failure(`{{label}} is not a valid JWT token`);
+    }, options);
+}
+exports.isJWT = isJWT;
+/**
+ * Validates if value a Lowercase string
+ * @validator isLowercase
+ */
+function isLowercase(options) {
+    return (0, index_js_1.validator)('isLowercase', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isLowercase(input))
+            return input;
+        context.failure(`{{label}} is not a lowercase string`);
+    }, options);
+}
+exports.isLowercase = isLowercase;
+/**
+ * Validates if value a Uppercase string
+ * @validator isUppercase
+ */
+function isUppercase(options) {
+    return (0, index_js_1.validator)('isLowercase', function (input, context) {
+        if (typeof input === 'string' && validator_1.default.isUppercase(input))
+            return input;
+        context.failure(`{{label}} is not an uppercase string`);
+    }, options);
+}
+exports.isUppercase = isUppercase;

package/cjs/rules/union.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.union = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ *
+ */
+function union(codecs) {
+    const l = codecs.length;
+    return (0, index_js_1.validator)('union', function (input, context) {
+        let i;
+        let c;
+        let v;
+        let passed = false;
+        for (i = 0; i < l; i++) {
+            c = codecs[i];
+            try {
+                v = c(input, context);
+                passed = true;
+                break;
+            }
+            catch (e) {
+                //
+            }
+        }
+        if (passed)
+            return v;
+        context.failure(`{{location}} didn't match any of required format`);
+    });
+}
+exports.union = union;

package/cjs/rules/utilities.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iif = exports.forwardRef = void 0;
+const index_js_1 = require("../core/index.js");
+/**
+ * Forwards codec process to a sub codec. Useful for circular checks
+ * @validator forwardRef
+ */
+function forwardRef(fn) {
+    return (0, index_js_1.validator)('forwardRef', function (input, context) {
+        const nested = fn(context);
+        return nested[index_js_1.kValidatorFn](input, context, nested);
+    });
+}
+exports.forwardRef = forwardRef;
+function iif(check, _then, _else) {
+    return (0, index_js_1.validator)('iif', function (input, context) {
+        let c = _else;
+        try {
+            if (check(input) !== undefined)
+                c = _then;
+        }
+        catch {
+            // ignored
+        }
+        if ((0, index_js_1.isValidator)(c))
+            return c[index_js_1.kValidatorFn](input, context, c);
+        return c;
+    });
+}
+exports.iif = iif;

package/esm/core/constants.js

@@ -0,0 +1,2 @@
+export const kValidatorFn = Symbol.for('kValidatorFn');
+export const kOptions = Symbol.for('kOptions');

package/esm/core/context.js

@@ -0,0 +1,61 @@
+import { kOptions } from './constants.js';
+import { ValidationError } from './validation-error.js';
+const VARIABLE_REPLACE_PATTERN = /{{([^}]*)}}/g;
+const OPTIONAL_VAR_PATTERN = /^([^?]+)(?:\||(.*))?$/;
+export class Context {
+    constructor(rule, options) {
+        this.errors = [];
+        this.input = {};
+        this.rule = rule;
+        if (options?.maxErrors != null)
+            this.maxErrors = options.maxErrors;
+        if (typeof options?.onFail === 'function')
+            this.onFail = options.onFail;
+        if (options?.coerce != null)
+            this.coerce = options?.coerce;
+    }
+    failure(message) {
+        const issue = (typeof message === 'object'
+            ? { ...message, message: message.message }
+            : { message: '' + message });
+        issue.rule = this.rule.id;
+        Object.assign(issue, this.input);
+        if (this.onFail) {
+            const proto = Object.getPrototypeOf(this);
+            const x = this.onFail(issue, this, proto.onFail);
+            if (!x)
+                return;
+            if (typeof x === 'object') {
+                delete x.id;
+                delete x.input;
+                Object.assign(issue, x);
+            }
+            else
+                issue.message = String(x);
+        }
+        issue.message = ('' + issue.message).replace(VARIABLE_REPLACE_PATTERN, (x, g) => {
+            const m = OPTIONAL_VAR_PATTERN.exec(g);
+            if (!m)
+                return x;
+            const k = m[1];
+            const v = this.input[k] ??
+                (m[1] === 'label' ? this.input.property : undefined);
+            if (v != null)
+                return '`' + v + '`';
+            if (m[2])
+                return m[2];
+            return m[1] === 'label' ? 'Value' : x;
+        });
+        this.errors.push(issue);
+        if (this.errors.length >= (this.maxErrors ?? Infinity))
+            throw new ValidationError(this.errors);
+    }
+    extend(rule, options) {
+        const extended = new Context(rule, { onFail: undefined, ...rule[kOptions], ...options });
+        Object.setPrototypeOf(extended, this);
+        delete extended.errors;
+        extended.parent = this;
+        extended.root = this.root || this;
+        return extended;
+    }
+}

package/esm/core/index.js

@@ -0,0 +1,5 @@
+export * from './context.js';
+export * from './constants.js';
+export * from './types.js';
+export * from './validation-error.js';
+export * from './validator.js';

package/esm/core/types.js

@@ -0,0 +1 @@
+export {};

package/esm/core/validation-error.js

@@ -0,0 +1,7 @@
+export class ValidationError extends Error {
+    constructor(issues) {
+        super(issues[0].message);
+        this.issues = [];
+        this.issues = issues;
+    }
+}

package/esm/core/validator.js

@@ -0,0 +1,56 @@
+import { camelCase } from '../helpers/string.utils.js';
+import { kOptions, kValidatorFn } from './constants.js';
+import { Context } from './context.js';
+import { ValidationError } from './validation-error.js';
+export function validator(arg0, arg1, arg2) {
+    let id = '';
+    let fn;
+    let validatorOptions;
+    if (typeof arg0 === 'string') {
+        id = arg0;
+        fn = arg1;
+        validatorOptions = arg2;
+    }
+    else {
+        fn = arg0;
+        validatorOptions = arg1;
+    }
+    if (typeof fn !== 'function')
+        throw new TypeError('You must provide a rule function argument');
+    id = id || fn.name || 'unnamed-rule';
+    const name = fn.name || camelCase(id);
+    const _rule = ({
+        [name](input, options, parent) {
+            const ctx = parent ? parent.extend(_rule, options) : new Context(_rule, options);
+            let value;
+            try {
+                ctx.input.value = input;
+                value = fn(input, ctx, _rule);
+            }
+            catch (e) {
+                if (!parent && e instanceof ValidationError)
+                    throw e;
+                ctx.failure(e);
+            }
+            if (!parent && ctx.errors.length)
+                throw new ValidationError(ctx.errors);
+            return value;
+        }
+    })[name];
+    _rule.id = id;
+    _rule[kValidatorFn] = fn;
+    _rule[kOptions] = validatorOptions || {};
+    _rule.silent = (input, options, context) => {
+        try {
+            const value = _rule(input, options, context);
+            return { value };
+        }
+        catch (e) {
+            return { errors: e.issues };
+        }
+    };
+    return _rule;
+}
+export function isValidator(x) {
+    return !!(typeof x === 'function' && x.id && x[kValidatorFn]);
+}

package/esm/helpers/object.utils.js

@@ -0,0 +1,14 @@
+export function omitKeys(o, keys) {
+    return Object.keys(o).reduce((a, k) => {
+        if (!keys.includes(k))
+            a[k] = o[k];
+        return a;
+    }, {});
+}
+export function pickKeys(o, keys) {
+    return Object.keys(o).reduce((a, k) => {
+        if (keys.includes(k))
+            a[k] = o[k];
+        return a;
+    }, {});
+}

package/esm/helpers/string.utils.js

@@ -0,0 +1,5 @@
+export function camelCase(v) {
+    return v.replace(/[\W_\s]+([^\W_\s])/g, (arg$, c) => {
+        return c[0].toUpperCase();
+    });
+}

package/esm/index.js

@@ -0,0 +1,2 @@
+export * from './core/index.js';
+export * from './rules/index.js';

package/esm/rules/index.js

@@ -0,0 +1,22 @@
+export * from './is-any.js';
+export * from './is-array.js';
+export * from './is-boolean.js';
+export * from './is-date.js';
+export * from './is-empty.js';
+export * from './is-enum.js';
+export * from './is-integer.js';
+export * from './is-null.js';
+export * from './is-matches.js';
+export * from './is-number.js';
+export * from './is-object.js';
+export * from './is-object-id.js';
+export * from './is-record.js';
+export * from './is-string.js';
+export * from './is-tuple.js';
+export * from './length.js';
+export * from './optional.js';
+export * from './pipe.js';
+export * from './range.js';
+export * from './string-formats.js';
+export * from './union.js';
+export * from './utilities.js';

package/esm/rules/is-any.js

@@ -0,0 +1,8 @@
+import { validator } from '../core/index.js';
+/**
+ * Does nothing, just returns original input value.
+ * @validator isAny
+ */
+export const isAny = () => validator('is-any', function (input) {
+    return input;
+});

package/esm/rules/is-array.js

@@ -0,0 +1,34 @@
+import { kValidatorFn, validator, } from '../core/index.js';
+/**
+ * Validates if value is "array" and applies validation for each item.
+ * Converts input value to array if coerce option is set to 'true'.
+ * @validator isArray
+ */
+export function isArray(itemValidator, options) {
+    return validator('isArray', function (input, context) {
+        if (input != null && context.coerce && !Array.isArray(input))
+            input = [input];
+        if (!Array.isArray(input)) {
+            context.failure(`{{label}} is not an array`);
+            return;
+        }
+        if (!itemValidator)
+            return input;
+        const location = context.input.location || '';
+        const itemContext = context.extend(itemValidator);
+        let i;
+        let v;
+        const l = input.length;
+        const out = [];
+        for (i = 0; i < l; i++) {
+            v = input[i];
+            itemContext.input.value = v;
+            itemContext.input.label = ((context.input.label || context.input.property) || 'Item') +
+                `[${i}]`;
+            itemContext.input.property = i;
+            itemContext.input.location = location + '[' + i + ']';
+            out.push(itemValidator[kValidatorFn](v, itemContext, itemValidator));
+        }
+        return out;
+    }, options);
+}

package/esm/rules/is-boolean.js

@@ -0,0 +1,26 @@
+import { validator } from '../core/index.js';
+const TRUE_PATTERN = /^true|t|1|yes|y$/i;
+const FALSE_PATTERN = /^false|f|0|no|n$/i;
+/**
+ * Validates if value is "boolean".
+ * Converts input value to boolean if coerce option is set to 'true'.
+ * @validator isBoolean
+ */
+export function isBoolean(options) {
+    return validator('isBoolean', function (input, context) {
+        if (input != null && typeof input !== 'boolean' && context.coerce) {
+            if (typeof input === 'string') {
+                if (TRUE_PATTERN.test(input))
+                    return true;
+                if (FALSE_PATTERN.test(input))
+                    return false;
+                throw new TypeError(`Invalid boolean string`);
+            }
+            if (input === 1 || input === 0)
+                input = !!input;
+        }
+        if (typeof input === 'boolean')
+            return input;
+        context.failure(`{{label}} is not a valid boolean`);
+    }, options);
+}

package/esm/rules/is-date.js

@@ -0,0 +1,55 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+import { validator } from '../core/index.js';
+import { omitKeys } from '../helpers/object.utils.js';
+dayjs.extend(customParseFormat);
+/**
+ * Validates if value is instance of "Date".
+ * Converts input value to Date if coerce option is set to 'true'.
+ * @validator isDate
+ */
+export function isDate(options) {
+    return validator('isDate', function (input, context) {
+        if (input != null && !(input instanceof Date) && context.coerce) {
+            if (typeof input === 'string') {
+                const d = dayjs(input, options?.format);
+                if (d.isValid())
+                    input = d.toDate();
+            }
+            else if (typeof input === 'number')
+                input = new Date(input);
+        }
+        if (input && input instanceof Date && !isNaN(input.getTime()))
+            return input;
+        context.failure({
+            message: `{{label}} is not a valid Date instance` +
+                (context.coerce
+                    ? ` or a date formatted${options?.format ? " (" + options.format + ")" : ''} string`
+                    : ''),
+            format: options?.format
+        });
+    }, omitKeys(options || {}, ['format']));
+}
+/**
+ * Validates if value is DFS (date formatted string).
+ * Converts input value to DFS if coerce option is set to 'true'.
+ * @validator isDateString
+ */
+export function isDateString(options) {
+    return validator('isDateString', function (input, context) {
+        if (input && typeof input !== 'string' && context.coerce) {
+            const d = dayjs(input);
+            if (d.isValid())
+                return options?.format ? d.format(options?.format) : d.toISOString();
+        }
+        if (typeof input === 'string') {
+            const d = dayjs(input, options?.format);
+            if (d.isValid())
+                return input;
+        }
+        context.failure({
+            message: `{{label}} is not a valid date formatted${options?.format ? " (" + options.format + ")" : ''} string`,
+            format: options?.format
+        });
+    }, omitKeys(options || {}, ['format']));
+}