@depup/express-validator 7.3.1-depup.1

package/lib/context.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const _ = require("lodash");
+function getDataMapKey(path, location) {
+    return `${location}:${path}`;
+}
+class Context {
+    get errors() {
+        return this._errors;
+    }
+    constructor(fields, locations, stack, optional, bail, visibility = { type: 'visible' }, message) {
+        this.fields = fields;
+        this.locations = locations;
+        this.stack = stack;
+        this.optional = optional;
+        this.bail = bail;
+        this.visibility = visibility;
+        this.message = message;
+        this._errors = [];
+        this.dataMap = new Map();
+    }
+    getData(options = { requiredOnly: false }) {
+        const { optional } = this;
+        const checks = options.requiredOnly && optional
+            ? [
+                (value) => value !== undefined,
+                (value) => (optional === 'null' ? value != null : true),
+                (value) => (optional === 'falsy' ? value : true),
+            ]
+            : [];
+        return _([...this.dataMap.values()])
+            .groupBy('originalPath')
+            .flatMap((instances, group) => {
+            const locations = _.uniqBy(instances, 'location');
+            // #331 - When multiple locations are involved, all of them must pass the validation.
+            // If none of the locations contain the field, we at least include one for error reporting.
+            // #458, #531 - Wildcards are an exception though: they may yield 0..* instances with different
+            // paths, so we may want to skip this filtering.
+            if (instances.length > 1 && locations.length > 1 && !group.includes('*')) {
+                const withValue = instances.filter(instance => instance.value !== undefined);
+                return withValue.length ? withValue : [instances[0]];
+            }
+            return instances;
+        })
+            .filter(instance => checks.every(check => check(instance.value)))
+            .valueOf();
+    }
+    addFieldInstances(instances) {
+        instances.forEach(instance => {
+            this.dataMap.set(getDataMapKey(instance.path, instance.location), { ...instance });
+        });
+    }
+    setData(path, value, location) {
+        const instance = this.dataMap.get(getDataMapKey(path, location));
+        if (!instance) {
+            throw new Error('Attempt to write data that did not pre-exist in context');
+        }
+        instance.value = value;
+    }
+    addError(opts) {
+        const msg = opts.message || this.message || 'Invalid value';
+        let error;
+        switch (opts.type) {
+            case 'field':
+                error = this.updateVisibility({
+                    type: 'field',
+                    value: opts.value,
+                    msg: typeof msg === 'function' ? msg(opts.value, opts.meta) : msg,
+                    path: opts.meta?.path,
+                    location: opts.meta?.location,
+                });
+                break;
+            case 'unknown_fields':
+                error = {
+                    type: 'unknown_fields',
+                    msg: typeof msg === 'function' ? msg(opts.fields, { req: opts.req }) : msg,
+                    fields: opts.fields,
+                };
+                break;
+            case 'alternative':
+                error = {
+                    type: 'alternative',
+                    msg: typeof msg === 'function' ? msg(opts.nestedErrors, { req: opts.req }) : msg,
+                    nestedErrors: opts.nestedErrors.map(error => this.updateVisibility(error)),
+                };
+                break;
+            case 'alternative_grouped':
+                error = {
+                    type: 'alternative_grouped',
+                    msg: typeof msg === 'function' ? msg(opts.nestedErrors, { req: opts.req }) : msg,
+                    nestedErrors: opts.nestedErrors.map(errors => errors.map(error => this.updateVisibility(error))),
+                };
+                break;
+            default:
+                throw new Error(`Unhandled addError case`);
+        }
+        this._errors.push(error);
+    }
+    updateVisibility(error) {
+        switch (this.visibility.type) {
+            case 'hidden':
+                error = { ...error };
+                delete error.value;
+                return error;
+            case 'redacted':
+                return {
+                    ...error,
+                    value: this.visibility.value,
+                };
+            case 'visible':
+            default:
+                return error;
+        }
+    }
+}
+exports.Context = Context;

package/lib/express-validator.d.ts

@@ -0,0 +1,153 @@
+import { CustomSanitizer, CustomValidator, ErrorMessage, FieldMessageFactory, Location, Middleware, Request, ValidationError } from './base';
+import { ContextRunner, ValidationChain } from './chain';
+import { MatchedDataOptions } from './matched-data';
+import { checkExact } from './middlewares/exact';
+import { OneOfOptions } from './middlewares/one-of';
+import { DefaultSchemaKeys, ExtensionSanitizerSchemaOptions, ExtensionValidatorSchemaOptions, ParamSchema, RunnableValidationChains } from './middlewares/schema';
+import { ErrorFormatter, Result } from './validation-result';
+type CustomValidatorsMap = Record<string, CustomValidator>;
+type CustomSanitizersMap = Record<string, CustomSanitizer>;
+type CustomOptions<E = ValidationError> = {
+    errorFormatter?: ErrorFormatter<E>;
+};
+/**
+ * A validation chain that contains some extension validators/sanitizers.
+ *
+ * Built-in methods return the same chain type so that chaining using more of the extensions is
+ * possible.
+ *
+ * @example
+ * ```
+ * function createChain(chain: ValidationChainWithExtensions<'isAllowedDomain' | 'removeEmailAttribute'>) {
+ *  return chain
+ *    .isEmail()
+ *    .isAllowedDomain()
+ *    .trim()
+ *    .removeEmailAttribute();
+ * }
+ * ```
+ */
+export type ValidationChainWithExtensions<T extends string> = Middleware & {
+    [K in keyof ValidationChain]: ValidationChain[K] extends (...args: infer A) => ValidationChain ? (...params: A) => ValidationChainWithExtensions<T> : ValidationChain[K];
+} & {
+    [K in T]: () => ValidationChainWithExtensions<T>;
+};
+/**
+ * Schema of validations/sanitizations for a field, including extension validators/sanitizers
+ */
+export type ParamSchemaWithExtensions<V extends string, S extends string, T extends string = DefaultSchemaKeys> = {
+    [K in keyof ParamSchema<T> | V | S]?: K extends V ? ExtensionValidatorSchemaOptions : K extends S ? ExtensionSanitizerSchemaOptions : K extends keyof ParamSchema<T> ? ParamSchema<T>[K] : never;
+};
+/**
+ * Type of a validation chain created by a custom ExpressValidator instance.
+ *
+ * @example
+ * ```
+ * const myExpressValidator = new ExpressValidator({
+ *  isAllowedDomain: value => value.endsWith('@gmail.com')
+ * });
+ *
+ * type MyCustomValidationChain = CustomValidationChain<typeof myExpressValidator>
+ * function createMyCustomChain(): MyCustomValidationChain {
+ *  return myExpressValidator.body('email').isAllowedDomain();
+ * }
+ * ```
+ */
+export type CustomValidationChain<T extends ExpressValidator<any, any, any>> = T extends ExpressValidator<infer V, infer S, any> ? ValidationChainWithExtensions<Extract<keyof V | keyof S, string>> : never;
+/**
+ * Mapping from field name to a validations/sanitizations schema, including extensions from an
+ * ExpressValidator instance.
+ */
+export type CustomSchema<T extends ExpressValidator<any, any, any>, K extends string = DefaultSchemaKeys> = T extends ExpressValidator<infer V, infer S, any> ? Record<string, ParamSchemaWithExtensions<Extract<keyof V, string>, Extract<keyof S, string>, K>> : never;
+export declare class ExpressValidator<V extends CustomValidatorsMap = {}, S extends CustomSanitizersMap = {}, E = ValidationError> {
+    private readonly validators?;
+    private readonly sanitizers?;
+    private readonly options?;
+    private readonly validatorEntries;
+    private readonly sanitizerEntries;
+    constructor(validators?: V | undefined, sanitizers?: S | undefined, options?: CustomOptions<E> | undefined);
+    private createChain;
+    buildCheckFunction(locations: Location[]): (fields?: string | string[], message?: FieldMessageFactory | ErrorMessage) => CustomValidationChain<this>;
+    /**
+     * Creates a middleware/validation chain for one or more fields that may be located in
+     * any of the following:
+     *
+     * - `req.body`
+     * - `req.cookies`
+     * - `req.headers`
+     * - `req.params`
+     * - `req.query`
+     *
+     * @param fields  a string or array of field names to validate/sanitize
+     * @param message an error message to use when failed validations don't specify a custom message.
+     *                Defaults to `Invalid Value`.
+     */
+    readonly check: (fields?: string | string[], message?: FieldMessageFactory | ErrorMessage) => CustomValidationChain<this>;
+    /**
+     * Same as {@link ExpressValidator.check}, but only validates in `req.body`.
+     */
+    readonly body: (fields?: string | string[], message?: FieldMessageFactory | ErrorMessage) => CustomValidationChain<this>;
+    /**
+     * Same as {@link ExpressValidator.check}, but only validates in `req.cookies`.
+     */
+    readonly cookie: (fields?: string | string[], message?: FieldMessageFactory | ErrorMessage) => CustomValidationChain<this>;
+    /**
+     * Same as {@link ExpressValidator.check}, but only validates in `req.headers`.
+     */
+    readonly header: (fields?: string | string[], message?: FieldMessageFactory | ErrorMessage) => CustomValidationChain<this>;
+    /**
+     * Same as {@link ExpressValidator.check}, but only validates in `req.params`.
+     */
+    readonly param: (fields?: string | string[], message?: FieldMessageFactory | ErrorMessage) => CustomValidationChain<this>;
+    /**
+     * Same as {@link ExpressValidator.check}, but only validates in `req.query`.
+     */
+    readonly query: (fields?: string | string[], message?: FieldMessageFactory | ErrorMessage) => CustomValidationChain<this>;
+    /**
+     * Checks whether the request contains exactly only those fields that have been validated.
+     *
+     * This method is here for convenience; it does exactly the same as `checkExact`.
+     *
+     * @see {@link checkExact}
+     */
+    readonly checkExact: typeof checkExact;
+    /**
+     * Creates an express middleware with validations for multiple fields at once in the form of
+     * a schema object.
+     *
+     * @param schema the schema to validate.
+     * @param defaultLocations which locations to validate in each field. Defaults to every location.
+     */
+    readonly checkSchema: <T extends string = DefaultSchemaKeys>(schema: CustomSchema<this, T>, locations?: Location[]) => RunnableValidationChains<CustomValidationChain<this>>;
+    /**
+     * Creates a middleware that will ensure that at least one of the given validation chains
+     * or validation chain groups are valid.
+     *
+     * If none are, a single error of type `alternative` is added to the request,
+     * with the errors of each chain made available under the `nestedErrors` property.
+     *
+     * @param chains an array of validation chains to check if are valid.
+     *               If any of the items of `chains` is an array of validation chains, then all of them
+     *               must be valid together for the request to be considered valid.
+     */
+    oneOf(chains: (CustomValidationChain<this> | CustomValidationChain<this>[])[], options?: OneOfOptions): Middleware & ContextRunner;
+    /**
+     * Extracts the validation errors of an express request using the default error formatter of this
+     * instance.
+     *
+     * @see {@link validationResult()}
+     * @param req the express request object
+     * @returns a `Result` which will by default use the error formatter passed when
+     *          instantiating `ExpressValidator`.
+     */
+    readonly validationResult: (req: Request) => Result<E>;
+    /**
+     * Extracts data validated or sanitized from the request, and builds an object with them.
+     *
+     * This method is a shortcut for `matchedData`; it does nothing different than it.
+     *
+     * @see {@link matchedData}
+     */
+    matchedData(req: Request, options?: Partial<MatchedDataOptions>): Record<string, any>;
+}
+export {};

package/lib/express-validator.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressValidator = void 0;
+const matched_data_1 = require("./matched-data");
+const check_1 = require("./middlewares/check");
+const exact_1 = require("./middlewares/exact");
+const one_of_1 = require("./middlewares/one-of");
+const schema_1 = require("./middlewares/schema");
+const validation_result_1 = require("./validation-result");
+/* eslint-enable no-use-before-define */
+class ExpressValidator {
+    constructor(validators, sanitizers, options) {
+        this.validators = validators;
+        this.sanitizers = sanitizers;
+        this.options = options;
+        /**
+         * Creates a middleware/validation chain for one or more fields that may be located in
+         * any of the following:
+         *
+         * - `req.body`
+         * - `req.cookies`
+         * - `req.headers`
+         * - `req.params`
+         * - `req.query`
+         *
+         * @param fields  a string or array of field names to validate/sanitize
+         * @param message an error message to use when failed validations don't specify a custom message.
+         *                Defaults to `Invalid Value`.
+         */
+        this.check = this.buildCheckFunction(['body', 'cookies', 'headers', 'params', 'query']);
+        /**
+         * Same as {@link ExpressValidator.check}, but only validates in `req.body`.
+         */
+        this.body = this.buildCheckFunction(['body']);
+        /**
+         * Same as {@link ExpressValidator.check}, but only validates in `req.cookies`.
+         */
+        this.cookie = this.buildCheckFunction(['cookies']);
+        /**
+         * Same as {@link ExpressValidator.check}, but only validates in `req.headers`.
+         */
+        this.header = this.buildCheckFunction(['headers']);
+        /**
+         * Same as {@link ExpressValidator.check}, but only validates in `req.params`.
+         */
+        this.param = this.buildCheckFunction(['params']);
+        /**
+         * Same as {@link ExpressValidator.check}, but only validates in `req.query`.
+         */
+        this.query = this.buildCheckFunction(['query']);
+        /**
+         * Checks whether the request contains exactly only those fields that have been validated.
+         *
+         * This method is here for convenience; it does exactly the same as `checkExact`.
+         *
+         * @see {@link checkExact}
+         */
+        this.checkExact = exact_1.checkExact;
+        /**
+         * Creates an express middleware with validations for multiple fields at once in the form of
+         * a schema object.
+         *
+         * @param schema the schema to validate.
+         * @param defaultLocations which locations to validate in each field. Defaults to every location.
+         */
+        // NOTE: This method references its own type, so the type cast is necessary.
+        this.checkSchema = (0, schema_1.createCheckSchema)((...args) => this.createChain(...args), Object.keys(this.validators || {}), Object.keys(this.sanitizers || {}));
+        /**
+         * Extracts the validation errors of an express request using the default error formatter of this
+         * instance.
+         *
+         * @see {@link validationResult()}
+         * @param req the express request object
+         * @returns a `Result` which will by default use the error formatter passed when
+         *          instantiating `ExpressValidator`.
+         */
+        this.validationResult = (req) => {
+            const formatter = this.options?.errorFormatter;
+            const result = (0, validation_result_1.validationResult)(req);
+            return formatter ? result.formatWith(formatter) : result;
+        };
+        this.validatorEntries = Object.entries(validators || {});
+        this.sanitizerEntries = Object.entries(sanitizers || {});
+        // Can't use arrow function in the declaration of `buildCheckFunction` due to the following
+        // error which only happens when tests are run without Jest cache (so CI only):
+        //
+        //    'buildCheckFunction' implicitly has type 'any' because it does not have a type annotation
+        //    and is referenced directly or indirectly in its own initializer
+        this.buildCheckFunction = this.buildCheckFunction.bind(this);
+    }
+    createChain(fields = '', locations = [], message) {
+        const middleware = (0, check_1.check)(fields, locations, message);
+        const boundValidators = Object.fromEntries(this.validatorEntries.map(([name, fn]) => [name, () => middleware.custom(fn)]));
+        const boundSanitizers = Object.fromEntries(this.sanitizerEntries.map(([name, fn]) => [name, () => middleware.customSanitizer(fn)]));
+        return Object.assign(middleware, boundValidators, boundSanitizers);
+    }
+    buildCheckFunction(locations) {
+        return (fields, message) => this.createChain(fields, locations, message);
+    }
+    /**
+     * Creates a middleware that will ensure that at least one of the given validation chains
+     * or validation chain groups are valid.
+     *
+     * If none are, a single error of type `alternative` is added to the request,
+     * with the errors of each chain made available under the `nestedErrors` property.
+     *
+     * @param chains an array of validation chains to check if are valid.
+     *               If any of the items of `chains` is an array of validation chains, then all of them
+     *               must be valid together for the request to be considered valid.
+     */
+    oneOf(chains, options) {
+        return (0, one_of_1.oneOf)(chains, options);
+    }
+    /**
+     * Extracts data validated or sanitized from the request, and builds an object with them.
+     *
+     * This method is a shortcut for `matchedData`; it does nothing different than it.
+     *
+     * @see {@link matchedData}
+     */
+    matchedData(req, options) {
+        return (0, matched_data_1.matchedData)(req, options);
+    }
+}
+exports.ExpressValidator = ExpressValidator;

package/lib/field-selection.d.ts

@@ -0,0 +1,22 @@
+import { FieldInstance, Location, Request, UnknownFieldInstance } from './base';
+export type SelectFields = (req: Request, fields: string[], locations: Location[]) => FieldInstance[];
+export declare const selectFields: SelectFields;
+export declare const selectUnknownFields: (req: Request, knownFields: string[], locations: Location[]) => UnknownFieldInstance[];
+/**
+ * Reconstructs a field path from a list of path segments.
+ *
+ * Most segments will be concatenated by a dot, for example `['foo', 'bar']` becomes `foo.bar`.
+ * However, a numeric segment will be wrapped in brackets to match regular JS array syntax:
+ *
+ * ```
+ * reconstructFieldPath(['foo', 0, 'bar']) // foo[0].bar
+ * ```
+ *
+ * Segments which have a special character such as `.` will be wrapped in brackets and quotes,
+ * which also matches JS syntax for objects with such keys.
+ *
+ * ```
+ * reconstructFieldPath(['foo', 'bar.baz', 'qux']) // foo["bar.baz"].qux
+ * ```
+ */
+export declare function reconstructFieldPath(segments: readonly string[]): string;

package/lib/field-selection.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectUnknownFields = exports.selectFields = void 0;
+exports.reconstructFieldPath = reconstructFieldPath;
+const _ = require("lodash");
+const selectFields = (req, fields, locations) => _(fields)
+    .flatMap(field => _.flatMap(locations, location => {
+    return expandField(req, field, location);
+}))
+    // Avoid duplicates if multiple field selections would return the same field twice.
+    // E.g. with fields = ['*.foo', 'bar.foo'] and req.body = { bar: { foo: 1 }, baz: { foo: 2 } },
+    // the instance bla.foo would appear twice, and baz.foo once.
+    .uniqWith(isSameFieldInstance)
+    .value();
+exports.selectFields = selectFields;
+function isSameFieldInstance(a, b) {
+    return a.path === b.path && a.location === b.location;
+}
+function expandField(req, field, location) {
+    const originalPath = field;
+    const pathToExpand = location === 'headers' ? field.toLowerCase() : field;
+    const paths = expandPath(req[location], pathToExpand, []);
+    return paths.map(({ path, values }) => {
+        const value = path === '' ? req[location] : _.get(req[location], path);
+        return {
+            location,
+            path,
+            originalPath,
+            pathValues: values,
+            value,
+        };
+    });
+}
+function expandPath(object, path, currPath, currValues = []) {
+    const segments = _.toPath(path);
+    if (!segments.length) {
+        // no more paths to traverse
+        return [
+            {
+                path: reconstructFieldPath(currPath),
+                values: currValues,
+            },
+        ];
+    }
+    const key = segments[0];
+    const rest = segments.slice(1);
+    if (object != null && !_.isObjectLike(object)) {
+        if (key === '**') {
+            if (!rest.length) {
+                // globstar leaves are always selected
+                return [
+                    {
+                        path: reconstructFieldPath(currPath),
+                        values: currValues,
+                    },
+                ];
+            }
+            return [];
+        }
+        if (key === '*') {
+            // wildcard position does not exist
+            return [];
+        }
+        // value is a primitive, paths being traversed from here might be in their prototype, return the entire path
+        return [
+            {
+                path: reconstructFieldPath([...currPath, ...segments]),
+                values: currValues,
+            },
+        ];
+    }
+    // Use a non-null value so that inexistent fields are still selected
+    object = object || {};
+    if (key === '*') {
+        return Object.keys(object).flatMap(key => expandPath(object[key], rest, currPath.concat(key), currValues.concat(key)));
+    }
+    if (key === '**') {
+        return Object.keys(object).flatMap(key => {
+            const nextPath = currPath.concat(key);
+            const value = object[key];
+            // recursively find matching subpaths
+            const selectedPaths = expandPath(value, segments, nextPath, [key]).concat(
+            // skip the first remaining segment, if it matches the current key
+            rest[0] === key ? expandPath(value, rest.slice(1), nextPath, []) : []);
+            return _.uniqBy(selectedPaths, ({ path }) => path).map(({ path, values }) => ({
+                path,
+                values: values.length ? [...currValues, values.flat()] : currValues,
+            }));
+        });
+    }
+    return expandPath(object[key], rest, currPath.concat(key), currValues);
+}
+const selectUnknownFields = (req, knownFields, locations) => {
+    const tree = {};
+    knownFields.forEach(field => {
+        const segments = field === '' ? [''] : _.toPath(field);
+        pathToTree(segments, tree);
+    });
+    const instances = [];
+    for (const location of locations) {
+        if (req[location] != null) {
+            instances.push(...findUnknownFields(location, req[location], tree));
+        }
+    }
+    return instances;
+};
+exports.selectUnknownFields = selectUnknownFields;
+function pathToTree(segments, tree) {
+    // Will either create or merge into existing branch for the current path segment
+    const branch = tree[segments[0]] || (tree[segments[0]] = {});
+    if (segments.length > 1) {
+        pathToTree(segments.slice(1), branch);
+    }
+    else {
+        // Leaf value.
+        branch[''] = {};
+    }
+}
+/**
+ * Performs a depth-first search for unknown fields in `value`.
+ * The path to the unknown fields will be pushed to the `unknownFields` argument.
+ *
+ * Known fields must be passed via `tree`. A field won't be considered unknown if:
+ * - its branch is validated as a whole; that is, it contains an empty string key (e.g `{ ['']: {} }`); OR
+ * - its path is individually validated; OR
+ * - it's covered by a wildcard (`*`).
+ *
+ * @returns the list of unknown fields
+ */
+function findUnknownFields(location, value, tree, treePath = [], unknownFields = []) {
+    const globstarBranch = tree['**'];
+    if (tree[''] || globstarBranch?.['']) {
+        // The rest of the tree from here is covered by some validation chain
+        // For example, when the current treePath is `['foo', 'bar']` but `foo` is known
+        return unknownFields;
+    }
+    if (typeof value !== 'object') {
+        if (!treePath.length || globstarBranch) {
+            // This is either
+            // a. a req.body that isn't an object (e.g. `req.body = 'bla'`), and wasn't validated either
+            // b. a leaf value which wasn't the target of a globstar path, e.g. `foo.**.bar`
+            unknownFields.push({
+                path: reconstructFieldPath(treePath),
+                value,
+                location,
+            });
+        }
+        return unknownFields;
+    }
+    const wildcardBranch = tree['*'];
+    for (const key of Object.keys(value)) {
+        const keyBranch = tree[key];
+        const path = treePath.concat([key]);
+        if (!keyBranch && !wildcardBranch && !globstarBranch) {
+            // No trees cover this path, so it's an unknown one.
+            unknownFields.push({
+                path: reconstructFieldPath(path),
+                value: value[key],
+                location,
+            });
+            continue;
+        }
+        const keyUnknowns = keyBranch ? findUnknownFields(location, value[key], keyBranch, path) : [];
+        const wildcardUnknowns = wildcardBranch
+            ? findUnknownFields(location, value[key], wildcardBranch, path)
+            : [];
+        const globstarUnknowns = globstarBranch
+            ? findUnknownFields(location, value[key], { ['**']: globstarBranch, ...globstarBranch }, path)
+            : [];
+        // If any of the tested branches contain only known fields, then don't mark the fields not covered
+        // by the other branches to the list of unknown ones.
+        // For example, `foo` is more comprehensive than `foo.*.bar`.
+        if ((!keyBranch || keyUnknowns.length) &&
+            (!wildcardBranch || wildcardUnknowns.length) &&
+            (!globstarBranch || globstarUnknowns.length)) {
+            unknownFields.push(...keyUnknowns, ...wildcardUnknowns, ...globstarUnknowns);
+        }
+    }
+    return unknownFields;
+}
+/**
+ * Reconstructs a field path from a list of path segments.
+ *
+ * Most segments will be concatenated by a dot, for example `['foo', 'bar']` becomes `foo.bar`.
+ * However, a numeric segment will be wrapped in brackets to match regular JS array syntax:
+ *
+ * ```
+ * reconstructFieldPath(['foo', 0, 'bar']) // foo[0].bar
+ * ```
+ *
+ * Segments which have a special character such as `.` will be wrapped in brackets and quotes,
+ * which also matches JS syntax for objects with such keys.
+ *
+ * ```
+ * reconstructFieldPath(['foo', 'bar.baz', 'qux']) // foo["bar.baz"].qux
+ * ```
+ */
+function reconstructFieldPath(segments) {
+    return segments.reduce((prev, segment) => {
+        let part = '';
+        segment = segment === '\\*' ? '*' : segment;
+        // TODO: Handle brackets?
+        if (segment.includes('.')) {
+            // Special char key access
+            part = `["${segment}"]`;
+        }
+        else if (/^\d+$/.test(segment)) {
+            // Index access
+            part = `[${segment}]`;
+        }
+        else if (prev) {
+            // Object key access
+            part = `.${segment}`;
+        }
+        else {
+            // Top level key
+            part = segment;
+        }
+        return prev + part;
+    }, '');
+}

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export { Location, Meta, CustomValidator, CustomSanitizer, AlternativeMessageFactory, FieldMessageFactory, GroupedAlternativeMessageFactory, UnknownFieldMessageFactory, FieldValidationError, AlternativeValidationError, GroupedAlternativeValidationError, UnknownFieldsError, ValidationError, } from './base';
+export { ContextRunner, ValidationChain } from './chain';
+export * from './middlewares/exact';
+export * from './middlewares/one-of';
+export * from './middlewares/validation-chain-builders';
+export { checkSchema, Schema, ParamSchema } from './middlewares/schema';
+export * from './matched-data';
+export * from './validation-result';
+export * from './express-validator';

package/lib/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSchema = void 0;
+__exportStar(require("./middlewares/exact"), exports);
+__exportStar(require("./middlewares/one-of"), exports);
+__exportStar(require("./middlewares/validation-chain-builders"), exports);
+var schema_1 = require("./middlewares/schema");
+Object.defineProperty(exports, "checkSchema", { enumerable: true, get: function () { return schema_1.checkSchema; } });
+__exportStar(require("./matched-data"), exports);
+__exportStar(require("./validation-result"), exports);
+__exportStar(require("./express-validator"), exports);