@nestjs/common 8.4.6 → 9.0.0-next.1

package/cache/cache.constants.d.ts

@@ -1,4 +1,3 @@
 export declare const CACHE_MANAGER = "CACHE_MANAGER";
-export declare const CACHE_MODULE_OPTIONS = "CACHE_MODULE_OPTIONS";
 export declare const CACHE_KEY_METADATA = "cache_module:cache_key";
 export declare const CACHE_TTL_METADATA = "cache_module:cache_ttl";

package/cache/cache.constants.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CACHE_TTL_METADATA = exports.CACHE_KEY_METADATA = exports.CACHE_MODULE_OPTIONS = exports.CACHE_MANAGER = void 0;
+exports.CACHE_TTL_METADATA = exports.CACHE_KEY_METADATA = exports.CACHE_MANAGER = void 0;
 exports.CACHE_MANAGER = 'CACHE_MANAGER';
-exports.CACHE_MODULE_OPTIONS = 'CACHE_MODULE_OPTIONS';
 exports.CACHE_KEY_METADATA = 'cache_module:cache_key';
 exports.CACHE_TTL_METADATA = 'cache_module:cache_ttl';

package/cache/cache.module-definition.d.ts

@@ -0,0 +1,2 @@
+import { CacheModuleOptions } from './interfaces/cache-module.interface';
+export declare const ConfigurableModuleClass: import("../module-utils").ConfigurableModuleCls<CacheModuleOptions<Record<string, any>>, "register", "createCacheOptions", {}>, MODULE_OPTIONS_TOKEN: string | symbol;

package/cache/cache.module-definition.js

@@ -0,0 +1,10 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODULE_OPTIONS_TOKEN = exports.ConfigurableModuleClass = void 0;
+const module_utils_1 = require("../module-utils");
+_a = new module_utils_1.ConfigurableModuleBuilder({
+    moduleName: 'Cache',
+})
+    .setFactoryMethodName('createCacheOptions')
+    .build(), exports.ConfigurableModuleClass = _a.ConfigurableModuleClass, exports.MODULE_OPTIONS_TOKEN = _a.MODULE_OPTIONS_TOKEN;

package/cache/cache.module.d.ts

@@ -1,4 +1,5 @@
 import { DynamicModule } from '../interfaces';
+import { ConfigurableModuleClass } from './cache.module-definition';
 import { CacheModuleAsyncOptions, CacheModuleOptions } from './interfaces/cache-module.interface';
 /**
  * Module that provides Nest cache-manager.
@@ -7,7 +8,7 @@ import { CacheModuleAsyncOptions, CacheModuleOptions } from './interfaces/cache-
  *
  * @publicApi
  */
-export declare class CacheModule {
+export declare class CacheModule extends ConfigurableModuleClass {
     /**
      * Configure the cache manager statically.
      *
@@ -25,6 +26,4 @@ export declare class CacheModule {
      * @see [Async configuration](https://docs.nestjs.com/techniques/caching#async-configuration)
      */
     static registerAsync<StoreConfig extends Record<any, any> = Record<string, any>>(options: CacheModuleAsyncOptions<StoreConfig>): DynamicModule;
-    private static createAsyncProviders;
-    private static createAsyncOptionsProvider;
 }

package/cache/cache.module.js

@@ -1,10 +1,10 @@
 "use strict";
-var CacheModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CacheModule = void 0;
 const tslib_1 = require("tslib");
 const decorators_1 = require("../decorators");
 const cache_constants_1 = require("./cache.constants");
+const cache_module_definition_1 = require("./cache.module-definition");
 const cache_providers_1 = require("./cache.providers");
 /**
  * Module that provides Nest cache-manager.
@@ -13,7 +13,7 @@ const cache_providers_1 = require("./cache.providers");
  *
  * @publicApi
  */
-let CacheModule = CacheModule_1 = class CacheModule {
+let CacheModule = class CacheModule extends cache_module_definition_1.ConfigurableModuleClass {
     /**
      * Configure the cache manager statically.
      *
@@ -22,11 +22,7 @@ let CacheModule = CacheModule_1 = class CacheModule {
      * @see [Customize caching](https://docs.nestjs.com/techniques/caching#customize-caching)
      */
     static register(options = {}) {
-        return {
-            module: CacheModule_1,
-            global: options.isGlobal,
-            providers: [{ provide: cache_constants_1.CACHE_MODULE_OPTIONS, useValue: options }],
-        };
+        return Object.assign({ global: options.isGlobal }, super.register(options));
     }
     /**
      * Configure the cache manager dynamically.
@@ -37,44 +33,11 @@ let CacheModule = CacheModule_1 = class CacheModule {
      * @see [Async configuration](https://docs.nestjs.com/techniques/caching#async-configuration)
      */
     static registerAsync(options) {
-        return {
-            module: CacheModule_1,
-            global: options.isGlobal,
-            imports: options.imports,
-            providers: [
-                ...this.createAsyncProviders(options),
-                ...(options.extraProviders || []),
-            ],
-        };
-    }
-    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: cache_constants_1.CACHE_MODULE_OPTIONS,
-                useFactory: options.useFactory,
-                inject: options.inject || [],
-            };
-        }
-        return {
-            provide: cache_constants_1.CACHE_MODULE_OPTIONS,
-            useFactory: async (optionsFactory) => optionsFactory.createCacheOptions(),
-            inject: [options.useExisting || options.useClass],
-        };
+        const moduleDefinition = super.registerAsync(options);
+        return Object.assign(Object.assign({ global: options.isGlobal }, moduleDefinition), { providers: moduleDefinition.providers.concat(options.extraProviders) });
     }
 };
-CacheModule = CacheModule_1 = tslib_1.__decorate([
+CacheModule = tslib_1.__decorate([
     (0, decorators_1.Module)({
         providers: [(0, cache_providers_1.createCacheManager)()],
         exports: [cache_constants_1.CACHE_MANAGER],

package/cache/cache.providers.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCacheManager = void 0;
 const load_package_util_1 = require("../utils/load-package.util");
 const cache_constants_1 = require("./cache.constants");
+const cache_module_definition_1 = require("./cache.module-definition");
 const default_options_1 = require("./default-options");
 /**
  * Creates a CacheManager Provider.
@@ -18,7 +19,7 @@ function createCacheManager() {
                 ? cacheManager.multiCaching(options.map(store => cacheManager.caching(Object.assign(Object.assign({}, default_options_1.defaultCacheOptions), (store || {})))))
                 : cacheManager.caching(Object.assign(Object.assign({}, default_options_1.defaultCacheOptions), (options || {})));
         },
-        inject: [cache_constants_1.CACHE_MODULE_OPTIONS],
+        inject: [cache_module_definition_1.MODULE_OPTIONS_TOKEN],
     };
 }
 exports.createCacheManager = createCacheManager;

package/cache/interfaces/cache-module.interface.d.ts

@@ -1,4 +1,5 @@
-import { ModuleMetadata, Provider, Type } from '../../interfaces';
+import { Provider, Type } from '../../interfaces';
+import { ConfigurableModuleAsyncOptions } from '../../module-utils';
 import { CacheManagerOptions } from './cache-manager.interface';
 export declare type CacheModuleOptions<StoreConfig extends Record<any, any> = Record<string, any>> = CacheManagerOptions & StoreConfig & {
     /**
@@ -24,7 +25,7 @@ export interface CacheOptionsFactory<StoreConfig extends Record<any, any> = Reco
  *
  * @publicApi
  */
-export interface CacheModuleAsyncOptions<StoreConfig extends Record<any, any> = Record<string, any>> extends Pick<ModuleMetadata, 'imports'> {
+export interface CacheModuleAsyncOptions<StoreConfig extends Record<any, any> = Record<string, any>> extends ConfigurableModuleAsyncOptions<CacheModuleOptions<StoreConfig>, keyof CacheOptionsFactory> {
     /**
      * Injection token resolving to an existing provider. The provider must implement
      * the `CacheOptionsFactory` interface.
@@ -44,6 +45,9 @@ export interface CacheModuleAsyncOptions<StoreConfig extends Record<any, any> =
      * Dependencies that a Factory may inject.
      */
     inject?: any[];
+    /**
+     * Extra providers to be registered within a scope of this module.
+     */
     extraProviders?: Provider[];
     /**
      * If "true', register `CacheModule` as a global module.

package/decorators/core/controller.decorator.js

@@ -46,7 +46,7 @@ function Controller(prefixOrOptions) {
             : [
                 prefixOrOptions.path || defaultPath,
                 prefixOrOptions.host,
-                { scope: prefixOrOptions.scope },
+                { scope: prefixOrOptions.scope, durable: prefixOrOptions.durable },
                 Array.isArray(prefixOrOptions.version)
                     ? Array.from(new Set(prefixOrOptions.version))
                     : prefixOrOptions.version,

package/index.d.ts

@@ -4,8 +4,8 @@ export * from './decorators';
 export * from './enums';
 export * from './exceptions';
 export * from './file-stream';
-export * from './http';
-export { Abstract, ArgumentMetadata, ArgumentsHost, BeforeApplicationShutdown, CallHandler, CanActivate, ClassProvider, ContextType, DynamicModule, ExceptionFilter, ExecutionContext, ExistingProvider, FactoryProvider, ForwardReference, HttpServer, INestApplication, INestApplicationContext, INestMicroservice, InjectionToken, IntrospectionResult, MessageEvent, MiddlewareConsumer, ModuleMetadata, NestApplicationOptions, NestHybridApplicationOptions, NestInterceptor, NestMiddleware, NestModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleDestroy, OnModuleInit, OptionalFactoryDependency, Paramtype, PipeTransform, Provider, RpcExceptionFilter, Scope, ScopeOptions, Type, ValidationError, ValueProvider, VersioningOptions, VERSION_NEUTRAL, WebSocketAdapter, WsExceptionFilter, WsMessageHandler, } from './interfaces';
+export { Abstract, ArgumentMetadata, ArgumentsHost, BeforeApplicationShutdown, CallHandler, CanActivate, ClassProvider, ContextType, DynamicModule, ExceptionFilter, ExecutionContext, ExistingProvider, FactoryProvider, ForwardReference, HttpServer, INestApplication, INestApplicationContext, INestMicroservice, InjectionToken, IntrospectionResult, MessageEvent, MiddlewareConsumer, ModuleMetadata, NestApplicationOptions, NestHybridApplicationOptions, NestInterceptor, NestMiddleware, NestModule, OnApplicationBootstrap, OnApplicationShutdown, OnModuleDestroy, OnModuleInit, OptionalFactoryDependency, Paramtype, PipeTransform, Provider, RawBodyRequest, RpcExceptionFilter, Scope, ScopeOptions, Type, ValidationError, ValueProvider, VersioningOptions, VERSION_NEUTRAL, WebSocketAdapter, WsExceptionFilter, WsMessageHandler, } from './interfaces';
+export * from './module-utils';
 export * from './pipes';
 export * from './serializer';
 export * from './services';

package/index.js

@@ -14,10 +14,10 @@ tslib_1.__exportStar(require("./decorators"), exports);
 tslib_1.__exportStar(require("./enums"), exports);
 tslib_1.__exportStar(require("./exceptions"), exports);
 tslib_1.__exportStar(require("./file-stream"), exports);
-tslib_1.__exportStar(require("./http"), exports);
 var interfaces_1 = require("./interfaces");
 Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return interfaces_1.Scope; } });
 Object.defineProperty(exports, "VERSION_NEUTRAL", { enumerable: true, get: function () { return interfaces_1.VERSION_NEUTRAL; } });
+tslib_1.__exportStar(require("./module-utils"), exports);
 tslib_1.__exportStar(require("./pipes"), exports);
 tslib_1.__exportStar(require("./serializer"), exports);
 tslib_1.__exportStar(require("./services"), exports);

package/interfaces/http/http-server.interface.d.ts

@@ -47,5 +47,5 @@ export interface HttpServer<TRequest = any, TResponse = any> {
     close(): any;
     getType(): string;
     init?(): Promise<void>;
-    applyVersionFilter?(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): <TRequest extends Record<string, any> = any, TResponse = any>(req: TRequest, res: TResponse, next: () => void) => any;
+    applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): (req: TRequest, res: TResponse, next: () => void) => Function;
 }

package/interfaces/http/index.d.ts

@@ -1,2 +1,3 @@
 export * from './http-server.interface';
 export * from './message-event.interface';
+export * from './raw-body-request.interface';

package/interfaces/http/index.js

@@ -3,3 +3,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./http-server.interface"), exports);
 tslib_1.__exportStar(require("./message-event.interface"), exports);
+tslib_1.__exportStar(require("./raw-body-request.interface"), exports);

package/interfaces/modules/provider.interface.d.ts

@@ -39,6 +39,19 @@ export interface ClassProvider<T = any> {
      * Optional enum defining lifetime of the provider that is injected.
      */
     scope?: Scope;
+    /**
+     * This option is only available on factory providers!
+     *
+     * @see [Use factory](https://docs.nestjs.com/fundamentals/custom-providers#factory-providers-usefactory)
+     */
+    inject?: never;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
 }
 /**
  * Interface defining a *Value* type provider.
@@ -64,6 +77,12 @@ export interface ValueProvider<T = any> {
      * Instance of a provider to be injected.
      */
     useValue: T;
+    /**
+     * This option is only available on factory providers!
+     *
+     * @see [Use factory](https://docs.nestjs.com/fundamentals/custom-providers#factory-providers-usefactory)
+     */
+    inject?: never;
 }
 /**
  * Interface defining a *Factory* type provider.
@@ -93,7 +112,7 @@ export interface FactoryProvider<T = any> {
     /**
      * Factory function that returns an instance of the provider to be injected.
      */
-    useFactory: (...args: any[]) => T;
+    useFactory: (...args: any[]) => T | Promise<T>;
     /**
      * Optional list of providers to be injected into the context of the Factory function.
      */
@@ -102,6 +121,13 @@ export interface FactoryProvider<T = any> {
      * Optional enum defining lifetime of the provider that is returned by the Factory function.
      */
     scope?: Scope;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
 }
 /**
  * Interface defining an *Existing* (aliased) type provider.

package/interfaces/nest-application.interface.d.ts

@@ -44,15 +44,6 @@ export interface INestApplication extends INestApplicationContext {
      */
     listen(port: number | string, callback?: () => void): Promise<any>;
     listen(port: number | string, hostname: string, callback?: () => void): Promise<any>;
-    /**
-     * Starts the application (can be awaited).
-     * @deprecated use "listen" instead.
-     *
-     * @param {number|string} port
-     * @param {string} [hostname]
-     * @returns {Promise}
-     */
-    listenAsync(port: number | string, hostname?: string): Promise<any>;
     /**
      * Returns the url the application is listening at, based on OS and IP version. Returns as an IP value either in IPv6 or IPv4
      *
@@ -109,13 +100,6 @@ export interface INestApplication extends INestApplicationContext {
      * @returns {Promise}
      */
     startAllMicroservices(): Promise<this>;
-    /**
-     * Starts all connected microservices and can be awaited.
-     * @deprecated use "startAllMicroservices" instead.
-     *
-     * @returns {Promise}
-     */
-    startAllMicroservicesAsync(): Promise<this>;
     /**
      * Registers exception filters as global filters (will be used within
      * every HTTP route handler)

package/interfaces/nest-microservice.interface.d.ts

@@ -16,13 +16,6 @@ export interface INestMicroservice extends INestApplicationContext {
      * @returns {void}
      */
     listen(): Promise<any>;
-    /**
-     * Starts the microservice (can be awaited).
-     * @deprecated use "listen" instead.
-     *
-     * @returns {Promise}
-     */
-    listenAsync(): Promise<any>;
     /**
      * Register Ws Adapter which will be used inside Gateways.
      * Use when you want to override default `socket.io` library.

package/interfaces/scope-options.interface.d.ts

@@ -27,4 +27,11 @@ export interface ScopeOptions {
      * Specifies the lifetime of an injected Provider or Controller.
      */
     scope?: Scope;
+    /**
+     * Flags provider as durable. This flag can be used in combination with custom context id
+     * factory strategy to construct lazy DI subtrees.
+     *
+     * This flag can be used only in conjunction with scope = Scope.REQUEST.
+     */
+    durable?: boolean;
 }

package/module-utils/configurable-module.builder.d.ts

@@ -0,0 +1,93 @@
+import { DynamicModule } from '../interfaces';
+import { Logger } from '../services/logger.service';
+import { DEFAULT_FACTORY_CLASS_METHOD_KEY, DEFAULT_METHOD_KEY } from './constants';
+import { ConfigurableModuleHost } from './interfaces/configurable-module-host.interface';
+/**
+ * @publicApi
+ */
+export interface ConfigurableModuleBuilderOptions {
+    /**
+     * Specified what injection token should be used for the module options provider.
+     * By default, an auto-generated UUID will be used.
+     */
+    optionsInjectionToken?: string | symbol;
+    /**
+     * By default, an UUID will be used as a module options provider token.
+     * Explicitly specifying the "moduleName" will instruct the "ConfigurableModuleBuilder"
+     * to use a more descriptive provider token.
+     *
+     * For example, if `moduleName: "Cache"` then auto-generated provider token will be "CACHE_MODULE_OPTIONS".
+     */
+    moduleName?: string;
+    /**
+     * Indicates whether module should always be "transient", meaning,
+     * every time you call the static method to construct a dynamic module,
+     * regardless of what arguments you pass in, a new "unique" module will be created.
+     *
+     * @default false
+     */
+    alwaysTransient?: boolean;
+}
+/**
+ * Factory that lets you create configurable modules and
+ * provides a way to reduce the majority of dynamic module boilerplate.
+ *
+ * @publicApi
+ */
+export declare class ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey extends string = typeof DEFAULT_METHOD_KEY, FactoryClassMethodKey extends string = typeof DEFAULT_FACTORY_CLASS_METHOD_KEY, ExtraModuleDefinitionOptions = {}> {
+    protected readonly options: ConfigurableModuleBuilderOptions;
+    protected staticMethodKey: StaticMethodKey;
+    protected factoryClassMethodKey: FactoryClassMethodKey;
+    protected extras: ExtraModuleDefinitionOptions;
+    protected transformModuleDefinition: (definition: DynamicModule, extraOptions: ExtraModuleDefinitionOptions) => DynamicModule;
+    protected readonly logger: Logger;
+    constructor(options?: ConfigurableModuleBuilderOptions, parentBuilder?: ConfigurableModuleBuilder<ModuleOptions>);
+    /**
+     * 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<ExtraModuleDefinitionOptions>(extras: ExtraModuleDefinitionOptions, transformDefinition: (definition: DynamicModule, extras: ExtraModuleDefinitionOptions) => DynamicModule): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * 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<StaticMethodKey extends string>(key: StaticMethodKey): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * 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<FactoryClassMethodKey extends string>(key: FactoryClassMethodKey): ConfigurableModuleBuilder<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    /**
+     * Returns an object consisting of multiple properties that lets you
+     * easily construct dynamic configurable modules. See "ConfigurableModuleHost" interface for more details.
+     */
+    build(): ConfigurableModuleHost<ModuleOptions, StaticMethodKey, FactoryClassMethodKey, ExtraModuleDefinitionOptions>;
+    private constructInjectionTokenString;
+    private createConfigurableModuleCls;
+    private createTypeProxy;
+}

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.6",
+  "version": "9.0.0-next.1",
   "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/parse-uuid.pipe.d.ts

@@ -6,8 +6,15 @@ export interface ParseUUIDPipeOptions {
     exceptionFactory?: (errors: string) => any;
 }
 export declare class ParseUUIDPipe implements PipeTransform<string> {
+    protected static uuidRegExps: {
+        3: RegExp;
+        4: RegExp;
+        5: RegExp;
+        all: RegExp;
+    };
     private readonly version;
     protected exceptionFactory: (errors: string) => any;
     constructor(options?: ParseUUIDPipeOptions);
     transform(value: string, metadata: ArgumentMetadata): Promise<string>;
+    protected isUUID(str: unknown, version?: string): any;
 }

package/pipes/parse-uuid.pipe.js

@@ -1,4 +1,5 @@
 "use strict";
+var ParseUUIDPipe_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParseUUIDPipe = void 0;
 const tslib_1 = require("tslib");
@@ -6,8 +7,8 @@ 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 is_uuid_1 = require("../utils/is-uuid");
-let ParseUUIDPipe = class ParseUUIDPipe {
+const shared_utils_1 = require("../utils/shared.utils");
+let ParseUUIDPipe = ParseUUIDPipe_1 = class ParseUUIDPipe {
     constructor(options) {
         options = options || {};
         const { exceptionFactory, errorHttpStatusCode = http_status_enum_1.HttpStatus.BAD_REQUEST, version, } = options;
@@ -17,13 +18,26 @@ let ParseUUIDPipe = class ParseUUIDPipe {
                 (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
     }
     async transform(value, metadata) {
-        if (!(0, is_uuid_1.isUUID)(value, this.version)) {
-            throw this.exceptionFactory(`Validation failed (uuid ${this.version ? 'v' + this.version : ''} is expected)`);
+        if (!this.isUUID(value, this.version)) {
+            throw this.exceptionFactory(`Validation failed (uuid${this.version ? ` v ${this.version}` : ''} is expected)`);
         }
         return value;
     }
+    isUUID(str, version = 'all') {
+        if (!(0, shared_utils_1.isString)(str)) {
+            throw this.exceptionFactory('The value passed as UUID is not a string');
+        }
+        const pattern = ParseUUIDPipe_1.uuidRegExps[version];
+        return pattern === null || pattern === void 0 ? void 0 : pattern.test(str);
+    }
+};
+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,
+    all: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
 };
-ParseUUIDPipe = tslib_1.__decorate([
+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])

package/utils/shared.utils.d.ts

@@ -2,11 +2,6 @@ export declare const isUndefined: (obj: any) => obj is undefined;
 export declare const isObject: (fn: any) => fn is object;
 export declare const isPlainObject: (fn: any) => fn is object;
 export declare const addLeadingSlash: (path?: string) => string;
-/**
- * Deprecated. Use the "addLeadingSlash" function instead.
- * @deprecated
- */
-export declare const validatePath: (path?: string) => string;
 export declare const normalizePath: (path?: string) => string;
 export declare const stripEndSlash: (path: string) => string;
 export declare const isFunction: (val: any) => boolean;

package/utils/shared.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSymbol = exports.isEmpty = exports.isNil = exports.isConstructor = exports.isNumber = exports.isString = exports.isFunction = exports.stripEndSlash = exports.normalizePath = exports.validatePath = exports.addLeadingSlash = exports.isPlainObject = exports.isObject = exports.isUndefined = void 0;
+exports.isSymbol = exports.isEmpty = exports.isNil = exports.isConstructor = exports.isNumber = exports.isString = exports.isFunction = exports.stripEndSlash = exports.normalizePath = exports.addLeadingSlash = exports.isPlainObject = exports.isObject = exports.isUndefined = void 0;
 /* eslint-disable @typescript-eslint/no-use-before-define */
 const isUndefined = (obj) => typeof obj === 'undefined';
 exports.isUndefined = isUndefined;
@@ -28,11 +28,6 @@ const addLeadingSlash = (path) => path && typeof path === 'string'
         : path
     : '';
 exports.addLeadingSlash = addLeadingSlash;
-/**
- * Deprecated. Use the "addLeadingSlash" function instead.
- * @deprecated
- */
-exports.validatePath = exports.addLeadingSlash;
 const normalizePath = (path) => path
     ? path.startsWith('/')
         ? ('/' + path.replace(/\/+$/, '')).replace(/\/+/g, '/')

package/http/http.constants.d.ts

@@ -1,3 +0,0 @@
-export declare const AXIOS_INSTANCE_TOKEN = "AXIOS_INSTANCE_TOKEN";
-export declare const HTTP_MODULE_ID = "HTTP_MODULE_ID";
-export declare const HTTP_MODULE_OPTIONS = "HTTP_MODULE_OPTIONS";

package/http/http.constants.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HTTP_MODULE_OPTIONS = exports.HTTP_MODULE_ID = exports.AXIOS_INSTANCE_TOKEN = void 0;
-exports.AXIOS_INSTANCE_TOKEN = 'AXIOS_INSTANCE_TOKEN';
-exports.HTTP_MODULE_ID = 'HTTP_MODULE_ID';
-exports.HTTP_MODULE_OPTIONS = 'HTTP_MODULE_OPTIONS';

package/http/http.module.d.ts

@@ -1,11 +0,0 @@
-import { DynamicModule } from '../interfaces';
-import { HttpModuleAsyncOptions, HttpModuleOptions } from './interfaces';
-/**
- * @deprecated "HttpModule" (from the "@nestjs/common" package) is deprecated and will be removed in the next major release. Please, use the "@nestjs/axios" package instead.
- */
-export declare class HttpModule {
-    static register(config: HttpModuleOptions): DynamicModule;
-    static registerAsync(options: HttpModuleAsyncOptions): DynamicModule;
-    private static createAsyncProviders;
-    private static createAsyncOptionsProvider;
-}

package/http/http.module.js

@@ -1,88 +0,0 @@
-"use strict";
-var HttpModule_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpModule = void 0;
-const tslib_1 = require("tslib");
-const axios_1 = require("axios");
-const module_decorator_1 = require("../decorators/modules/module.decorator");
-const random_string_generator_util_1 = require("../utils/random-string-generator.util");
-const http_constants_1 = require("./http.constants");
-const http_service_1 = require("./http.service");
-/**
- * @deprecated "HttpModule" (from the "@nestjs/common" package) is deprecated and will be removed in the next major release. Please, use the "@nestjs/axios" package instead.
- */
-let HttpModule = HttpModule_1 = class HttpModule {
-    static register(config) {
-        return {
-            module: HttpModule_1,
-            providers: [
-                {
-                    provide: http_constants_1.AXIOS_INSTANCE_TOKEN,
-                    useValue: axios_1.default.create(config),
-                },
-                {
-                    provide: http_constants_1.HTTP_MODULE_ID,
-                    useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
-                },
-            ],
-        };
-    }
-    static registerAsync(options) {
-        return {
-            module: HttpModule_1,
-            imports: options.imports,
-            providers: [
-                ...this.createAsyncProviders(options),
-                {
-                    provide: http_constants_1.AXIOS_INSTANCE_TOKEN,
-                    useFactory: (config) => axios_1.default.create(config),
-                    inject: [http_constants_1.HTTP_MODULE_OPTIONS],
-                },
-                {
-                    provide: http_constants_1.HTTP_MODULE_ID,
-                    useValue: (0, random_string_generator_util_1.randomStringGenerator)(),
-                },
-                ...(options.extraProviders || []),
-            ],
-        };
-    }
-    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: http_constants_1.HTTP_MODULE_OPTIONS,
-                useFactory: options.useFactory,
-                inject: options.inject || [],
-            };
-        }
-        return {
-            provide: http_constants_1.HTTP_MODULE_OPTIONS,
-            useFactory: async (optionsFactory) => optionsFactory.createHttpOptions(),
-            inject: [options.useExisting || options.useClass],
-        };
-    }
-};
-HttpModule = HttpModule_1 = tslib_1.__decorate([
-    (0, module_decorator_1.Module)({
-        providers: [
-            http_service_1.HttpService,
-            {
-                provide: http_constants_1.AXIOS_INSTANCE_TOKEN,
-                useValue: axios_1.default,
-            },
-        ],
-        exports: [http_service_1.HttpService],
-    })
-], HttpModule);
-exports.HttpModule = HttpModule;

package/http/http.service.d.ts

@@ -1,19 +0,0 @@
-import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
-import { Observable } from 'rxjs';
-/**
- * @deprecated "HttpModule" (from the "@nestjs/common" package) is deprecated and will be removed in the next major release. Please, use the "@nestjs/axios" package instead.
- */
-export declare class HttpService {
-    private readonly instance;
-    private readonly logger;
-    constructor(instance?: AxiosInstance);
-    request<T = any>(config: AxiosRequestConfig): Observable<AxiosResponse<T>>;
-    get<T = any>(url: string, config?: AxiosRequestConfig): Observable<AxiosResponse<T>>;
-    delete<T = any>(url: string, config?: AxiosRequestConfig): Observable<AxiosResponse<T>>;
-    head<T = any>(url: string, config?: AxiosRequestConfig): Observable<AxiosResponse<T>>;
-    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Observable<AxiosResponse<T>>;
-    put<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Observable<AxiosResponse<T>>;
-    patch<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Observable<AxiosResponse<T>>;
-    get axiosRef(): AxiosInstance;
-    private makeObservable;
-}

package/http/http.service.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpService = void 0;
-const tslib_1 = require("tslib");
-const axios_1 = require("axios");
-const rxjs_1 = require("rxjs");
-const decorators_1 = require("../decorators");
-const services_1 = require("../services");
-const http_constants_1 = require("./http.constants");
-/**
- * @deprecated "HttpModule" (from the "@nestjs/common" package) is deprecated and will be removed in the next major release. Please, use the "@nestjs/axios" package instead.
- */
-let HttpService = class HttpService {
-    constructor(instance = axios_1.default) {
-        this.instance = instance;
-        this.logger = new services_1.Logger(HttpService.name);
-        this.logger.warn('DEPRECATED! "HttpModule" (from the "@nestjs/common" package) is deprecated and will be removed in the next major release. Please, use the "@nestjs/axios" package instead.');
-    }
-    request(config) {
-        return this.makeObservable(this.instance.request, config);
-    }
-    get(url, config) {
-        return this.makeObservable(this.instance.get, url, config);
-    }
-    delete(url, config) {
-        return this.makeObservable(this.instance.delete, url, config);
-    }
-    head(url, config) {
-        return this.makeObservable(this.instance.head, url, config);
-    }
-    post(url, data, config) {
-        return this.makeObservable(this.instance.post, url, data, config);
-    }
-    put(url, data, config) {
-        return this.makeObservable(this.instance.put, url, data, config);
-    }
-    patch(url, data, config) {
-        return this.makeObservable(this.instance.patch, url, data, config);
-    }
-    get axiosRef() {
-        return this.instance;
-    }
-    makeObservable(axios, ...args) {
-        return new rxjs_1.Observable(subscriber => {
-            const config = Object.assign({}, (args[args.length - 1] || {}));
-            let cancelSource;
-            if (!config.cancelToken) {
-                cancelSource = axios_1.default.CancelToken.source();
-                config.cancelToken = cancelSource.token;
-            }
-            axios(...args)
-                .then(res => {
-                subscriber.next(res);
-                subscriber.complete();
-            })
-                .catch(err => {
-                subscriber.error(err);
-            });
-            return () => {
-                if (config.responseType === 'stream') {
-                    return;
-                }
-                if (cancelSource) {
-                    cancelSource.cancel();
-                }
-            };
-        });
-    }
-};
-HttpService = tslib_1.__decorate([
-    tslib_1.__param(0, (0, decorators_1.Inject)(http_constants_1.AXIOS_INSTANCE_TOKEN)),
-    tslib_1.__metadata("design:paramtypes", [Function])
-], HttpService);
-exports.HttpService = HttpService;

package/http/index.d.ts

@@ -1,3 +0,0 @@
-export * from './http.module';
-export * from './http.service';
-export * from './interfaces';

package/http/interfaces/http-module.interface.d.ts

@@ -1,13 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { ModuleMetadata, Provider, Type } from '../../interfaces';
-export declare type HttpModuleOptions = AxiosRequestConfig;
-export interface HttpModuleOptionsFactory {
-    createHttpOptions(): Promise<HttpModuleOptions> | HttpModuleOptions;
-}
-export interface HttpModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
-    useExisting?: Type<HttpModuleOptionsFactory>;
-    useClass?: Type<HttpModuleOptionsFactory>;
-    useFactory?: (...args: any[]) => Promise<HttpModuleOptions> | HttpModuleOptions;
-    inject?: any[];
-    extraProviders?: Provider[];
-}

package/http/interfaces/index.d.ts

@@ -1,2 +0,0 @@
-export * from './http-module.interface';
-export * from './raw-body-request.interface';

package/http/interfaces/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./http-module.interface"), exports);
-tslib_1.__exportStar(require("./raw-body-request.interface"), exports);

package/utils/is-uuid.d.ts

@@ -1 +0,0 @@
-export declare function isUUID(str: any, version?: string): any;

package/utils/is-uuid.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUUID = void 0;
-const exceptions_1 = require("../exceptions");
-const shared_utils_1 = require("./shared.utils");
-const uuid = {
-    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,
-    all: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
-};
-function isUUID(str, version = 'all') {
-    if (!(0, shared_utils_1.isString)(str)) {
-        throw new exceptions_1.BadRequestException('The value passed as UUID is not a string');
-    }
-    const pattern = uuid[version];
-    return pattern && pattern.test(str);
-}
-exports.isUUID = isUUID;