Use NestFactory to create an application instance.
### Specifying an entry module
Pass the required *root module* for the application via the module parameter. By convention, it is usually called ApplicationModule. Starting with this module, Nest assembles the dependency graph and begins the process of Dependency Injection and instantiates the classes needed to launch your application.

variable REQUEST

const REQUEST: string;

Functions

function createContextId

createContextId: () => ContextId;

function repl

repl: (module: Type | DynamicModule) => Promise<import('repl').REPLServer>;

Classes

class AbstractHttpAdapter

abstract class AbstractHttpAdapter<TServer = any, TRequest = any, TResponse = any>
    implements HttpServer<TRequest, TResponse> {}

constructor

constructor(instance?: any);

property httpServer

protected httpServer: {};

property instance

protected instance?: any;

method all

all: {
    (handler: RequestHandler): any;
    (path: any, handler: RequestHandler): any;
};

method applyVersionFilter

abstract applyVersionFilter: (
    handler: Function,
    version: VersionValue,
    versioningOptions: VersioningOptions
) => (req: TRequest, res: TResponse, next: () => void) => Function;

method close

abstract close: () => any;

method createMiddlewareFactory

abstract createMiddlewareFactory: (
    requestMethod: RequestMethod
) =>
    | ((path: string, callback: Function) => any)
    | Promise<(path: string, callback: Function) => any>;

method delete

delete: {
    (handler: RequestHandler): any;
    (path: any, handler: RequestHandler): any;
};

method enableCors

abstract enableCors: (
    options: CorsOptions | CorsOptionsDelegate<TRequest>,
    prefix?: string
) => any;

method end

abstract end: (response: any, message?: string) => any;

method get

get: {
    (handler: RequestHandler): any;
    (path: any, handler: RequestHandler): any;
};

method getHttpServer

getHttpServer: () => TServer;

method getInstance

getInstance: <T = any>() => T;

method getRequestHostname

abstract getRequestHostname: (request: any) => any;

method getRequestMethod

abstract getRequestMethod: (request: any) => any;

method getRequestUrl

abstract getRequestUrl: (request: any) => any;

method getType

abstract getType: () => string;

method head

head: {
    (handler: RequestHandler): any;
    (path: any, handler: RequestHandler): any;
};

method init

init: () => Promise<void>;

method initHttpServer

abstract initHttpServer: (options: NestApplicationOptions) => any;

method isHeadersSent

abstract isHeadersSent: (response: any) => any;

method listen

listen: {
    (port: string | number, callback?: () => void): any;
    (port: string | number, hostname: string, callback?: () => void): any;
};

method options

options: {
    (handler: RequestHandler): any;
    (path: any, handler: RequestHandler): any;
};

method patch

patch: {
    (handler: RequestHandler): any;
    (path: any, handler: RequestHandler): any;
};

method post

post: {
    (handler: RequestHandler): any;
    (path: any, handler: RequestHandler): any;
};

method put

put: {
    (handler: RequestHandler): any;
    (path: any, handler: RequestHandler): any;
};

method redirect

abstract redirect: (response: any, statusCode: number, url: string) => any;

method registerParserMiddleware

abstract registerParserMiddleware: (prefix?: string, rawBody?: boolean) => any;

method render

abstract render: (response: any, view: string, options: any) => any;

method reply

abstract reply: (response: any, body: any, statusCode?: number) => any;

method setErrorHandler

abstract setErrorHandler: (handler: Function, prefix?: string) => any;

method setHeader

abstract setHeader: (response: any, name: string, value: string) => any;

method setHttpServer

setHttpServer: (httpServer: TServer) => void;

method setInstance

setInstance: <T = any>(instance: T) => void;

method setNotFoundHandler

abstract setNotFoundHandler: (handler: Function, prefix?: string) => any;

method setViewEngine

abstract setViewEngine: (engine: string) => any;

method status

abstract status: (response: any, statusCode: number) => any;

method use

use: (...args: any[]) => any;

method useStaticAssets

abstract useStaticAssets: (...args: any[]) => any;

class ApplicationConfig

class ApplicationConfig {}

constructor

constructor(ioAdapter?: any);

method addGlobalFilter

addGlobalFilter: (filter: ExceptionFilter) => void;

method addGlobalGuard

addGlobalGuard: (guard: CanActivate) => void;

method addGlobalInterceptor

addGlobalInterceptor: (interceptor: NestInterceptor) => void;

method addGlobalPipe

addGlobalPipe: (pipe: PipeTransform<any>) => void;

method addGlobalRequestFilter

addGlobalRequestFilter: (wrapper: InstanceWrapper<ExceptionFilter>) => void;

method addGlobalRequestGuard

addGlobalRequestGuard: (wrapper: InstanceWrapper<CanActivate>) => void;

method addGlobalRequestInterceptor

addGlobalRequestInterceptor: (wrapper: InstanceWrapper<NestInterceptor>) => void;

method addGlobalRequestPipe

addGlobalRequestPipe: (wrapper: InstanceWrapper<PipeTransform>) => void;

method enableVersioning

enableVersioning: (options: VersioningOptions) => void;

method getGlobalFilters

getGlobalFilters: () => ExceptionFilter[];

method getGlobalGuards

getGlobalGuards: () => CanActivate[];

method getGlobalInterceptors

getGlobalInterceptors: () => NestInterceptor[];

method getGlobalPipes

getGlobalPipes: () => PipeTransform<any>[];

method getGlobalPrefix

getGlobalPrefix: () => string;

method getGlobalPrefixOptions

getGlobalPrefixOptions: () => GlobalPrefixOptions<ExcludeRouteMetadata>;

method getGlobalRequestFilters

getGlobalRequestFilters: () => InstanceWrapper<ExceptionFilter>[];

method getGlobalRequestGuards

getGlobalRequestGuards: () => InstanceWrapper<CanActivate>[];

method getGlobalRequestInterceptors

getGlobalRequestInterceptors: () => InstanceWrapper<NestInterceptor>[];

method getGlobalRequestPipes

getGlobalRequestPipes: () => InstanceWrapper<PipeTransform>[];

method getIoAdapter

getIoAdapter: () => WebSocketAdapter;

method getVersioning

getVersioning: () => VersioningOptions | undefined;

method setGlobalPrefix

setGlobalPrefix: (prefix: string) => void;

method setGlobalPrefixOptions

setGlobalPrefixOptions: (
    options: GlobalPrefixOptions<ExcludeRouteMetadata>
) => void;

method setIoAdapter

setIoAdapter: (ioAdapter: WebSocketAdapter) => void;

method useGlobalFilters

useGlobalFilters: (...filters: ExceptionFilter[]) => void;

method useGlobalGuards

useGlobalGuards: (...guards: CanActivate[]) => void;

method useGlobalInterceptors

useGlobalInterceptors: (...interceptors: NestInterceptor[]) => void;

method useGlobalPipes

useGlobalPipes: (...pipes: PipeTransform<any>[]) => void;

class BaseExceptionFilter

class BaseExceptionFilter<T = any> implements ExceptionFilter<T> {}

constructor

constructor(applicationRef?: HttpServer);

property applicationRef

protected readonly applicationRef?: HttpServer;

property httpAdapterHost

protected readonly httpAdapterHost?: HttpAdapterHost<
    AbstractHttpAdapter<any, any, any>
>;

method catch

catch: (exception: T, host: ArgumentsHost) => void;

method handleUnknownError

handleUnknownError: (
    exception: T,
    host: ArgumentsHost,
    applicationRef: AbstractHttpAdapter | HttpServer
) => void;

method isExceptionObject

isExceptionObject: (err: any) => err is Error;

method isHttpError

isHttpError: (err: any) => err is { statusCode: number; message: string };

Checks if the thrown error comes from the "http-errors" library.
Parameter err
error object

class ContextIdFactory

class ContextIdFactory {}

method apply

static apply: (strategy: ContextIdStrategy) => void;

Registers a custom context id strategy that lets you attach a parent context id to the existing context id object.
Parameter strategy
strategy instance

method create

static create: () => ContextId;

Generates a context identifier based on the request object.

method getByRequest

static getByRequest: <T extends Record<any, any> = any>(
    request: T,
    propsToInspect?: string[]
) => ContextId;

Generates a random identifier to track asynchronous execution context.
Parameter request
request object

class DiscoveryModule

class DiscoveryModule {}

class DiscoveryService

class DiscoveryService {}

constructor

constructor(modulesContainer: ModulesContainer);

method getControllers

getControllers: (
    options?: DiscoveryOptions,
    modules?: Module[]
) => InstanceWrapper[];

method getModules

protected getModules: (options?: DiscoveryOptions) => Module[];

method getProviders

getProviders: (
    options?: DiscoveryOptions,
    modules?: Module[]
) => InstanceWrapper[];

class ExternalContextCreator

class ExternalContextCreator {}

constructor

constructor(
    guardsContextCreator: GuardsContextCreator,
    guardsConsumer: GuardsConsumer,
    interceptorsContextCreator: InterceptorsContextCreator,
    interceptorsConsumer: InterceptorsConsumer,
    modulesContainer: ModulesContainer,
    pipesContextCreator: PipesContextCreator,
    pipesConsumer: PipesConsumer,
    filtersContextCreator: ExternalExceptionFilterContext
);

method create

create: <
    TParamsMetadata extends ParamsMetadata = ParamsMetadata,
    TContext extends string = ContextType
>(
    instance: Controller,
    callback: (...args: unknown[]) => unknown,
    methodName: string,
    metadataKey?: string,
    paramsFactory?: ParamsFactory,
    contextId?: ContextId,
    inquirerId?: string,
    options?: ExternalContextOptions,
    contextType?: TContext
) => (...args: any[]) => Promise<any>;

method createGuardsFn

createGuardsFn: <TContext extends string = ContextType>(
    guards: any[],
    instance: Controller,
    callback: (...args: any[]) => any,
    contextType?: TContext
) => Function | null;

method createPipesFn

createPipesFn: (
    pipes: PipeTransform[],
    paramsOptions: (ParamProperties & { metatype?: unknown })[]
) => (args: unknown[], ...params: unknown[]) => Promise<void>;

method exchangeKeysForValues

exchangeKeysForValues: <TMetadata = any>(
    keys: string[],
    metadata: TMetadata,
    moduleContext: string,
    paramsFactory: ParamsFactory,
    contextId?: ContextId,
    inquirerId?: string,
    contextFactory?: (
        args: unknown[]
    ) => import('./execution-context-host').ExecutionContextHost
) => ParamProperties[];

method fromContainer

static fromContainer: (container: NestContainer) => ExternalContextCreator;

method getContextModuleKey

getContextModuleKey: (moduleCtor: Function | undefined) => string;

method getMetadata

getMetadata: <TMetadata, TContext extends string = ContextType>(
    instance: Controller,
    methodName: string,
    metadataKey?: string,
    paramsFactory?: ParamsFactory,
    contextType?: TContext
) => ExternalHandlerMetadata;

method getParamValue

getParamValue: <T>(
    value: T,
    { metatype, type, data }: { metatype: any; type: any; data: any },
    pipes: PipeTransform[]
) => Promise<any>;

method registerRequestProvider

registerRequestProvider: <T = any>(request: T, contextId: ContextId) => void;

method transformToResult

transformToResult: (resultOrDeferred: any) => Promise<any>;

class GraphInspector

class GraphInspector {}

constructor

constructor(container: NestContainer);

method insertAttachedEnhancer

insertAttachedEnhancer: (wrapper: InstanceWrapper) => void;

method insertClassNode

insertClassNode: (
    moduleRef: Module,
    wrapper: InstanceWrapper,
    type: Exclude<Node['metadata']['type'], 'module'>
) => void;

method insertEnhancerMetadataCache

insertEnhancerMetadataCache: (entry: EnhancerMetadataCacheEntry) => void;

method insertEntrypointDefinition

insertEntrypointDefinition: <T>(
    definition: Entrypoint<T>,
    parentId: string
) => void;

method insertOrphanedEnhancer

insertOrphanedEnhancer: (entry: OrphanedEnhancerDefinition) => void;

method inspectInstanceWrapper

inspectInstanceWrapper: <T = any>(
    source: InstanceWrapper<T>,
    moduleRef: Module
) => void;

method inspectModules

inspectModules: (modules?: Map<string, Module>) => void;

method registerPartial

registerPartial: (error: unknown) => void;

class HttpAdapterHost

class HttpAdapterHost<T extends AbstractHttpAdapter = AbstractHttpAdapter> {}

Defines the HttpAdapterHost object.
HttpAdapterHost wraps the underlying platform-specific HttpAdapter. The HttpAdapter is a wrapper around the underlying native HTTP server library (e.g., Express). The HttpAdapterHost object provides methods to get and set the underlying HttpAdapter.
See Also
- [Http adapter](https://docs.nestjs.com/faq/http-adapter)

property httpAdapter

httpAdapter: AbstractHttpAdapter<any, any, any>;

Accessor for the underlying HttpAdapter
Example 1
const httpAdapter = adapterHost.httpAdapter;

class InitializeOnPreviewAllowlist

class InitializeOnPreviewAllowlist {}

method add

static add: (type: Type) => void;

method has

static has: (type: Type) => boolean;

class LazyModuleLoader

class LazyModuleLoader {}

constructor

constructor(
    dependenciesScanner: DependenciesScanner,
    instanceLoader: InstanceLoader<Injector>,
    moduleCompiler: ModuleCompiler,
    modulesContainer: ModulesContainer
);

method load

load: (
    loaderFn: () =>
        | Promise<Type<unknown> | DynamicModule>
        | Type<unknown>
        | DynamicModule,
    loadOpts?: LazyModuleLoaderLoadOptions
) => Promise<ModuleRef>;

class MetadataScanner

class MetadataScanner {}

method getAllFilteredMethodNames

getAllFilteredMethodNames: (prototype: object) => IterableIterator<string>;

See Also
- getAllMethodNames
- getAllMethodNames
Deprecated

method getAllMethodNames

getAllMethodNames: (prototype: object | null) => string[];

method scanFromPrototype

scanFromPrototype: <T extends Injectable, R = any>(
    instance: T,
    prototype: object,
    callback: (name: string) => R
) => R[];

See Also
- getAllMethodNames
- getAllMethodNames
Deprecated

class MiddlewareBuilder

class MiddlewareBuilder implements MiddlewareConsumer {}

constructor

constructor(
    routesMapper: RoutesMapper,
    httpAdapter: HttpServer,
    routeInfoPathExtractor: RouteInfoPathExtractor
);

method apply

apply: (
    ...middleware: Array<Type<any> | Function | any>
) => MiddlewareConfigProxy;

method build

build: () => MiddlewareConfiguration[];

method getHttpAdapter

getHttpAdapter: () => HttpServer;

class ModuleRef

abstract class ModuleRef extends AbstractInstanceResolver {}

constructor

constructor(container: NestContainer);

property container

protected readonly container: NestContainer;

property injector

protected readonly injector: Injector;

property instanceLinksHost

readonly instanceLinksHost: InstanceLinksHost;

method create

abstract create: <T = any>(type: Type<T>) => Promise<T>;

method get

abstract get: {
    <TInput = any, TResult = TInput>(
        typeOrToken: Type<TInput> | Function | string | symbol
    ): TResult;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        options: { strict?: boolean; each?: false }
    ): TResult;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        options: { strict?: boolean; each: true }
    ): TResult[];
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        options?: ModuleRefGetOrResolveOpts
    ): TResult | TResult[];
};

Retrieves an instance of either injectable or controller, otherwise, throws exception.
Returns
{TResult}
Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
Returns
{Array}
Retrieves an instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
Returns
{TResult | Array}

method instantiateClass

protected instantiateClass: <T = any>(
    type: Type<T>,
    moduleRef: Module
) => Promise<T>;

method introspect

introspect: <T = any>(token: Type<T> | string | symbol) => IntrospectionResult;

method registerRequestByContextId

registerRequestByContextId: <T = any>(request: T, contextId: ContextId) => void;

method resolve

abstract resolve: {
    <TInput = any, TResult = TInput>(
        typeOrToken: Type<TInput> | Function | string | symbol
    ): Promise<TResult>;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        contextId?: { id: number }
    ): Promise<TResult>;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        contextId?: { id: number },
        options?: { strict?: boolean; each?: false }
    ): Promise<TResult>;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        contextId?: { id: number },
        options?: { strict?: boolean; each: true }
    ): Promise<TResult[]>;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        contextId?: { id: number },
        options?: ModuleRefGetOrResolveOpts
    ): Promise<TResult | TResult[]>;
};

Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
Returns
{Array}
Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
Returns
{Array}
Resolves transient or request-scoped instance (or a list of instances) of either injectable or controller, otherwise, throws exception.
Returns
{Promise<TResult | Array>}

class ModulesContainer

class ModulesContainer extends Map<string, Module> {}

property applicationId

readonly applicationId: string;

method getById

getById: (id: string) => Module | undefined;

class NestApplication

class NestApplication
    extends NestApplicationContext<NestApplicationOptions>
    implements INestApplication {}

constructor

constructor(
    container: NestContainer,
    httpAdapter: HttpServer,
    config: ApplicationConfig,
    graphInspector: GraphInspector,
    appOptions?: NestApplicationOptions
);

property logger

protected readonly logger: Logger;

method applyOptions

applyOptions: () => void;

method connectMicroservice

connectMicroservice: <T extends object>(
    microserviceOptions: T,
    hybridAppOptions?: NestHybridApplicationOptions
) => INestMicroservice;

method createServer

createServer: <T = any>() => T;

method dispose

protected dispose: () => Promise<void>;

method enableCors

enableCors: (options?: CorsOptions | CorsOptionsDelegate<any>) => void;

method enableVersioning

enableVersioning: (options?: VersioningOptions) => this;

method getHttpAdapter

getHttpAdapter: () => AbstractHttpAdapter;

method getHttpServer

getHttpServer: () => any;

method getMicroservices

getMicroservices: () => INestMicroservice[];

method getUnderlyingHttpServer

getUnderlyingHttpServer: <T>() => T;

method getUrl

getUrl: () => Promise<string>;

method init

init: () => Promise<this>;

method listen

listen: {
    (port: number | string): Promise<any>;
    (port: string | number, hostname: string): Promise<any>;
};

method registerHttpServer

registerHttpServer: () => void;

method registerModules

registerModules: () => Promise<void>;

method registerParserMiddleware

registerParserMiddleware: () => void;

method registerRouter

registerRouter: () => Promise<void>;

method registerRouterHooks

registerRouterHooks: () => Promise<void>;

method registerWsModule

registerWsModule: () => void;

method setBaseViewsDir

setBaseViewsDir: (path: string | string[]) => this;

method setGlobalPrefix

setGlobalPrefix: (prefix: string, options?: GlobalPrefixOptions) => this;

method setViewEngine

setViewEngine: (engineOrOptions: any) => this;

method startAllMicroservices

startAllMicroservices: () => Promise<this>;

method use

use: (args_0: any, args_1?: any) => this;

method useBodyParser

useBodyParser: (args_0: any, args_1?: any) => this;

method useGlobalFilters

useGlobalFilters: (...filters: ExceptionFilter[]) => this;

method useGlobalGuards

useGlobalGuards: (...guards: CanActivate[]) => this;

method useGlobalInterceptors

useGlobalInterceptors: (...interceptors: NestInterceptor[]) => this;

method useGlobalPipes

useGlobalPipes: (...pipes: PipeTransform<any>[]) => this;

method useStaticAssets

useStaticAssets: { (options: any): this; (path: string, options?: any): this };

method useWebSocketAdapter

useWebSocketAdapter: (adapter: WebSocketAdapter) => this;

class NestApplicationContext

class NestApplicationContext<
        TOptions extends NestApplicationContextOptions = NestApplicationContextOptions
    >
    extends AbstractInstanceResolver
    implements INestApplicationContext {}

constructor

constructor(
    container: NestContainer,
    appOptions?: NestApplicationContextOptions,
    contextModule?: Module,
    scope?: Type<any>[]
);

property appOptions

protected readonly appOptions: NestApplicationContextOptions;

property container

protected readonly container: NestContainer;

property injector

protected injector: Injector;

property instanceLinksHost

readonly instanceLinksHost: InstanceLinksHost;

property isInitialized

protected isInitialized: boolean;

property logger

protected readonly logger: Logger;

method assertNotInPreviewMode

protected assertNotInPreviewMode: (methodName: string) => void;

method callBeforeShutdownHook

protected callBeforeShutdownHook: (signal?: string) => Promise<void>;

Calls the beforeApplicationShutdown function on the registered modules and children.

method callBootstrapHook

protected callBootstrapHook: () => Promise<void>;

Calls the onApplicationBootstrap function on the registered modules and its children.

method callDestroyHook

protected callDestroyHook: () => Promise<void>;

Calls the onModuleDestroy function on the registered modules and its children.

method callInitHook

protected callInitHook: () => Promise<void>;

Calls the onModuleInit function on the registered modules and its children.

method callShutdownHook

protected callShutdownHook: (signal?: string) => Promise<void>;

Calls the onApplicationShutdown function on the registered modules and children.

method close

close: (signal?: string) => Promise<void>;

Terminates the application
Returns
{Promise}

method dispose

protected dispose: () => Promise<void>;

method enableShutdownHooks

enableShutdownHooks: (signals?: (ShutdownSignal | string)[]) => this;

Enables the usage of shutdown hooks. Will call the onApplicationShutdown function of a provider if the process receives a shutdown signal.
Parameter signals
The system signals it should listen to
Returns
{this} The Nest application context instance

method flushLogs

flushLogs: () => void;

Prints buffered logs and detaches buffer.
Returns
{void}

method flushLogsOnOverride

flushLogsOnOverride: () => void;

Define that it must flush logs right after defining a custom logger.

method get

get: {
    <TInput = any, TResult = TInput>(
        typeOrToken: Type<TInput> | Function | string | symbol
    ): TResult;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        options: { strict?: boolean; each?: false }
    ): TResult;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        options: { strict?: boolean; each: true }
    ): TResult[];
};

Retrieves an instance of either injectable or controller, otherwise, throws exception.
Returns
{TResult}
Retrieves a list of instances of either injectables or controllers, otherwise, throws exception.
Returns
{Array}

method init

init: () => Promise<this>;

Initializes the Nest application. Calls the Nest lifecycle events.
Returns
{Promise} The NestApplicationContext instance as Promise

method listenToShutdownSignals

protected listenToShutdownSignals: (signals: string[]) => void;

Listens to shutdown signals by listening to process events
Parameter signals
The system signals it should listen to

method registerRequestByContextId

registerRequestByContextId: <T = any>(request: T, contextId: ContextId) => void;

Registers the request/context object for a given context ID (DI container sub-tree).
Returns
{void}

method resolve

resolve: {
    <TInput = any, TResult = TInput>(
        typeOrToken: Type<TInput> | Function | string | symbol
    ): Promise<TResult>;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        contextId?: { id: number }
    ): Promise<TResult>;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        contextId?: { id: number },
        options?: { strict?: boolean; each?: false }
    ): Promise<TResult>;
    <TInput = any, TResult = TInput>(
        typeOrToken: any,
        contextId?: { id: number },
        options?: { strict?: boolean; each: true }
    ): Promise<TResult[]>;
};

Resolves transient or request-scoped instance of either injectable or controller, otherwise, throws exception.
Returns
{Array}
Resolves transient or request-scoped instances of either injectables or controllers, otherwise, throws exception.
Returns
{Array}

method select

select: <T>(moduleType: Type<T> | DynamicModule) => INestApplicationContext;

Allows navigating through the modules tree, for example, to pull out a specific instance from the selected module.
Returns
{INestApplicationContext}

method selectContextModule

selectContextModule: () => void;

method unsubscribeFromProcessSignals

protected unsubscribeFromProcessSignals: () => void;

Unsubscribes from shutdown signals (process events)

method useLogger

useLogger: (logger: LoggerService | LogLevel[] | false) => void;

Sets custom logger service. Flushes buffered logs if auto flush is on.
Returns
{void}

class NestContainer

class NestContainer {}

constructor

constructor(_applicationConfig?: ApplicationConfig);

property applicationConfig

readonly applicationConfig: ApplicationConfig;

property serializedGraph

readonly serializedGraph: SerializedGraph;

method addController

addController: (controller: Type<any>, token: string) => void;

method addDynamicMetadata

addDynamicMetadata: (
    token: string,
    dynamicModuleMetadata: DynamicModule,
    scope: Type<any>[]
) => Promise<void>;

method addDynamicModules

addDynamicModules: (modules: any[], scope: Type<any>[]) => Promise<void>;

method addExportedProvider

addExportedProvider: (provider: Type<any>, token: string) => void;

method addGlobalModule

addGlobalModule: (module: Module) => void;

method addImport

addImport: (
    relatedModule: Type<any> | DynamicModule,
    token: string
) => Promise<void>;

method addInjectable

addInjectable: (
    injectable: Provider,
    token: string,
    enhancerSubtype: EnhancerSubtype,
    host?: Type<Injectable>
) =>
    | string
    | symbol
    | Function
    | import('./instance-wrapper').InstanceWrapper<unknown>;

method addModule

addModule: (
    metatype: Type<any> | DynamicModule | Promise<DynamicModule>,
    scope: Type<any>[]
) => Promise<Module | undefined>;

method addProvider

addProvider: (
    provider: Provider,
    token: string,
    enhancerSubtype?: EnhancerSubtype
) => string | symbol | Function;

method bindGlobalModuleToModule

bindGlobalModuleToModule: (target: Module, globalModule: Module) => void;

method bindGlobalScope

bindGlobalScope: () => void;

method bindGlobalsToImports

bindGlobalsToImports: (moduleRef: Module) => void;

method clear

clear: () => void;

method getDynamicMetadataByToken

getDynamicMetadataByToken: {
    (token: string): DynamicModule;
    <K extends string | number | symbol>(
        token: string,
        metadataKey: K
    ): DynamicModule;
};

method getHttpAdapterHostRef

getHttpAdapterHostRef: () => import('..').HttpAdapterHost<
    import('..').AbstractHttpAdapter<any, any, any>
>;

method getHttpAdapterRef

getHttpAdapterRef: () => import('..').AbstractHttpAdapter<any, any, any>;

method getInternalCoreModuleRef

getInternalCoreModuleRef: () => Module | undefined;

method getModuleByKey

getModuleByKey: (moduleKey: string) => Module;

method getModuleCompiler

getModuleCompiler: () => ModuleCompiler;

method getModules

getModules: () => ModulesContainer;

method getModuleTokenFactory

getModuleTokenFactory: () => ModuleTokenFactory;

method isGlobalModule

isGlobalModule: (
    metatype: Type<any>,
    dynamicMetadata?: DynamicModule
) => boolean;

method registerCoreModuleRef

registerCoreModuleRef: (moduleRef: Module) => void;

method registerRequestProvider

registerRequestProvider: <T = any>(request: T, contextId: ContextId) => void;

method replace

replace: (toReplace: any, options: any & { scope: any[] | null }) => void;

method setHttpAdapter

setHttpAdapter: (httpAdapter: any) => void;

class PartialGraphHost

class PartialGraphHost {}

method register

static register: (partialGraph: SerializedGraph) => void;

method toJSON

static toJSON: () => import('./interfaces/serialized-graph-json.interface').SerializedGraphJson;

method toString

static toString: () => string;

class Reflector

class Reflector {}

Helper class providing Nest reflection capabilities.
See Also
- [Reflection](https://docs.nestjs.com/guards#putting-it-all-together)

method get

get: <TResult = any, TKey = any>(
    metadataKey: TKey,
    target: Type<any> | Function
) => TResult;

Retrieve metadata for a specified key for a specified target.
Parameter metadataKey
lookup key for metadata to retrieve
Parameter target
context (decorated object) to retrieve metadata from
Example 1
const roles = this.reflector.get<string[]>('roles', context.getHandler());

method getAll

getAll: <TResult extends any[] = any[], TKey = any>(
    metadataKey: TKey,
    targets: (Type<any> | Function)[]
) => TResult;

Retrieve metadata for a specified key for a specified set of targets.
Parameter metadataKey
lookup key for metadata to retrieve
Parameter targets
context (decorated objects) to retrieve metadata from

method getAllAndMerge

getAllAndMerge: <TResult extends any[] = any[], TKey = any>(
    metadataKey: TKey,
    targets: (Type<any> | Function)[]
) => TResult;

Retrieve metadata for a specified key for a specified set of targets and merge results.
Parameter metadataKey
lookup key for metadata to retrieve
Parameter targets
context (decorated objects) to retrieve metadata from

method getAllAndOverride

getAllAndOverride: <TResult = any, TKey = any>(
    metadataKey: TKey,
    targets: (Type<any> | Function)[]
) => TResult;

Retrieve metadata for a specified key for a specified set of targets and return a first not undefined value.
Parameter metadataKey
lookup key for metadata to retrieve
Parameter targets
context (decorated objects) to retrieve metadata from

class RouterModule

class RouterModule {}

constructor

constructor(modulesContainer: ModulesContainer, routes: Routes);

method register

static register: (routes: Routes) => DynamicModule;

class SerializedGraph

class SerializedGraph {}

method getNodeById

getNodeById: (id: string) => Node;

method insertAttachedEnhancer

insertAttachedEnhancer: (nodeId: string) => void;

method insertEdge

insertEdge: (edgeDefinition: WithOptionalId<Edge>) => {
    id: string;
    metadata:
        | ({ type: 'module-to-module' } & {
              sourceModuleName: string;
              targetModuleName: string;
          })
        | ({
              type: 'class-to-class';
              sourceClassName: string;
              targetClassName: string;
              sourceClassToken: InjectionToken;
              targetClassToken: InjectionToken;
              injectionType: 'constructor' | 'property' | 'decorator';
              keyOrIndex?: string | number | symbol;
              internal?: boolean;
          } & { sourceModuleName: string; targetModuleName: string });
    source: string;
    target: string;
};

method insertEntrypoint

insertEntrypoint: <T>(definition: Entrypoint<T>, parentId: string) => void;

method insertNode

insertNode: (nodeDefinition: Node) => Node;

method insertOrphanedEnhancer

insertOrphanedEnhancer: (entry: OrphanedEnhancerDefinition) => void;

method toJSON

toJSON: () => SerializedGraphJson;

method toString

toString: () => string;

Interfaces

interface ContextId

interface ContextId {}

property id

readonly id: number;

property payload

payload?: unknown;

method getParent

getParent: (info: HostComponentInfo) => ContextId;

interface ContextIdResolver

interface ContextIdResolver {}

property payload

payload: unknown;

Payload associated with the custom context id

property resolve

resolve: ContextIdResolverFn;

A context id resolver function

interface ContextIdStrategy

interface ContextIdStrategy<T = any> {}

method attach

attach: (
    contextId: ContextId,
    request: T
) => ContextIdResolverFn | ContextIdResolver | undefined;

Allows to attach a parent context id to the existing child context id. This lets you construct durable DI sub-trees that can be shared between contexts.
Parameter contextId
auto-generated child context id
Parameter request
request object

interface DiscoveryOptions

interface DiscoveryOptions {}

property include

include?: Function[];

interface ExternalContextOptions

interface ExternalContextOptions {}

property filters

filters?: boolean;

property guards

guards?: boolean;

property interceptors

interceptors?: boolean;

interface HostComponentInfo

interface HostComponentInfo {}

property isTreeDurable

isTreeDurable: boolean;

Flag that indicates whether DI subtree is durable

property token

token: InstanceToken;

Injection token (or class reference)

interface ModuleRefGetOrResolveOpts

interface ModuleRefGetOrResolveOpts {}

property each

each?: boolean;

If enabled, instead of returning a first instance registered under a given token, a list of instances will be returned. false

property strict

strict?: boolean;

If enabled, lookup will only be performed in the host module. true

interface ParamsFactory

interface ParamsFactory {}

method exchangeKeyForValue

exchangeKeyForValue: (type: number, data: ParamData, args: any) => any;

interface RouteTree

interface RouteTree {}

property children

children?: Routes | Type<any>[];

property module

module?: Type<any>;

property path

path: string;

Type Aliases

type ContextIdResolverFn

type ContextIdResolverFn = (info: HostComponentInfo) => ContextId;

type Routes

type Routes = RouteTree[];

type SerializedGraphStatus

type SerializedGraphStatus = 'partial' | 'complete';

Package Files (30)

Dev Dependencies (1)

@nestjs/common

Peer Dependencies (6)

@nestjs/common
@nestjs/microservices
@nestjs/platform-express
@nestjs/websockets
reflect-metadata
rxjs

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@nestjs/core.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@nestjs/core)

HTML

<a href="https://www.jsdocs.io/package/@nestjs/core"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 9 days ago.
Package analyzed in 9351 ms.
Missing or incorrect documentation? Open an issue for this package.