@depup/express-validator 7.3.1-depup.1

package/lib/chain/sanitizers-impl.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SanitizersImpl = void 0;
+const _ = require("lodash");
+const validator = require("validator");
+const sanitization_1 = require("../context-items/sanitization");
+class SanitizersImpl {
+    constructor(builder, chain) {
+        this.builder = builder;
+        this.chain = chain;
+    }
+    // custom sanitizers
+    customSanitizer(sanitizer) {
+        this.builder.addItem(new sanitization_1.Sanitization(sanitizer, true));
+        return this.chain;
+    }
+    default(default_value) {
+        return this.customSanitizer(value => [undefined, null, NaN, ''].includes(value) ? _.cloneDeep(default_value) : value);
+    }
+    replace(values_to_replace, new_value) {
+        if (!Array.isArray(values_to_replace)) {
+            values_to_replace = [values_to_replace];
+        }
+        return this.customSanitizer(value => values_to_replace.includes(value) ? _.cloneDeep(new_value) : value);
+    }
+    // Standard sanitizers
+    addStandardSanitization(sanitizer, ...options) {
+        this.builder.addItem(new sanitization_1.Sanitization(sanitizer, false, options));
+        return this.chain;
+    }
+    blacklist(chars) {
+        return this.addStandardSanitization(validator.blacklist, chars);
+    }
+    escape() {
+        return this.addStandardSanitization(validator.escape);
+    }
+    unescape() {
+        return this.addStandardSanitization(validator.unescape);
+    }
+    ltrim(chars) {
+        return this.addStandardSanitization(validator.ltrim, chars);
+    }
+    normalizeEmail(options) {
+        return this.addStandardSanitization(validator.normalizeEmail, options);
+    }
+    rtrim(chars) {
+        return this.addStandardSanitization(validator.rtrim, chars);
+    }
+    stripLow(keep_new_lines) {
+        return this.addStandardSanitization(validator.stripLow, keep_new_lines);
+    }
+    toArray() {
+        return this.customSanitizer(value => (value !== undefined && ((Array.isArray(value) && value) || [value])) || []);
+    }
+    toBoolean(strict) {
+        return this.addStandardSanitization(validator.toBoolean, strict);
+    }
+    toDate() {
+        return this.addStandardSanitization(validator.toDate);
+    }
+    toFloat() {
+        return this.addStandardSanitization(validator.toFloat);
+    }
+    toInt(radix) {
+        return this.addStandardSanitization(validator.toInt, radix);
+    }
+    toLowerCase() {
+        return this.customSanitizer(value => (typeof value === 'string' ? value.toLowerCase() : value));
+    }
+    toUpperCase() {
+        return this.customSanitizer(value => (typeof value === 'string' ? value.toUpperCase() : value));
+    }
+    trim(chars) {
+        return this.addStandardSanitization(validator.trim, chars);
+    }
+    whitelist(chars) {
+        return this.addStandardSanitization(validator.whitelist, chars);
+    }
+}
+exports.SanitizersImpl = SanitizersImpl;

package/lib/chain/sanitizers.d.ts

@@ -0,0 +1,42 @@
+import { CustomSanitizer } from '../base';
+import * as Options from '../options';
+export interface Sanitizers<Return> {
+    /**
+     * Adds a custom sanitizer to the validation chain.
+     *
+     * @param sanitizer the custom sanitizer
+     * @returns the current validation chain
+     */
+    customSanitizer(sanitizer: CustomSanitizer): Return;
+    /**
+     * Replaces the value of the field if it's one of `''`, `null`, `undefined` or `NaN`.
+     *
+     * @param default_value the value to replace with
+     * @returns the current validation chain
+     */
+    default(default_value: any): Return;
+    /**
+     * Replaces a field's value with another value.
+     *
+     * @param values_to_replace one or more values that should be replaced
+     * @param new_value the value to replace with
+     * @returns the current validation chain
+     */
+    replace(values_to_replace: any, new_value: any): Return;
+    blacklist(chars: string): Return;
+    escape(): Return;
+    unescape(): Return;
+    ltrim(chars?: string): Return;
+    normalizeEmail(options?: Options.NormalizeEmailOptions): Return;
+    rtrim(chars?: string): Return;
+    stripLow(keep_new_lines?: boolean): Return;
+    toArray(): Return;
+    toBoolean(strict?: boolean): Return;
+    toDate(): Return;
+    toFloat(): Return;
+    toInt(radix?: number): Return;
+    toLowerCase(): Return;
+    toUpperCase(): Return;
+    trim(chars?: string): Return;
+    whitelist(chars: string): Return;
+}

package/lib/chain/sanitizers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/chain/validation-chain.d.ts

@@ -0,0 +1,18 @@
+import { Request } from '../base';
+import { ContextBuilder } from '../context-builder';
+import { Sanitizers } from './sanitizers';
+import { Validators } from './validators';
+import { ContextHandler } from './context-handler';
+import { ContextRunner } from './context-runner';
+export interface ValidationChain extends Validators<ValidationChain>, Sanitizers<ValidationChain>, ContextHandler<ValidationChain>, ContextRunner {
+    (req: Request, res: any, next: (error?: any) => void): void;
+    builder: ContextBuilder;
+}
+/**
+ * A copy of `ValidationChain` where methods that would return the chain itself can return any other
+ * value.
+ * Useful for typing functions which accept either standard or custom validation chains.
+ */
+export type ValidationChainLike = {
+    [K in keyof ValidationChain]: ValidationChain[K] extends (...args: infer A) => ValidationChain ? (...args: A) => any : ValidationChain[K];
+};

package/lib/chain/validation-chain.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/chain/validators-impl.d.ts

@@ -0,0 +1,121 @@
+import { CustomValidator, ErrorMessage, FieldMessageFactory } from '../base';
+import { ContextBuilder } from '../context-builder';
+import * as Options from '../options';
+import { ExistsOptions, Validators } from './validators';
+export declare class ValidatorsImpl<Chain> implements Validators<Chain> {
+    private readonly builder;
+    private readonly chain;
+    private lastValidator;
+    private negateNext;
+    constructor(builder: ContextBuilder, chain: Chain);
+    private addItem;
+    not(): Chain;
+    withMessage(message: FieldMessageFactory | ErrorMessage): Chain;
+    custom(validator: CustomValidator): Chain;
+    exists(options?: ExistsOptions): Chain;
+    isArray(options?: {
+        min?: number;
+        max?: number;
+    }): Chain;
+    isObject(options?: {
+        strict?: boolean;
+    }): Chain;
+    isString(): Chain;
+    notEmpty(options?: Options.IsEmptyOptions): Chain;
+    private addStandardValidation;
+    contains(elem: any, options?: Options.ContainsOptions): Chain;
+    equals(comparison: string): Chain;
+    isAbaRouting(): Chain;
+    isAfter(dateOrOptions?: string | Options.IsAfterOptions): Chain;
+    isAlpha(locale?: Options.AlphaLocale, options?: Options.IsAlphaOptions): Chain;
+    isAlphanumeric(locale?: Options.AlphanumericLocale, options?: Options.IsAlphanumericOptions): Chain;
+    isAscii(): Chain;
+    isBase32(options?: Options.IsBase32Options): Chain;
+    isBase58(): Chain;
+    isBase64(options?: Options.IsBase64Options): Chain;
+    isBefore(date?: string): Chain;
+    isBIC(): Chain;
+    /**
+     * There are basically three levels of strictness for this validator.
+     * Passing `{ strict: true }` as option only passes the validation if the value is a JS bool. (It also overrides the loose property of the options).
+     * Passing `{ loose: true|false }` along with no `strict` prop of with `strict` falsy follows the behaviour specified in validator.js docs.
+     */
+    isBoolean(options?: Options.IsBooleanOptions): Chain;
+    isBtcAddress(): Chain;
+    isByteLength(options: Options.MinMaxOptions): Chain;
+    isCreditCard(): Chain;
+    isCurrency(options?: Options.IsCurrencyOptions): Chain;
+    isDataURI(): Chain;
+    isDate(options?: Options.IsDateOptions): Chain;
+    isDecimal(options?: Options.IsDecimalOptions): Chain;
+    isDivisibleBy(number: number): Chain;
+    isEAN(): Chain;
+    isEmail(options?: Options.IsEmailOptions): Chain;
+    isEmpty(options?: Options.IsEmptyOptions): Chain;
+    isEthereumAddress(): Chain;
+    isFQDN(options?: Options.IsFQDNOptions): Chain;
+    isFloat(options?: Options.IsFloatOptions): Chain;
+    isFreightContainerID(): Chain;
+    isFullWidth(): Chain;
+    isHalfWidth(): Chain;
+    isHash(algorithm: Options.HashAlgorithm): Chain;
+    isHexColor(): Chain;
+    isHexadecimal(): Chain;
+    isHSL(): Chain;
+    isIBAN(options?: Options.IsIBANOptions): Chain;
+    isIdentityCard(locale: Options.IdentityCardLocale): Chain;
+    isIMEI(options?: Options.IsIMEIOptions): Chain;
+    isIP(version?: Options.IPVersion): Chain;
+    isIPRange(version?: Options.IPVersion): Chain;
+    isISBN(versionOrOptions?: number | Options.IsISBNOptions): Chain;
+    isISSN(options?: Options.IsISSNOptions): Chain;
+    isISIN(): Chain;
+    isISO6346(): Chain;
+    isISO6391(): Chain;
+    isISO8601(options?: Options.IsISO8601Options): Chain;
+    isISO31661Numeric(): Chain;
+    isISO31661Alpha2(): Chain;
+    isISO31661Alpha3(): Chain;
+    isISO4217(): Chain;
+    isISO15924(): Chain;
+    isISRC(): Chain;
+    isIn(values: readonly any[]): Chain;
+    isInt(options?: Options.IsIntOptions): Chain;
+    isJSON(options?: Options.IsJSONOptions): Chain;
+    isJWT(): Chain;
+    isLatLong(options?: Options.IsLatLongOptions): Chain;
+    isLength(options: Options.MinMaxOptions): Chain;
+    isLicensePlate(locale: Options.IsLicensePlateLocale): Chain;
+    isLocale(): Chain;
+    isLowercase(): Chain;
+    isLuhnNumber(): Chain;
+    isMagnetURI(): Chain;
+    isMailtoURI(options?: Options.IsEmailOptions): Chain;
+    isMACAddress(options?: Options.IsMACAddressOptions): Chain;
+    isMD5(): Chain;
+    isMimeType(): Chain;
+    isMobilePhone(locale: Options.MobilePhoneLocale | readonly Options.MobilePhoneLocale[], options?: Options.IsMobilePhoneOptions): Chain;
+    isMongoId(): Chain;
+    isMultibyte(): Chain;
+    isNumeric(options?: Options.IsNumericOptions): Chain;
+    isOctal(): Chain;
+    isPassportNumber(countryCode?: Options.PassportCountryCode): Chain;
+    isPort(): Chain;
+    isPostalCode(locale: Options.PostalCodeLocale): Chain;
+    isRFC3339(): Chain;
+    isRgbColor(includePercentValues?: boolean): Chain;
+    isSemVer(): Chain;
+    isSlug(): Chain;
+    isStrongPassword(options?: Options.IsStrongPasswordOptions): Chain;
+    isSurrogatePair(): Chain;
+    isTaxID(locale: Options.TaxIDLocale): Chain;
+    isTime(options?: Options.IsTimeOptions): Chain;
+    isURL(options?: Options.IsURLOptions): Chain;
+    isULID(): Chain;
+    isUUID(version?: Options.UUIDVersion): Chain;
+    isUppercase(): Chain;
+    isVariableWidth(): Chain;
+    isVAT(countryCode: Options.VATCountryCode): Chain;
+    isWhitelisted(chars: string | readonly string[]): Chain;
+    matches(pattern: RegExp | string, modifiers?: string): any;
+}

package/lib/chain/validators-impl.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorsImpl = void 0;
+const validator = require("validator");
+const context_items_1 = require("../context-items");
+class ValidatorsImpl {
+    constructor(builder, chain) {
+        this.builder = builder;
+        this.chain = chain;
+        this.negateNext = false;
+    }
+    addItem(item) {
+        this.builder.addItem(item);
+        this.lastValidator = item;
+        // Reset this.negateNext so that next validation isn't negated too
+        this.negateNext = false;
+        return this.chain;
+    }
+    // validation manipulation
+    not() {
+        this.negateNext = true;
+        return this.chain;
+    }
+    withMessage(message) {
+        this.lastValidator.message = message;
+        return this.chain;
+    }
+    // custom validators
+    custom(validator) {
+        return this.addItem(new context_items_1.CustomValidation(validator, this.negateNext));
+    }
+    exists(options = {}) {
+        let validator;
+        if (options.checkFalsy || options.values === 'falsy') {
+            validator = value => !!value;
+        }
+        else if (options.checkNull || options.values === 'null') {
+            validator = value => value != null;
+        }
+        else {
+            validator = value => value !== undefined;
+        }
+        return this.custom(validator);
+    }
+    isArray(options = {}) {
+        return this.custom(value => Array.isArray(value) &&
+            (typeof options.min === 'undefined' || value.length >= options.min) &&
+            (typeof options.max === 'undefined' || value.length <= options.max));
+    }
+    isObject(options = { strict: true }) {
+        return this.custom(value => typeof value === 'object' &&
+            (options.strict == null || options.strict ? value !== null && !Array.isArray(value) : true));
+    }
+    isString() {
+        return this.custom(value => typeof value === 'string');
+    }
+    notEmpty(options) {
+        this.not();
+        return this.isEmpty(options);
+    }
+    // Standard validators
+    addStandardValidation(validator, ...options) {
+        return this.addItem(new context_items_1.StandardValidation(validator, this.negateNext, options));
+    }
+    contains(elem, options) {
+        return this.addStandardValidation(validator.contains, elem, options);
+    }
+    equals(comparison) {
+        return this.addStandardValidation(validator.equals, comparison);
+    }
+    isAbaRouting() {
+        return this.addStandardValidation(validator.isAbaRouting);
+    }
+    isAfter(dateOrOptions) {
+        return this.addStandardValidation(validator.isAfter, dateOrOptions);
+    }
+    isAlpha(locale, options) {
+        // TODO(v7): remove string[] support
+        const ignore = Array.isArray(options?.ignore) ? options?.ignore.join('') : options?.ignore;
+        return this.addStandardValidation(validator.isAlpha, locale, { ...options, ignore });
+    }
+    isAlphanumeric(locale, options) {
+        return this.addStandardValidation(validator.isAlphanumeric, locale, options);
+    }
+    isAscii() {
+        return this.addStandardValidation(validator.isAscii);
+    }
+    isBase32(options) {
+        return this.addStandardValidation(validator.isBase32, options);
+    }
+    isBase58() {
+        return this.addStandardValidation(validator.isBase58);
+    }
+    isBase64(options) {
+        return this.addStandardValidation(validator.isBase64, options);
+    }
+    isBefore(date) {
+        return this.addStandardValidation(validator.isBefore, date);
+    }
+    isBIC() {
+        return this.addStandardValidation(validator.isBIC);
+    }
+    /**
+     * There are basically three levels of strictness for this validator.
+     * Passing `{ strict: true }` as option only passes the validation if the value is a JS bool. (It also overrides the loose property of the options).
+     * Passing `{ loose: true|false }` along with no `strict` prop of with `strict` falsy follows the behaviour specified in validator.js docs.
+     */
+    isBoolean(options) {
+        if (options?.strict) {
+            return this.custom(value => {
+                return value === true || value === false;
+            });
+        }
+        return this.addStandardValidation(validator.isBoolean, options);
+    }
+    isBtcAddress() {
+        return this.addStandardValidation(validator.isBtcAddress);
+    }
+    isByteLength(options) {
+        return this.addStandardValidation(validator.isByteLength, options);
+    }
+    isCreditCard() {
+        return this.addStandardValidation(validator.isCreditCard);
+    }
+    isCurrency(options) {
+        return this.addStandardValidation(validator.isCurrency, options);
+    }
+    isDataURI() {
+        return this.addStandardValidation(validator.isDataURI);
+    }
+    isDate(options) {
+        return this.addStandardValidation(validator.isDate, options);
+    }
+    isDecimal(options) {
+        return this.addStandardValidation(validator.isDecimal, options);
+    }
+    isDivisibleBy(number) {
+        return this.addStandardValidation(validator.isDivisibleBy, number);
+    }
+    isEAN() {
+        return this.addStandardValidation(validator.isEAN);
+    }
+    isEmail(options) {
+        return this.addStandardValidation(validator.isEmail, options);
+    }
+    isEmpty(options) {
+        return this.addStandardValidation(validator.isEmpty, options);
+    }
+    isEthereumAddress() {
+        return this.addStandardValidation(validator.isEthereumAddress);
+    }
+    isFQDN(options) {
+        return this.addStandardValidation(validator.isFQDN, options);
+    }
+    isFloat(options) {
+        return this.addStandardValidation(validator.isFloat, options);
+    }
+    isFreightContainerID() {
+        return this.addStandardValidation(validator.isFreightContainerID);
+    }
+    isFullWidth() {
+        return this.addStandardValidation(validator.isFullWidth);
+    }
+    isHalfWidth() {
+        return this.addStandardValidation(validator.isHalfWidth);
+    }
+    isHash(algorithm) {
+        return this.addStandardValidation(validator.isHash, algorithm);
+    }
+    isHexColor() {
+        return this.addStandardValidation(validator.isHexColor);
+    }
+    isHexadecimal() {
+        return this.addStandardValidation(validator.isHexadecimal);
+    }
+    isHSL() {
+        return this.addStandardValidation(validator.isHSL);
+    }
+    isIBAN(options) {
+        return this.addStandardValidation(validator.isIBAN, options);
+    }
+    isIdentityCard(locale) {
+        return this.addStandardValidation(validator.isIdentityCard, locale);
+    }
+    isIMEI(options) {
+        return this.addStandardValidation(validator.isIMEI, options);
+    }
+    isIP(version) {
+        return this.addStandardValidation(validator.isIP, version);
+    }
+    isIPRange(version) {
+        return this.addStandardValidation(validator.isIPRange, version);
+    }
+    isISBN(versionOrOptions) {
+        return this.addStandardValidation(validator.isISBN, versionOrOptions);
+    }
+    isISSN(options) {
+        return this.addStandardValidation(validator.isISSN, options);
+    }
+    isISIN() {
+        return this.addStandardValidation(validator.isISIN);
+    }
+    isISO6346() {
+        return this.addStandardValidation(validator.isISO6346);
+    }
+    isISO6391() {
+        return this.addStandardValidation(validator.isISO6391);
+    }
+    isISO8601(options) {
+        return this.addStandardValidation(validator.isISO8601, options);
+    }
+    isISO31661Numeric() {
+        return this.addStandardValidation(validator.isISO31661Numeric);
+    }
+    isISO31661Alpha2() {
+        return this.addStandardValidation(validator.isISO31661Alpha2);
+    }
+    isISO31661Alpha3() {
+        return this.addStandardValidation(validator.isISO31661Alpha3);
+    }
+    isISO4217() {
+        return this.addStandardValidation(validator.isISO4217);
+    }
+    isISO15924() {
+        return this.addStandardValidation(validator.isISO15924);
+    }
+    isISRC() {
+        return this.addStandardValidation(validator.isISRC);
+    }
+    isIn(values) {
+        return this.addStandardValidation(validator.isIn, values);
+    }
+    isInt(options) {
+        return this.addStandardValidation(validator.isInt, options);
+    }
+    isJSON(options) {
+        return this.addStandardValidation(validator.isJSON, options);
+    }
+    isJWT() {
+        return this.addStandardValidation(validator.isJWT);
+    }
+    isLatLong(options) {
+        return this.addStandardValidation(validator.isLatLong, options);
+    }
+    isLength(options) {
+        return this.addStandardValidation(validator.isLength, options);
+    }
+    isLicensePlate(locale) {
+        return this.addStandardValidation(validator.isLicensePlate, locale);
+    }
+    isLocale() {
+        return this.addStandardValidation(validator.isLocale);
+    }
+    isLowercase() {
+        return this.addStandardValidation(validator.isLowercase);
+    }
+    isLuhnNumber() {
+        return this.addStandardValidation(validator.isLuhnNumber);
+    }
+    isMagnetURI() {
+        return this.addStandardValidation(validator.isMagnetURI);
+    }
+    isMailtoURI(options) {
+        return this.addStandardValidation(validator.isMailtoURI, options);
+    }
+    isMACAddress(options) {
+        return this.addStandardValidation(validator.isMACAddress, options);
+    }
+    isMD5() {
+        return this.addStandardValidation(validator.isMD5);
+    }
+    isMimeType() {
+        return this.addStandardValidation(validator.isMimeType);
+    }
+    isMobilePhone(locale, options) {
+        return this.addStandardValidation(validator.isMobilePhone, locale, options);
+    }
+    isMongoId() {
+        return this.addStandardValidation(validator.isMongoId);
+    }
+    isMultibyte() {
+        return this.addStandardValidation(validator.isMultibyte);
+    }
+    isNumeric(options) {
+        return this.addStandardValidation(validator.isNumeric, options);
+    }
+    isOctal() {
+        return this.addStandardValidation(validator.isOctal);
+    }
+    isPassportNumber(countryCode) {
+        return this.addStandardValidation(validator.isPassportNumber, countryCode);
+    }
+    isPort() {
+        return this.addStandardValidation(validator.isPort);
+    }
+    isPostalCode(locale) {
+        return this.addStandardValidation(validator.isPostalCode, locale);
+    }
+    isRFC3339() {
+        return this.addStandardValidation(validator.isRFC3339);
+    }
+    isRgbColor(includePercentValues) {
+        return this.addStandardValidation(validator.isRgbColor, includePercentValues);
+    }
+    isSemVer() {
+        return this.addStandardValidation(validator.isSemVer);
+    }
+    isSlug() {
+        return this.addStandardValidation(validator.isSlug);
+    }
+    isStrongPassword(options) {
+        return this.addStandardValidation(validator.isStrongPassword, options);
+    }
+    isSurrogatePair() {
+        return this.addStandardValidation(validator.isSurrogatePair);
+    }
+    isTaxID(locale) {
+        return this.addStandardValidation(validator.isTaxID, locale);
+    }
+    isTime(options) {
+        return this.addStandardValidation(validator.isTime, options);
+    }
+    isURL(options) {
+        return this.addStandardValidation(validator.isURL, options);
+    }
+    isULID() {
+        return this.addStandardValidation(validator.isULID);
+    }
+    isUUID(version) {
+        return this.addStandardValidation(validator.isUUID, version);
+    }
+    isUppercase() {
+        return this.addStandardValidation(validator.isUppercase);
+    }
+    isVariableWidth() {
+        return this.addStandardValidation(validator.isVariableWidth);
+    }
+    isVAT(countryCode) {
+        return this.addStandardValidation(validator.isVAT, countryCode);
+    }
+    isWhitelisted(chars) {
+        return this.addStandardValidation(validator.isWhitelisted, chars);
+    }
+    matches(pattern, modifiers) {
+        return this.addStandardValidation.apply(this, [
+            validator.matches,
+            ...(typeof pattern === 'string'
+                ? [pattern, modifiers]
+                : [pattern.source, [...new Set((modifiers || '') + pattern.flags)].join('')]),
+        ]);
+    }
+}
+exports.ValidatorsImpl = ValidatorsImpl;