@nestjs/common 11.1.15 → 12.0.0-alpha.0

package/pipes/parse-uuid.pipe.js

@@ -1,13 +1,10 @@
-"use strict";
 var ParseUUIDPipe_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParseUUIDPipe = void 0;
-const tslib_1 = require("tslib");
-const injectable_decorator_1 = require("../decorators/core/injectable.decorator");
-const optional_decorator_1 = require("../decorators/core/optional.decorator");
-const http_status_enum_1 = require("../enums/http-status.enum");
-const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
-const shared_utils_1 = require("../utils/shared.utils");
+import { __decorate, __metadata, __param } from "tslib";
+import { Injectable } from '../decorators/core/injectable.decorator.js';
+import { Optional } from '../decorators/core/optional.decorator.js';
+import { HttpStatus } from '../enums/http-status.enum.js';
+import { HttpErrorByCode, } from '../utils/http-error-by-code.util.js';
+import { isNil, isString } from '../utils/shared.utils.js';
 /**
  * Defines the built-in ParseUUID Pipe
  *
@@ -15,18 +12,29 @@ const shared_utils_1 = require("../utils/shared.utils");
  *
  * @publicApi
  */
-let ParseUUIDPipe = ParseUUIDPipe_1 = class ParseUUIDPipe {
+let ParseUUIDPipe = class ParseUUIDPipe {
+    static { ParseUUIDPipe_1 = this; }
+    options;
+    static uuidRegExps = {
+        3: /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
+        4: /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+        5: /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+        7: /^[0-9A-F]{8}-[0-9A-F]{4}-7[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+        all: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
+    };
+    version;
+    exceptionFactory;
     constructor(options) {
         this.options = options;
         options = options || {};
-        const { exceptionFactory, errorHttpStatusCode = http_status_enum_1.HttpStatus.BAD_REQUEST, version, } = options;
+        const { exceptionFactory, errorHttpStatusCode = HttpStatus.BAD_REQUEST, version, } = options;
         this.version = version;
         this.exceptionFactory =
             exceptionFactory ||
-                (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
+                (error => new HttpErrorByCode[errorHttpStatusCode](error));
     }
     async transform(value, metadata) {
-        if ((0, shared_utils_1.isNil)(value) && this.options?.optional) {
+        if (isNil(value) && this.options?.optional) {
             return value;
         }
         if (!this.isUUID(value, this.version)) {
@@ -35,23 +43,16 @@ let ParseUUIDPipe = ParseUUIDPipe_1 = class ParseUUIDPipe {
         return value;
     }
     isUUID(str, version = 'all') {
-        if (!(0, shared_utils_1.isString)(str)) {
+        if (!isString(str)) {
             throw this.exceptionFactory('The value passed as UUID is not a string');
         }
         const pattern = ParseUUIDPipe_1.uuidRegExps[version];
         return pattern?.test(str);
     }
 };
-exports.ParseUUIDPipe = ParseUUIDPipe;
-ParseUUIDPipe.uuidRegExps = {
-    3: /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
-    4: /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
-    5: /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
-    7: /^[0-9A-F]{8}-[0-9A-F]{4}-7[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
-    all: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
-};
-exports.ParseUUIDPipe = ParseUUIDPipe = ParseUUIDPipe_1 = tslib_1.__decorate([
-    (0, injectable_decorator_1.Injectable)(),
-    tslib_1.__param(0, (0, optional_decorator_1.Optional)()),
-    tslib_1.__metadata("design:paramtypes", [Object])
+ParseUUIDPipe = ParseUUIDPipe_1 = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __metadata("design:paramtypes", [Object])
 ], ParseUUIDPipe);
+export { ParseUUIDPipe };

package/pipes/standard-schema-validation.pipe.d.ts

@@ -0,0 +1,86 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface.js';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util.js';
+/**
+ * @publicApi
+ */
+export interface StandardSchemaValidationPipeOptions {
+    /**
+     * If true, the pipe will return the value produced by the schema
+     * (which may differ from the input if the schema coerces/transforms values).
+     * If false, the original input value is returned after successful validation.
+     * @default true
+     */
+    transform?: boolean;
+    /**
+     * If true, the pipe will also validate parameters decorated with custom decorators
+     * (created with `createParamDecorator`). When false, custom parameters are skipped.
+     * @default false
+     */
+    validateCustomDecorators?: boolean;
+    /**
+     * Options to pass to the standard schema `validate` function.
+     * These options are forwarded as the second argument to the schema's `~standard.validate` method.
+     */
+    validateOptions?: Record<string, unknown>;
+    /**
+     * The HTTP status code to be used in the response when the validation fails.
+     * @default HttpStatus.BAD_REQUEST
+     */
+    errorHttpStatusCode?: ErrorHttpStatusCode;
+    /**
+     * A factory function that returns an exception object to be thrown
+     * if validation fails.
+     * @param issues The issues returned by the standard schema validation
+     * @returns The exception object
+     */
+    exceptionFactory?: (issues: readonly StandardSchemaV1.Issue[]) => any;
+}
+/**
+ * Defines the built-in StandardSchemaValidation Pipe.
+ *
+ * Uses a standard schema object (conforming to the Standard Schema spec)
+ * attached to the parameter metadata to validate incoming values.
+ *
+ * @see [Standard Schema](https://github.com/standard-schema/standard-schema)
+ *
+ * @publicApi
+ */
+export declare class StandardSchemaValidationPipe implements PipeTransform {
+    protected readonly options?: StandardSchemaValidationPipeOptions | undefined;
+    protected isTransformEnabled: boolean;
+    protected validateCustomDecorators: boolean;
+    protected validateOptions: Record<string, unknown> | undefined;
+    protected exceptionFactory: (issues: readonly StandardSchemaV1.Issue[]) => any;
+    constructor(options?: StandardSchemaValidationPipeOptions | undefined);
+    /**
+     * Method that validates the incoming value against the standard schema
+     * provided in the parameter metadata.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    transform<T = any>(value: T, metadata: ArgumentMetadata): Promise<T>;
+    /**
+     * Determines whether validation should be performed for the given metadata.
+     * Skips validation for custom decorators unless `validateCustomDecorators` is enabled.
+     *
+     * @param metadata contains metadata about the currently processed route argument
+     * @returns `true` if validation should be performed
+     */
+    protected toValidate(metadata: ArgumentMetadata): boolean;
+    /**
+     * Validates a value against a standard schema.
+     * Can be overridden to customize validation behavior.
+     *
+     * @param value The value to validate
+     * @param schema The standard schema to validate against
+     * @param options Optional options forwarded to the schema's validate method
+     * @returns The validation result
+     */
+    protected validate<T = unknown>(value: unknown, schema: StandardSchemaV1, options?: Record<string, unknown>): Promise<StandardSchemaV1.Result<T>> | StandardSchemaV1.Result<T>;
+    /**
+     * Strips dangerous prototype pollution keys from an object.
+     */
+    protected stripProtoKeys(value: any): void;
+}

package/pipes/standard-schema-validation.pipe.js

@@ -0,0 +1,120 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { types } from 'util';
+import { Injectable } from '../decorators/core/injectable.decorator.js';
+import { Optional } from '../decorators/core/optional.decorator.js';
+import { HttpStatus } from '../enums/http-status.enum.js';
+import { HttpErrorByCode, } from '../utils/http-error-by-code.util.js';
+/**
+ * Built-in JavaScript types that should be excluded from prototype stripping
+ * to avoid conflicts with test frameworks like Jest's useFakeTimers
+ */
+const BUILT_IN_TYPES = [Date, RegExp, Error, Map, Set, WeakMap, WeakSet];
+/**
+ * Defines the built-in StandardSchemaValidation Pipe.
+ *
+ * Uses a standard schema object (conforming to the Standard Schema spec)
+ * attached to the parameter metadata to validate incoming values.
+ *
+ * @see [Standard Schema](https://github.com/standard-schema/standard-schema)
+ *
+ * @publicApi
+ */
+let StandardSchemaValidationPipe = class StandardSchemaValidationPipe {
+    options;
+    isTransformEnabled;
+    validateCustomDecorators;
+    validateOptions;
+    exceptionFactory;
+    constructor(options) {
+        this.options = options;
+        const { transform = true, validateCustomDecorators = false, validateOptions, exceptionFactory, errorHttpStatusCode = HttpStatus.BAD_REQUEST, } = options || {};
+        this.isTransformEnabled = transform;
+        this.validateCustomDecorators = validateCustomDecorators;
+        this.validateOptions = validateOptions;
+        this.exceptionFactory =
+            exceptionFactory ||
+                (issues => {
+                    const messages = issues.map(issue => issue.message);
+                    return new HttpErrorByCode[errorHttpStatusCode](messages);
+                });
+    }
+    /**
+     * Method that validates the incoming value against the standard schema
+     * provided in the parameter metadata.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    async transform(value, metadata) {
+        const schema = metadata.schema;
+        if (!schema || !this.toValidate(metadata)) {
+            return value;
+        }
+        this.stripProtoKeys(value);
+        const result = await this.validate(value, schema, this.validateOptions);
+        if (result.issues) {
+            throw this.exceptionFactory(result.issues);
+        }
+        return this.isTransformEnabled ? result.value : value;
+    }
+    /**
+     * Determines whether validation should be performed for the given metadata.
+     * Skips validation for custom decorators unless `validateCustomDecorators` is enabled.
+     *
+     * @param metadata contains metadata about the currently processed route argument
+     * @returns `true` if validation should be performed
+     */
+    toValidate(metadata) {
+        const { type } = metadata;
+        if (type === 'custom' && !this.validateCustomDecorators) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Validates a value against a standard schema.
+     * Can be overridden to customize validation behavior.
+     *
+     * @param value The value to validate
+     * @param schema The standard schema to validate against
+     * @param options Optional options forwarded to the schema's validate method
+     * @returns The validation result
+     */
+    validate(value, schema, options) {
+        return schema['~standard'].validate(value, options);
+    }
+    /**
+     * Strips dangerous prototype pollution keys from an object.
+     */
+    stripProtoKeys(value) {
+        if (value == null ||
+            typeof value !== 'object' ||
+            types.isTypedArray(value)) {
+            return;
+        }
+        if (BUILT_IN_TYPES.some(type => value instanceof type)) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const v of value) {
+                this.stripProtoKeys(v);
+            }
+            return;
+        }
+        delete value.__proto__;
+        delete value.prototype;
+        const constructorType = value?.constructor;
+        if (constructorType && !BUILT_IN_TYPES.includes(constructorType)) {
+            delete value.constructor;
+        }
+        for (const key in value) {
+            this.stripProtoKeys(value[key]);
+        }
+    }
+};
+StandardSchemaValidationPipe = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __metadata("design:paramtypes", [Object])
+], StandardSchemaValidationPipe);
+export { StandardSchemaValidationPipe };

package/pipes/validation.pipe.d.ts

@@ -1,11 +1,15 @@
-import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface';
-import { TransformerPackage } from '../interfaces/external/transformer-package.interface';
-import { ValidationError } from '../interfaces/external/validation-error.interface';
-import { ValidatorOptions } from '../interfaces/external/validator-options.interface';
-import { ValidatorPackage } from '../interfaces/external/validator-package.interface';
-import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
-import { Type } from '../interfaces/type.interface';
-import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
+import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface.js';
+import { TransformerPackage } from '../interfaces/external/transformer-package.interface.js';
+import { ValidationError } from '../interfaces/external/validation-error.interface.js';
+import { ValidatorOptions } from '../interfaces/external/validator-options.interface.js';
+import { ValidatorPackage } from '../interfaces/external/validator-package.interface.js';
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface.js';
+import { Type } from '../interfaces/type.interface.js';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util.js';
+/**
+ * @publicApi
+ */
+export type ValidationErrorFormat = 'list' | 'grouped';
 /**
  * @publicApi
  */
@@ -19,13 +23,25 @@ export interface ValidationPipeOptions extends ValidatorOptions {
     expectedType?: Type<any>;
     validatorPackage?: ValidatorPackage;
     transformerPackage?: TransformerPackage;
+    /**
+     * Specifies the format of validation error messages.
+     * - 'list': Returns an array of error message strings (default). The response message is `string[]`.
+     * - 'grouped': Returns an object with property paths as keys and arrays of unmodified error messages as values.
+     *   The response message is `Record<string, string[]>`. Custom messages defined in validation decorators
+     *   (e.g., `@IsNotEmpty({ message: 'Name is required' })`) are preserved without parent path prefixes.
+     *
+     * @remarks
+     * When using 'grouped', the `message` property in the error response changes from `string[]` to `Record<string, string[]>`.
+     * If you have exception filters or interceptors that assume `message` is always an array, they will need to be updated.
+     */
+    errorFormat?: ValidationErrorFormat;
 }
 /**
  * @see [Validation](https://docs.nestjs.com/techniques/validation)
  *
  * @publicApi
  */
-export declare class ValidationPipe implements PipeTransform<any> {
+export declare class ValidationPipe implements PipeTransform {
     protected isTransformEnabled: boolean;
     protected isDetailedOutputDisabled?: boolean;
     protected validatorOptions: ValidatorOptions;
@@ -34,18 +50,20 @@ export declare class ValidationPipe implements PipeTransform<any> {
     protected expectedType: Type<any> | undefined;
     protected exceptionFactory: (errors: ValidationError[]) => any;
     protected validateCustomDecorators: boolean;
+    protected errorFormat: ValidationErrorFormat;
     constructor(options?: ValidationPipeOptions);
-    protected loadValidator(validatorPackage?: ValidatorPackage): ValidatorPackage;
-    protected loadTransformer(transformerPackage?: TransformerPackage): TransformerPackage;
-    transform(value: any, metadata: ArgumentMetadata): Promise<any>;
+    protected loadValidator(validatorPackage?: ValidatorPackage): ValidatorPackage | Promise<ValidatorPackage>;
+    protected loadTransformer(transformerPackage?: TransformerPackage): TransformerPackage | Promise<TransformerPackage>;
+    transform(value: unknown, metadata: ArgumentMetadata): Promise<any>;
     createExceptionFactory(): (validationErrors?: ValidationError[]) => unknown;
     protected toValidate(metadata: ArgumentMetadata): boolean;
-    protected transformPrimitive(value: any, metadata: ArgumentMetadata): any;
-    protected toEmptyIfNil<T = any, R = T>(value: T, metatype: Type<unknown> | object): R | object | string;
+    protected transformPrimitive(value: unknown, metadata: ArgumentMetadata): unknown;
+    protected toEmptyIfNil<T = any, R = T>(value: unknown, metatype: Type<unknown> | object): R | object | string;
     protected stripProtoKeys(value: any): void;
     protected isPrimitive(value: unknown): boolean;
     protected validate(object: object, validatorOptions?: ValidatorOptions): Promise<ValidationError[]> | ValidationError[];
     protected flattenValidationErrors(validationErrors: ValidationError[]): string[];
+    protected groupValidationErrors(validationErrors: ValidationError[], parentPath?: string): Record<string, string[]>;
     protected mapChildrenToValidationErrors(error: ValidationError, parentPath?: string): ValidationError[];
     protected prependConstraintsWithParentProp(parentPath: string, error: ValidationError): ValidationError;
 }

package/pipes/validation.pipe.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationPipe = void 0;
-const tslib_1 = require("tslib");
-const iterare_1 = require("iterare");
-const util_1 = require("util");
-const decorators_1 = require("../decorators");
-const core_1 = require("../decorators/core");
-const http_status_enum_1 = require("../enums/http-status.enum");
-const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
-const load_package_util_1 = require("../utils/load-package.util");
-const shared_utils_1 = require("../utils/shared.utils");
+import { __decorate, __metadata, __param } from "tslib";
+import { iterate } from 'iterare';
+import { types } from 'util';
+import { Injectable } from '../decorators/core/index.js';
+import { Optional } from '../decorators/index.js';
+import { HttpStatus } from '../enums/http-status.enum.js';
+import { HttpErrorByCode, } from '../utils/http-error-by-code.util.js';
+import { loadPackage } from '../utils/load-package.util.js';
+import { isNil, isUndefined } from '../utils/shared.utils.js';
 let classValidator = {};
 let classTransformer = {};
 /**
@@ -23,17 +20,27 @@ const BUILT_IN_TYPES = [Date, RegExp, Error, Map, Set, WeakMap, WeakSet];
  * @publicApi
  */
 let ValidationPipe = class ValidationPipe {
+    isTransformEnabled;
+    isDetailedOutputDisabled;
+    validatorOptions;
+    transformOptions;
+    errorHttpStatusCode;
+    expectedType;
+    exceptionFactory;
+    validateCustomDecorators;
+    errorFormat;
     constructor(options) {
         options = options || {};
-        const { transform, disableErrorMessages, errorHttpStatusCode, expectedType, transformOptions, validateCustomDecorators, ...validatorOptions } = options;
+        const { transform, disableErrorMessages, errorHttpStatusCode, expectedType, transformOptions, validateCustomDecorators, errorFormat, ...validatorOptions } = options;
         // @see [https://github.com/nestjs/nest/issues/10683#issuecomment-1413690508](https://github.com/nestjs/nest/issues/10683#issuecomment-1413690508)
         this.validatorOptions = { forbidUnknownValues: false, ...validatorOptions };
         this.isTransformEnabled = !!transform;
         this.transformOptions = transformOptions;
         this.isDetailedOutputDisabled = disableErrorMessages;
         this.validateCustomDecorators = validateCustomDecorators || false;
-        this.errorHttpStatusCode = errorHttpStatusCode || http_status_enum_1.HttpStatus.BAD_REQUEST;
+        this.errorHttpStatusCode = errorHttpStatusCode || HttpStatus.BAD_REQUEST;
         this.expectedType = expectedType;
+        this.errorFormat = errorFormat || 'list';
         this.exceptionFactory =
             options.exceptionFactory || this.createExceptionFactory();
         classValidator = this.loadValidator(options.validatorPackage);
@@ -41,11 +48,11 @@ let ValidationPipe = class ValidationPipe {
     }
     loadValidator(validatorPackage) {
         return (validatorPackage ??
-            (0, load_package_util_1.loadPackage)('class-validator', 'ValidationPipe', () => require('class-validator')));
+            loadPackage('class-validator', 'ValidationPipe', () => import('class-validator')));
     }
     loadTransformer(transformerPackage) {
         return (transformerPackage ??
-            (0, load_package_util_1.loadPackage)('class-transformer', 'ValidationPipe', () => require('class-transformer')));
+            loadPackage('class-transformer', 'ValidationPipe', () => import('class-transformer')));
     }
     async transform(value, metadata) {
         if (this.expectedType) {
@@ -57,6 +64,8 @@ let ValidationPipe = class ValidationPipe {
                 ? this.transformPrimitive(value, metadata)
                 : value;
         }
+        classValidator = (await classValidator);
+        classTransformer = (await classTransformer);
         const originalValue = value;
         value = this.toEmptyIfNil(value, metatype);
         const isNil = value !== originalValue;
@@ -106,10 +115,16 @@ let ValidationPipe = class ValidationPipe {
     createExceptionFactory() {
         return (validationErrors = []) => {
             if (this.isDetailedOutputDisabled) {
-                return new http_error_by_code_util_1.HttpErrorByCode[this.errorHttpStatusCode]();
+                return new HttpErrorByCode[this.errorHttpStatusCode]();
+            }
+            if (this.errorFormat === 'grouped') {
+                const errors = this.groupValidationErrors(validationErrors);
+                return new HttpErrorByCode[this.errorHttpStatusCode]({
+                    message: errors,
+                });
             }
             const errors = this.flattenValidationErrors(validationErrors);
-            return new http_error_by_code_util_1.HttpErrorByCode[this.errorHttpStatusCode](errors);
+            return new HttpErrorByCode[this.errorHttpStatusCode](errors);
         };
     }
     toValidate(metadata) {
@@ -118,7 +133,7 @@ let ValidationPipe = class ValidationPipe {
             return false;
         }
         const types = [String, Boolean, Number, Array, Object, Buffer, Date];
-        return !types.some(t => metatype === t) && !(0, shared_utils_1.isNil)(metatype);
+        return !types.some(t => metatype === t) && !isNil(metatype);
     }
     transformPrimitive(value, metadata) {
         if (!metadata.data) {
@@ -130,7 +145,7 @@ let ValidationPipe = class ValidationPipe {
             return value;
         }
         if (metatype === Boolean) {
-            if ((0, shared_utils_1.isUndefined)(value)) {
+            if (isUndefined(value)) {
                 // This is an workaround to deal with optional boolean values since
                 // optional booleans shouldn't be parsed to a valid boolean when
                 // they were not defined
@@ -140,7 +155,7 @@ let ValidationPipe = class ValidationPipe {
             return value === true || value === 'true';
         }
         if (metatype === Number) {
-            if ((0, shared_utils_1.isUndefined)(value)) {
+            if (isUndefined(value)) {
                 // This is a workaround to deal with optional numeric values since
                 // optional numerics shouldn't be parsed to a valid number when
                 // they were not defined
@@ -148,13 +163,13 @@ let ValidationPipe = class ValidationPipe {
             }
             return +value;
         }
-        if (metatype === String && !(0, shared_utils_1.isUndefined)(value)) {
+        if (metatype === String && !isUndefined(value)) {
             return String(value);
         }
         return value;
     }
     toEmptyIfNil(value, metatype) {
-        if (!(0, shared_utils_1.isNil)(value)) {
+        if (!isNil(value)) {
             return value;
         }
         if (typeof metatype === 'function' ||
@@ -170,7 +185,7 @@ let ValidationPipe = class ValidationPipe {
     stripProtoKeys(value) {
         if (value == null ||
             typeof value !== 'object' ||
-            util_1.types.isTypedArray(value)) {
+            types.isTypedArray(value)) {
             return;
         }
         // Skip built-in JavaScript primitives to avoid Jest useFakeTimers conflicts
@@ -202,7 +217,7 @@ let ValidationPipe = class ValidationPipe {
         return classValidator.validate(object, validatorOptions);
     }
     flattenValidationErrors(validationErrors) {
-        return (0, iterare_1.iterate)(validationErrors)
+        return iterate(validationErrors)
             .map(error => this.mapChildrenToValidationErrors(error))
             .flatten()
             .filter(item => !!item.constraints)
@@ -210,6 +225,21 @@ let ValidationPipe = class ValidationPipe {
             .flatten()
             .toArray();
     }
+    groupValidationErrors(validationErrors, parentPath) {
+        const result = {};
+        for (const error of validationErrors) {
+            const path = parentPath
+                ? `${parentPath}.${error.property}`
+                : error.property;
+            if (error.constraints) {
+                result[path] = Object.values(error.constraints);
+            }
+            if (error.children && error.children.length) {
+                Object.assign(result, this.groupValidationErrors(error.children, path));
+            }
+        }
+        return result;
+    }
     mapChildrenToValidationErrors(error, parentPath) {
         if (!(error.children && error.children.length)) {
             return [error];
@@ -237,9 +267,9 @@ let ValidationPipe = class ValidationPipe {
         };
     }
 };
-exports.ValidationPipe = ValidationPipe;
-exports.ValidationPipe = ValidationPipe = tslib_1.__decorate([
-    (0, core_1.Injectable)(),
-    tslib_1.__param(0, (0, decorators_1.Optional)()),
-    tslib_1.__metadata("design:paramtypes", [Object])
+ValidationPipe = __decorate([
+    Injectable(),
+    __param(0, Optional()),
+    __metadata("design:paramtypes", [Object])
 ], ValidationPipe);
+export { ValidationPipe };

package/serializer/class-serializer.constants.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CLASS_SERIALIZER_OPTIONS = void 0;
-exports.CLASS_SERIALIZER_OPTIONS = 'class_serializer:options';
+export const CLASS_SERIALIZER_OPTIONS = 'class_serializer:options';

package/serializer/class-serializer.interceptor.d.ts

@@ -1,8 +1,8 @@
-import { ClassSerializerContextOptions } from './class-serializer.interfaces';
 import { Observable } from 'rxjs';
-import { CallHandler, ExecutionContext, NestInterceptor } from '../interfaces';
-import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface';
-import { TransformerPackage } from '../interfaces/external/transformer-package.interface';
+import { ClassTransformOptions } from '../interfaces/external/class-transform-options.interface.js';
+import { TransformerPackage } from '../interfaces/external/transformer-package.interface.js';
+import { CallHandler, ExecutionContext, NestInterceptor } from '../interfaces/index.js';
+import { ClassSerializerContextOptions } from './class-serializer.interfaces.js';
 export interface PlainLiteralObject {
     [key: string]: any;
 }
@@ -19,7 +19,7 @@ export declare class ClassSerializerInterceptor implements NestInterceptor {
     protected readonly reflector: any;
     protected readonly defaultOptions: ClassSerializerInterceptorOptions;
     constructor(reflector: any, defaultOptions?: ClassSerializerInterceptorOptions);
-    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>>;
     /**
      * Serializes responses that are non-null objects nor streamable files.
      */