@nestjs/common 8.4.7 → 9.0.0

package/module-utils/configurable-module.builder.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurableModuleBuilder = void 0;
+const logger_service_1 = require("../services/logger.service");
+const random_string_generator_util_1 = require("../utils/random-string-generator.util");
+const constants_1 = require("./constants");
+const generate_options_injection_token_util_1 = require("./utils/generate-options-injection-token.util");
+/**
+ * Factory that lets you create configurable modules and
+ * provides a way to reduce the majority of dynamic module boilerplate.
+ *
+ * @publicApi
+ */
+class ConfigurableModuleBuilder {
+    constructor(options = {}, parentBuilder) {
+        this.options = options;
+        this.logger = new logger_service_1.Logger(ConfigurableModuleBuilder.name);
+        if (parentBuilder) {
+            this.staticMethodKey = parentBuilder.staticMethodKey;
+            this.factoryClassMethodKey =
+                parentBuilder.factoryClassMethodKey;
+            this.transformModuleDefinition = parentBuilder.transformModuleDefinition;
+            this.extras = parentBuilder.extras;
+        }
+    }
+    /**
+     * Registers the "extras" object (a set of extra options that can be used to modify the dynamic module definition).
+     * Values you specify within the "extras" object will be used as default values (that can be overriden by module consumers).
+     *
+     * This method also applies the so-called "module definition transform function" that takes the auto-generated
+     * dynamic module object ("DynamicModule") and the actual consumer "extras" object as input parameters.
+     * The "extras" object consists of values explicitly specified by module consumers and default values.
+     *
+     * @example
+     * ```typescript
+     * .setExtras<{ isGlobal?: boolean }>({ isGlobal: false }, (definition, extras) =>
+     *    ({ ...definition, global: extras.isGlobal })
+     * )
+     * ```
+     */
+    setExtras(extras, transformDefinition) {
+        const builder = new ConfigurableModuleBuilder(this.options, this);
+        builder.extras = extras;
+        builder.transformModuleDefinition = transformDefinition;
+        return builder;
+    }
+    /**
+     * Dynamic modules must expose public static methods that let you pass in
+     * configuration parameters (control the module's behavior from the outside).
+     * Some frequently used names that you may have seen in other modules are:
+     * "forRoot", "forFeature", "register", "configure".
+     *
+     * This method "setClassMethodName" lets you specify the name of the
+     * method that will be auto-generated.
+     *
+     * @param key name of the method
+     */
+    setClassMethodName(key) {
+        const builder = new ConfigurableModuleBuilder(this.options, this);
+        builder.staticMethodKey = key;
+        return builder;
+    }
+    /**
+     * Asynchronously configured modules (that rely on other modules, i.e. "ConfigModule")
+     * let you pass the configuration factory class that will be registered and instantiated as a provider.
+     * This provider then will be used to retrieve the module's configuration. To provide the configuration,
+     * the corresponding factory method must be implemented.
+     *
+     * This method ("setFactoryMethodName") lets you control what method name will have to be
+     * implemented by the config factory (default is "create").
+     *
+     * @param key name of the method
+     */
+    setFactoryMethodName(key) {
+        const builder = new ConfigurableModuleBuilder(this.options, this);
+        builder.factoryClassMethodKey = key;
+        return builder;
+    }
+    /**
+     * Returns an object consisting of multiple properties that lets you
+     * easily construct dynamic configurable modules. See "ConfigurableModuleHost" interface for more details.
+     */
+    build() {
+        var _a, _b, _c, _d;
+        var _e;
+        (_a = this.staticMethodKey) !== null && _a !== void 0 ? _a : (this.staticMethodKey = constants_1.DEFAULT_METHOD_KEY);
+        (_b = this.factoryClassMethodKey) !== null && _b !== void 0 ? _b : (this.factoryClassMethodKey = constants_1.DEFAULT_FACTORY_CLASS_METHOD_KEY);
+        (_c = (_e = this.options).optionsInjectionToken) !== null && _c !== void 0 ? _c : (_e.optionsInjectionToken = this.options.moduleName
+            ? this.constructInjectionTokenString()
+            : (0, generate_options_injection_token_util_1.generateOptionsInjectionToken)());
+        (_d = this.transformModuleDefinition) !== null && _d !== void 0 ? _d : (this.transformModuleDefinition = definition => definition);
+        return {
+            ConfigurableModuleClass: this.createConfigurableModuleCls(),
+            MODULE_OPTIONS_TOKEN: this.options.optionsInjectionToken,
+            ASYNC_OPTIONS_TYPE: this.createTypeProxy('ASYNC_OPTIONS_TYPE'),
+            OPTIONS_TYPE: this.createTypeProxy('OPTIONS_TYPE'),
+        };
+    }
+    constructInjectionTokenString() {
+        const moduleNameInSnakeCase = this.options.moduleName
+            .trim()
+            .split(/(?=[A-Z])/)
+            .join('_')
+            .toUpperCase();
+        return `${moduleNameInSnakeCase}_MODULE_OPTIONS`;
+    }
+    createConfigurableModuleCls() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        const asyncMethodKey = this.staticMethodKey + constants_1.ASYNC_METHOD_SUFFIX;
+        class InternalModuleClass {
+            static [self.staticMethodKey](options) {
+                const providers = [
+                    {
+                        provide: self.options.optionsInjectionToken,
+                        useValue: this.omitExtras(options, self.extras),
+                    },
+                ];
+                if (self.options.alwaysTransient) {
+                    providers.push({
+                        provide: constants_1.CONFIGURABLE_MODULE_ID,
+                        useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
+                    });
+                }
+                return self.transformModuleDefinition({
+                    module: this,
+                    providers,
+                }, options);
+            }
+            static [asyncMethodKey](options) {
+                const providers = this.createAsyncProviders(options);
+                if (self.options.alwaysTransient) {
+                    providers.push({
+                        provide: constants_1.CONFIGURABLE_MODULE_ID,
+                        useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
+                    });
+                }
+                return self.transformModuleDefinition({
+                    module: this,
+                    imports: options.imports || [],
+                    providers,
+                }, options);
+            }
+            static omitExtras(input, extras) {
+                if (!extras) {
+                    return input;
+                }
+                const moduleOptions = {};
+                const extrasKeys = Object.keys(extras);
+                Object.keys(input)
+                    .filter(key => !extrasKeys.includes(key))
+                    .forEach(key => {
+                    moduleOptions[key] = input[key];
+                });
+                return moduleOptions;
+            }
+            static createAsyncProviders(options) {
+                if (options.useExisting || options.useFactory) {
+                    return [this.createAsyncOptionsProvider(options)];
+                }
+                return [
+                    this.createAsyncOptionsProvider(options),
+                    {
+                        provide: options.useClass,
+                        useClass: options.useClass,
+                    },
+                ];
+            }
+            static createAsyncOptionsProvider(options) {
+                if (options.useFactory) {
+                    return {
+                        provide: self.options.optionsInjectionToken,
+                        useFactory: options.useFactory,
+                        inject: options.inject || [],
+                    };
+                }
+                return {
+                    provide: self.options.optionsInjectionToken,
+                    useFactory: async (optionsFactory) => await optionsFactory[self.factoryClassMethodKey](),
+                    inject: [options.useExisting || options.useClass],
+                };
+            }
+        }
+        return InternalModuleClass;
+    }
+    createTypeProxy(typeName) {
+        const proxy = new Proxy({}, {
+            get: () => {
+                throw new Error(`"${typeName}" is not supposed to be used as a value.`);
+            },
+        });
+        return proxy;
+    }
+}
+exports.ConfigurableModuleBuilder = ConfigurableModuleBuilder;

package/module-utils/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_METHOD_KEY = "register";
+export declare const DEFAULT_FACTORY_CLASS_METHOD_KEY = "create";
+export declare const ASYNC_METHOD_SUFFIX = "Async";
+export declare const CONFIGURABLE_MODULE_ID = "CONFIGURABLE_MODULE_ID";

package/module-utils/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIGURABLE_MODULE_ID = exports.ASYNC_METHOD_SUFFIX = exports.DEFAULT_FACTORY_CLASS_METHOD_KEY = exports.DEFAULT_METHOD_KEY = void 0;
+exports.DEFAULT_METHOD_KEY = 'register';
+exports.DEFAULT_FACTORY_CLASS_METHOD_KEY = 'create';
+exports.ASYNC_METHOD_SUFFIX = 'Async';
+exports.CONFIGURABLE_MODULE_ID = 'CONFIGURABLE_MODULE_ID';

package/module-utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './configurable-module.builder';
+export * from './interfaces';

package/{http → module-utils}/index.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./http.module"), exports);
-tslib_1.__exportStar(require("./http.service"), exports);
+tslib_1.__exportStar(require("./configurable-module.builder"), exports);
 tslib_1.__exportStar(require("./interfaces"), exports);

package/module-utils/interfaces/configurable-module-async-options.interface.d.ts

@@ -0,0 +1,36 @@
+import { FactoryProvider, ModuleMetadata, Type } from '../../interfaces';
+import { DEFAULT_FACTORY_CLASS_METHOD_KEY } from '../constants';
+/**
+ * Interface that must be implemented by the module options factory class.
+ * Method key varies depending on the "FactoryClassMethodKey" type argument.
+ *
+ * @publicApi
+ */
+export declare type ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey extends string> = Record<`${FactoryClassMethodKey}`, () => Promise<ModuleOptions> | ModuleOptions>;
+/**
+ * Interface that represents the module async options object
+ * Factory method name varies depending on the "FactoryClassMethodKey" type argument.
+ *
+ * @publicApi
+ */
+export interface ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY> extends Pick<ModuleMetadata, 'imports'> {
+    /**
+     * Injection token resolving to an existing provider. The provider must implement
+     * the corresponding interface.
+     */
+    useExisting?: Type<ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey>>;
+    /**
+     * Injection token resolving to a class that will be instantiated as a provider.
+     * The class must implement the corresponding interface.
+     */
+    useClass?: Type<ConfigurableModuleOptionsFactory<ModuleOptions, FactoryClassMethodKey>>;
+    /**
+     * Function returning options (or a Promise resolving to options) to configure the
+     * cache module.
+     */
+    useFactory?: (...args: unknown[]) => Promise<ModuleOptions> | ModuleOptions;
+    /**
+     * Dependencies that a Factory may inject.
+     */
+    inject?: FactoryProvider['inject'];
+}

package/module-utils/interfaces/configurable-module-cls.interface.d.ts

@@ -0,0 +1,13 @@
+import { DynamicModule } from '../../interfaces';
+import { DEFAULT_FACTORY_CLASS_METHOD_KEY, DEFAULT_METHOD_KEY } from '../constants';
+import { ConfigurableModuleAsyncOptions } from './configurable-module-async-options.interface';
+/**
+ * Class that represents a blueprint/prototype for a configurable Nest module.
+ * This class provides static methods for constructing dynamic modules. Their names
+ * can be controlled through the "MethodKey" type argument.
+ *
+ * @publicApi
+ */
+export declare type ConfigurableModuleCls<ModuleOptions, MethodKey extends string = typeof DEFAULT_METHOD_KEY, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY, ExtraModuleDefinitionOptions = {}> = {
+    new (): any;
+} & Record<`${MethodKey}`, (options: ModuleOptions & ExtraModuleDefinitionOptions) => DynamicModule> & Record<`${MethodKey}Async`, (options: ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey> & ExtraModuleDefinitionOptions) => DynamicModule>;

package/module-utils/interfaces/configurable-module-cls.interface.js

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

package/module-utils/interfaces/configurable-module-host.interface.d.ts

@@ -0,0 +1,62 @@
+import { ConfigurableModuleAsyncOptions } from './configurable-module-async-options.interface';
+import { ConfigurableModuleCls } from './configurable-module-cls.interface';
+/**
+ * Configurable module host. See properties for more details
+ *
+ * @publicApi
+ */
+export interface ConfigurableModuleHost<ModuleOptions = Record<string, unknown>, MethodKey extends string = string, FactoryClassMethodKey extends string = string, ExtraModuleDefinitionOptions = {}> {
+    /**
+     * Class that represents a blueprint/prototype for a configurable Nest module.
+     * This class provides static methods for constructing dynamic modules. Their names
+     * can be controlled through the "MethodKey" type argument.
+     *
+     * Your module class should inherit from this class to make the static methods available.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  // ...
+     * }
+     * ```
+     */
+    ConfigurableModuleClass: ConfigurableModuleCls<ModuleOptions, MethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Module options provider token. Can be used to inject the "options object" to
+     * providers registered within the host module.
+     */
+    MODULE_OPTIONS_TOKEN: string | symbol;
+    /**
+     * Can be used to auto-infer the compound "async module options" type.
+     * Note: this property is not supposed to be used as a value.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  static module = initializer(IntegrationModule);
+     *
+     * static registerAsync(options: typeof ASYNC_OPTIONS_TYPE): DynamicModule {
+     *  return super.registerAsync(options);
+     * }
+     * ```
+     */
+    ASYNC_OPTIONS_TYPE: ConfigurableModuleAsyncOptions<ModuleOptions, FactoryClassMethodKey> & ExtraModuleDefinitionOptions;
+    /**
+     * Can be used to auto-infer the compound "module options" type (options interface + extra module definition options).
+     * Note: this property is not supposed to be used as a value.
+     *
+     * @example
+     * ```typescript
+     * @Module({})
+     * class IntegrationModule extends ConfigurableModuleCls {
+     *  static module = initializer(IntegrationModule);
+     *
+     * static register(options: typeof OPTIONS_TYPE): DynamicModule {
+     *  return super.register(options);
+     * }
+     * ```
+     */
+    OPTIONS_TYPE: ModuleOptions & ExtraModuleDefinitionOptions;
+}

package/module-utils/interfaces/configurable-module-host.interface.js

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

package/module-utils/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './configurable-module-async-options.interface';
+export * from './configurable-module-cls.interface';
+export * from './configurable-module-host.interface';

package/module-utils/interfaces/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./configurable-module-async-options.interface"), exports);
+tslib_1.__exportStar(require("./configurable-module-cls.interface"), exports);
+tslib_1.__exportStar(require("./configurable-module-host.interface"), exports);

package/module-utils/utils/generate-options-injection-token.util.d.ts

@@ -0,0 +1 @@
+export declare function generateOptionsInjectionToken(): string;

package/module-utils/utils/generate-options-injection-token.util.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOptionsInjectionToken = void 0;
+const random_string_generator_util_1 = require("../../utils/random-string-generator.util");
+function generateOptionsInjectionToken() {
+    const hash = (0, random_string_generator_util_1.randomStringGenerator)();
+    return `CONFIGURABLE_MODULE_OPTIONS[${hash}]`;
+}
+exports.generateOptionsInjectionToken = generateOptionsInjectionToken;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/common",
-  "version": "8.4.7",
+  "version": "9.0.0",
   "description": "Nest - modern, fast, powerful node.js web framework (@common)",
   "author": "Kamil Mysliwiec",
   "homepage": "https://nestjs.com",
@@ -17,7 +17,6 @@
   },
   "license": "MIT",
   "dependencies": {
-    "axios": "0.27.2",
     "iterare": "1.2.1",
     "tslib": "2.4.0",
     "uuid": "8.3.2"

package/pipes/file/file-type.validator.d.ts

@@ -0,0 +1,19 @@
+import { FileValidator } from './file-validator.interface';
+export declare type FileTypeValidatorOptions = {
+    fileType: string | RegExp;
+};
+/**
+ * Defines the built-in FileType File Validator. It validates incoming files mime-type
+ * matching a string or a regular expression. Note that this validator uses a naive strategy
+ * to check the mime-type and could be fooled if the client provided a file with renamed extension.
+ * (for instance, renaming a 'malicious.bat' to 'malicious.jpeg'). To handle such security issues
+ * with more reliability, consider checking against the file's [magic-numbers](https://en.wikipedia.org/wiki/Magic_number_%28programming%29)
+ *
+ * @see [File Validators](https://docs.nestjs.com/techniques/file-upload#validators)
+ *
+ * @publicApi
+ */
+export declare class FileTypeValidator extends FileValidator<FileTypeValidatorOptions> {
+    buildErrorMessage(): string;
+    isValid(file: any): boolean;
+}

package/pipes/file/file-type.validator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileTypeValidator = void 0;
+const file_validator_interface_1 = require("./file-validator.interface");
+/**
+ * Defines the built-in FileType File Validator. It validates incoming files mime-type
+ * matching a string or a regular expression. Note that this validator uses a naive strategy
+ * to check the mime-type and could be fooled if the client provided a file with renamed extension.
+ * (for instance, renaming a 'malicious.bat' to 'malicious.jpeg'). To handle such security issues
+ * with more reliability, consider checking against the file's [magic-numbers](https://en.wikipedia.org/wiki/Magic_number_%28programming%29)
+ *
+ * @see [File Validators](https://docs.nestjs.com/techniques/file-upload#validators)
+ *
+ * @publicApi
+ */
+class FileTypeValidator extends file_validator_interface_1.FileValidator {
+    buildErrorMessage() {
+        return `Validation failed (expected type is ${this.validationOptions.fileType})`;
+    }
+    isValid(file) {
+        if (!this.validationOptions) {
+            return true;
+        }
+        if (!file.mimetype) {
+            return false;
+        }
+        return Boolean(file.mimetype.match(this.validationOptions.fileType));
+    }
+}
+exports.FileTypeValidator = FileTypeValidator;

package/pipes/file/file-validator.interface.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Interface describing FileValidators, which can be added to a {@link ParseFilePipe}.
+ */
+export declare abstract class FileValidator<TValidationOptions = Record<string, any>> {
+    protected readonly validationOptions: TValidationOptions;
+    constructor(validationOptions: TValidationOptions);
+    /**
+     * Indicates if this file should be considered valid, according to the options passed in the constructor.
+     * @param file the file from the request object
+     */
+    abstract isValid(file?: any): boolean | Promise<boolean>;
+    /**
+     * Builds an error message in case the validation fails.
+     * @param file the file from the request object
+     */
+    abstract buildErrorMessage(file: any): string;
+}

package/pipes/file/file-validator.interface.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileValidator = void 0;
+/**
+ * Interface describing FileValidators, which can be added to a {@link ParseFilePipe}.
+ */
+class FileValidator {
+    constructor(validationOptions) {
+        this.validationOptions = validationOptions;
+    }
+}
+exports.FileValidator = FileValidator;

package/pipes/file/index.d.ts

@@ -0,0 +1,6 @@
+export * from './file-type.validator';
+export * from './file-validator.interface';
+export * from './max-file-size.validator';
+export * from './parse-file-options.interface';
+export * from './parse-file.pipe';
+export * from './parse-file-pipe.builder';

package/pipes/file/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./file-type.validator"), exports);
+tslib_1.__exportStar(require("./file-validator.interface"), exports);
+tslib_1.__exportStar(require("./max-file-size.validator"), exports);
+tslib_1.__exportStar(require("./parse-file-options.interface"), exports);
+tslib_1.__exportStar(require("./parse-file.pipe"), exports);
+tslib_1.__exportStar(require("./parse-file-pipe.builder"), exports);

package/pipes/file/max-file-size.validator.d.ts

@@ -0,0 +1,15 @@
+import { FileValidator } from './file-validator.interface';
+export declare type MaxFileSizeValidatorOptions = {
+    maxSize: number;
+};
+/**
+ * Defines the built-in MaxSize File Validator
+ *
+ * @see [File Validators](https://docs.nestjs.com/techniques/file-upload#validators)
+ *
+ * @publicApi
+ */
+export declare class MaxFileSizeValidator extends FileValidator<MaxFileSizeValidatorOptions> {
+    buildErrorMessage(): string;
+    isValid(file: any): boolean;
+}

package/pipes/file/max-file-size.validator.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxFileSizeValidator = void 0;
+const file_validator_interface_1 = require("./file-validator.interface");
+/**
+ * Defines the built-in MaxSize File Validator
+ *
+ * @see [File Validators](https://docs.nestjs.com/techniques/file-upload#validators)
+ *
+ * @publicApi
+ */
+class MaxFileSizeValidator extends file_validator_interface_1.FileValidator {
+    buildErrorMessage() {
+        return `Validation failed (expected size is less than ${this.validationOptions.maxSize})`;
+    }
+    isValid(file) {
+        if (!this.validationOptions) {
+            return true;
+        }
+        return file.size < this.validationOptions.maxSize;
+    }
+}
+exports.MaxFileSizeValidator = MaxFileSizeValidator;

package/pipes/file/parse-file-options.interface.d.ts

@@ -0,0 +1,7 @@
+import { ErrorHttpStatusCode } from '../../utils/http-error-by-code.util';
+import { FileValidator } from './file-validator.interface';
+export interface ParseFileOptions {
+    validators?: FileValidator[];
+    errorHttpStatusCode?: ErrorHttpStatusCode;
+    exceptionFactory?: (error: string) => any;
+}

package/pipes/file/parse-file-options.interface.js

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

package/pipes/file/parse-file-pipe.builder.d.ts

@@ -0,0 +1,10 @@
+import { FileTypeValidatorOptions } from './file-type.validator';
+import { MaxFileSizeValidatorOptions } from './max-file-size.validator';
+import { ParseFileOptions } from './parse-file-options.interface';
+import { ParseFilePipe } from './parse-file.pipe';
+export declare class ParseFilePipeBuilder {
+    private validators;
+    addMaxSizeValidator(options: MaxFileSizeValidatorOptions): this;
+    addFileTypeValidator(options: FileTypeValidatorOptions): this;
+    build(additionalOptions?: Omit<ParseFileOptions, 'validators'>): ParseFilePipe;
+}

package/pipes/file/parse-file-pipe.builder.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseFilePipeBuilder = void 0;
+const file_type_validator_1 = require("./file-type.validator");
+const max_file_size_validator_1 = require("./max-file-size.validator");
+const parse_file_pipe_1 = require("./parse-file.pipe");
+class ParseFilePipeBuilder {
+    constructor() {
+        this.validators = [];
+    }
+    addMaxSizeValidator(options) {
+        this.validators.push(new max_file_size_validator_1.MaxFileSizeValidator(options));
+        return this;
+    }
+    addFileTypeValidator(options) {
+        this.validators.push(new file_type_validator_1.FileTypeValidator(options));
+        return this;
+    }
+    build(additionalOptions) {
+        const parseFilePipe = new parse_file_pipe_1.ParseFilePipe(Object.assign(Object.assign({}, additionalOptions), { validators: this.validators }));
+        this.validators = [];
+        return parseFilePipe;
+    }
+}
+exports.ParseFilePipeBuilder = ParseFilePipeBuilder;

package/pipes/file/parse-file.pipe.d.ts

@@ -0,0 +1,25 @@
+import { PipeTransform } from '../../interfaces/features/pipe-transform.interface';
+import { ParseFileOptions } from './parse-file-options.interface';
+import { FileValidator } from './file-validator.interface';
+/**
+ * Defines the built-in ParseFile Pipe. This pipe can be used to validate incoming files
+ * with `@UploadedFile()` decorator. You can use either other specific built-in validators
+ * or provide one of your own, simply implementing it through {@link FileValidator}
+ * interface and adding it to ParseFilePipe's constructor.
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+export declare class ParseFilePipe implements PipeTransform<any> {
+    protected exceptionFactory: (error: string) => any;
+    private readonly validators;
+    constructor(options?: ParseFileOptions);
+    transform(value: any): Promise<any>;
+    protected validate(file: any): Promise<any>;
+    private validateOrThrow;
+    /**
+     * @returns list of validators used in this pipe.
+     */
+    getValidators(): FileValidator<Record<string, any>>[];
+}