Class Container

Dependency injection container that can create objects marked with the injectable and automatically resolving their dependencies.

To use the container mark any class with the injectable-decorator. injectable allows specifying the lifecycle policy of the object which determines if the container will create a new instance or use the existing instance of the class registered in the container.

The container resolves all undefined constructor parameters and all properties marked with injectable.property.

Circular references are supported and handled by using a lzy resolution proxy.

Usage:

@injectable()
class Bar {
   constructor(private foo: Foo) {
   }

   public helloFooBar() {
       this.foo.helloBar();
   }

   public hello() {
       console.log('Hello!');
   }
}

@injectable()
class Foo {
   constructor(public bar: Bar) {
   }

   public helloBar() {
       this.bar.hello();
   }
}

container.get(Foo).helloBar(); // prints 'Hello!'
container.get(Foo).bar.helloFooBar(); // prints 'Hello!'

Hierarchy

Container

Constructors

constructor

new Container(logger?, parent?): Container
Parameters
- logger: any = ...
- Optional parent: Container
Returns Container
- Defined in packages/core/src/container.ts:156

Properties

`Private` `Readonly` containerGuid

containerGuid: string = ...

`Private` `Readonly` containerPath

containerPath: string

`Private` `Readonly` factories

factories: Map<string, {
lifecycle?: LifecyclePolicy;
new: ServiceFactory<object>;
}> = ...

Type declaration

Optional lifecycle?: LifecyclePolicy
new: ServiceFactory<object>

`Private` `Readonly` instances

instances: Map<string, any> = ...

`Private` `Readonly` logger

logger: Logger = ...

`Private` `Optional` `Readonly` parent

parent?: Container

`Private` `Readonly` providers

providers: Map<string, ((receiver) => any)> = ...

Type declaration

- (receiver): any
- Parameters
  - receiver: any
  Returns any

`Private` `Readonly` resolveStack

resolveStack: string[] = ...

`Private` `Readonly` serviceDependencies

serviceDependencies: Map<string, string[]> = ...

`Private` `Readonly` serviceTypes

serviceTypes: Map<string, {
ctor: ServiceCtor<object>;
options?: ServiceOptions;
}[]> = ...

`Private` `Readonly` servicesProvided

servicesProvided: symbol = ...

useInstanceProxies

useInstanceProxies: boolean = false

Wrap all instance created by this container in Proxies. When set to true each service instance created by this container is wrapped in a Proxy. Proxied service instances behave the same way as non-proxied service instances but each call will be routed through the proxy which can impact performance.

For now the recommended setting is false unless you need to dynamically swap service instances without recreated the dependencies that use them.

For circular references proxies will always be used even when useInstanceProxies is set to false

`Static` root

root: Container

Global root container; by default all services are contained in there

Accessors

isRoot

get isRoot(): boolean
Returns true if this container is the root container of the application. The root container is the container that is created by default and contains all services by default.

Returns boolean
- Defined in packages/core/src/container.ts:141

Methods

create

create<T>(ctor, ...params): InstanceType<T>
Create a new instance of a type resolving constructor parameters as dependencies using the container. The returned class is not registered in the container as dependency.
Type Parameters
- T extends (new (...args) => any)
Parameters
- ctor: T
 
 Constructor/Type to instantiate
- Rest ...params: PartialArray<ConstructorParameters<T>, any>
 
 Constructor params provided
Returns InstanceType<T>
New instance of an object who's dependencies are resolved by the container
- Defined in packages/core/src/container.ts:282

createAndRegister

createAndRegister<T>(ctor, ...params): void
Create a new instance of a type resolving constructor parameters as dependencies using the container and register it as a dependency.
Type Parameters
- T extends (new (...args) => any)
Parameters
- ctor: T
 
 Constructor/Type to instantiate
- Rest ...params: PartialArray<ConstructorParameters<T>, any>
 
 Constructor params provided
Returns void
- Defined in packages/core/src/container.ts:291

`Private` createInstance

createInstance<T>(ctor, args?): InstanceType<T>
Creates a new instance of the specified type resolving dependencies using the current container context. The returned class is not registered in the container as dependency.
Type Parameters
- T extends (new (...args) => any)
Parameters
- ctor: T
 
 Constructor type/prototype class definition
- args: any[] = []
Returns InstanceType<T>
- Defined in packages/core/src/container.ts:300

`Private` decorateWithServiceGuid

decorateWithServiceGuid<T>(instance, guid?): T
Type Parameters
- T
Parameters
- instance: T
- Optional guid: string
Returns T
- Defined in packages/core/src/container.ts:402

dispose

dispose(): void
Dispose all services; factories and provides in this container.

Returns void
- Defined in packages/core/src/container.ts:173

`Private` generateServiceGuid

generateServiceGuid(ctor): string
Parameters
- ctor: any
Returns string
- Defined in packages/core/src/container.ts:397

get

get<T>(service, overrideLifecycle?): T
Safe version of resolve that never returns undefined and throws an Error for services that cannot be resolved.
Type Parameters
- T extends object
Parameters
- service: ServiceType<T>
 
 Service type for which to resolve the concrete class
- Optional overrideLifecycle: LifecyclePolicy
Returns T
- Defined in packages/core/src/container.ts:267

`Private` getPrototypes

getPrototypes(instance): {
constructor: (new (...args) => any);
}[]
Parameters
- instance: any
Returns {
constructor: (new (...args) => any);
}[]
- Defined in packages/core/src/container.ts:445

`Private` getServiceName

getServiceName<T>(service): string
Type Parameters
- T extends object
Parameters
- service: ServiceType<T>
Returns string
- Defined in packages/core/src/container.ts:582

new

new(options?): Container
Create a new container that inherits all configuration form the parent but on top of that can register or overwrite dependencies; by default dependency resolution is first attempted using the providers, factories and registered service instance in the new container; if that fails it resolution is delegated to the parent until the root container which will throw an exception in case it cannot resolve the requested module.
Parameters
- Optional options: {
  isolated?: boolean;
  }
  - Optional isolated?: boolean
Returns Container
- Defined in packages/core/src/container.ts:166

register

register<T>(instances, options?): void
Register an already instantiated service/class in the container, if the instance provides one or more services which are registered using the injectable decorator then those services will be made available in the container.
Type Parameters
- T extends object
Parameters
- instances: T | T[]
- Optional options: {
 additionalServiceTypes?: ServiceType<T>[];
 }
 - Optional additionalServiceTypes?: ServiceType<T>[]
 
 additional service types to register the instance for
Returns void
- Defined in packages/core/src/container.ts:429

registerAs

registerAs<T, I>(instance, services): void
Register an instance in the container as the specified service service shape
Type Parameters
- T extends object
- I extends object = T
Parameters
- instance: I
 
 Instance providing the service
- services: ServiceType<T> | ServiceType<T>[]
 
 Service or array of service shapes provided
Returns void
the instance
- Defined in packages/core/src/container.ts:459

registerFactory

registerFactory<T, I>(services, factory, lifecycle?): void
Register a factory that can provide an instance of the specified factory
Type Parameters
- T extends object
- I extends object = T
Parameters
- services: ServiceType<T> | ServiceType<T>[]
 
 list of services to register
- factory: ServiceFactory
 
 factory that produces the an instance
- lifecycle: LifecyclePolicy = LifecyclePolicy.transient
Returns void
- Defined in packages/core/src/container.ts:530

registerProvider

registerProvider<T, I>(service, provider): void
Type Parameters
- T extends object
- I extends object = T
Parameters
- service: ServiceType<T>
- provider: ((receiver) => undefined | I | Promise)
 - - (receiver): undefined | I | Promise
 - Parameters
 
 receiver: any
 
 Returns undefined | I | Promise
Returns void
- Defined in packages/core/src/container.ts:577

registerProxyService

registerProxyService<T>(type): ProxyTarget<T>
Register a service proxy that can be manually set with a concrete instance later on. Any instance that request a service of type T will receive the proxy instance.

The proxy is not registered as a factory type.

The proxy instance can be set using the setInstance method on the ProxyTarget returned by this method.
Type Parameters
- T extends object
Parameters
- type: {
 name: string;
 prototype: T;
 }
 
 Service type to register
 - name: string
 - prototype: T
Returns ProxyTarget<T>
ProxyTarget instance that can be used to set the concrete instance
- Defined in packages/core/src/container.ts:563

registerType

registerType<T, I>(type, services, serviceOptions?): void
Registers a type in the container as provider of services; type specified is dynamically created when required injecting any resolving any dependency required
Type Parameters
- T extends object
- I extends object = T
Parameters
- type: ServiceCtor
 
 Type to register
- services: ServiceType<T> | ServiceType<T>[]
 
 list of services to register
- Optional serviceOptions: Partial<ServiceOptions>
 
 options including lifecycle policy of the service
Returns void
- Defined in packages/core/src/container.ts:543

removeInstance

removeInstance(instance): void
Drops an active singleton service instance from the container causing subsequent resolutions to create a new instances instead of reusing the existing one.
Parameters
- instance: object
  
  the instance to remove
Returns void
- Defined in packages/core/src/container.ts:487

resolve

resolve<T>(service, overrideLifecycle?, receiver?, resolver?): undefined | T
Resolve requested service to an implementation.
Type Parameters
- T extends object
Parameters
- service: ServiceType<T>
 
 Service type for which to resolve a concrete class
- Optional overrideLifecycle: LifecyclePolicy
 
 Use an alternate lifecycle policy
- Optional receiver: (new () => object)
 
 Class ctor for which we are resolving this
 - - new (): object
 - Returns object
- resolver: Container = ...
Returns undefined | T
- Defined in packages/core/src/container.ts:194

resolveParameters

resolveParameters<T>(ctor, args?, instanceGuid?): any[]
Resolve injectable parameters for a service using this container.
Type Parameters
- T extends (new (...args) => any)
Parameters
- ctor: T
  
  Constructor function
- args: any[] = []
  
  arguments
- Optional instanceGuid: string
  
  instance guid
Returns any[]
- Defined in packages/core/src/container.ts:336

resolveProperties

resolveProperties<T>(instance): T
Resolve injectable properties for a service using this container.
Type Parameters
- T
Parameters
- instance: T
  
  Instance object
Returns T
instance
- Defined in packages/core/src/container.ts:375

`Private` trackServiceDependencies

trackServiceDependencies(serviceGuid, dependsOn): void
Register a new dependency between two services
Parameters
- serviceGuid: string
  
  the instance guid of the object that owns the dependency
- dependsOn: object
  
  instance of the dependency
Returns void
- Defined in packages/core/src/container.ts:414

`Static` get

get(instance): undefined | Container
Get's the container that owns or created the specified instance.
Parameters
- instance: object
Returns undefined | Container
- Defined in packages/core/src/container.ts:325

Class Container

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

logger: any = ...

Optional parent: Container

Returns Container

Properties

Private Readonly containerGuid

Private Readonly containerPath

Private Readonly factories

Type declaration

Optional lifecycle?: LifecyclePolicy

new: ServiceFactory<object>

Private Readonly instances

Private Readonly logger

Private Optional Readonly parent

Private Readonly providers

Type declaration

Parameters

receiver: any

Returns any

Private Readonly resolveStack

Private Readonly serviceDependencies

Private Readonly serviceTypes

Private Readonly servicesProvided

useInstanceProxies

Static root

Accessors

isRoot

Returns boolean

Methods

create

Type Parameters

T extends (new (...args) => any)

Parameters

ctor: T

Rest ...params: PartialArray<ConstructorParameters<T>, any>

Returns InstanceType<T>

createAndRegister

Type Parameters

T extends (new (...args) => any)

Parameters

ctor: T

Rest ...params: PartialArray<ConstructorParameters<T>, any>

Returns void

Private createInstance

Type Parameters

T extends (new (...args) => any)

Parameters

ctor: T

args: any[] = []

Returns InstanceType<T>

Private decorateWithServiceGuid

Type Parameters

T

Parameters

instance: T

Optional guid: string

Returns T

dispose

Returns void

Private generateServiceGuid

Parameters

ctor: any

Returns string

get

Type Parameters

T extends object

Parameters

service: ServiceType<T>

Optional overrideLifecycle: LifecyclePolicy

Returns T

Private getPrototypes

`Optional` parent: Container

`Private` `Readonly` containerGuid

`Private` `Readonly` containerPath

`Private` `Readonly` factories

`Optional` lifecycle?: LifecyclePolicy

`Private` `Readonly` instances

`Private` `Readonly` logger

`Private` `Optional` `Readonly` parent

`Private` `Readonly` providers

`Private` `Readonly` resolveStack

`Private` `Readonly` serviceDependencies

`Private` `Readonly` serviceTypes

`Private` `Readonly` servicesProvided

`Static` root

`Rest` ...params: PartialArray<ConstructorParameters<T>, any>

`Rest` ...params: PartialArray<ConstructorParameters<T>, any>

`Private` createInstance

`Private` decorateWithServiceGuid

`Optional` guid: string

`Private` generateServiceGuid

`Optional` overrideLifecycle: LifecyclePolicy

`Private` getPrototypes

Returns {
constructor: (new (...args) => any);
}[]

`Private` getServiceName

`Optional` options: {
isolated?: boolean;
}

`Optional` isolated?: boolean

`Optional` options: {
additionalServiceTypes?: ServiceType<T>[];
}

`Optional` additionalServiceTypes?: ServiceType<T>[]

type: {
name: string;
prototype: T;
}

`Optional` serviceOptions: Partial<ServiceOptions>