Inversion of control (IoC) container that creates components and manages their lifecycle.

Implements: IConfigurable interface, IReferenceable interface, IUnreferenceable interface, IOpenable interface


The Container class allows you to create an inversion of control (IoC) container that creates components and manages their lifecycle.

Important points

  • The container is driven by configuration, which is usually stored in a JSON or YAML file.
  • The configuration contains a list of components identified by their type or locator, followed by their configuration.
  • On start, a container performs the following actions:
    • Creates components using their types or calls registered factories to create them using their locators.
    • Configures components that implement IConfigurable interface and passes them their configuration parameters.
    • Sets references to components that implement IReferenceable interface and passes them references of all components in the container.
    • Opens components that implement IOpenable interface.
  • On stop, a container reverses the orden of its actions:

Configuration parameters

  • name: context (container or process) name
  • description: human-readable description of the context
  • properties: section of additional descriptive properties


Creates a new instance of the container.

public constructor(name?: string, description?: string)

  • name: string - (optional) container’s name (accessible via ContextInfo)
  • description: string - (optional) container’s description (accessible via ContextInfo)



Configuration of the container

protected _config: ContainerConfig


Container’s references

protected _references: ContainerReferences



protected _logger: ILogger


Container’s information.

protected _info: ContextInfo


Default factories.

protected _factories: DefaultContainerFactory

Instance methods


Adds a factory to the container. The factory is used to create components
added to the container by their locators (descriptors).

public addFactory(factory: IFactory): void

  • factory: IFactory - component factory to be added.


Closes the component and frees used resources.

public close(correlationId: string): Promise<void>

  • correlationId: string - (optional) transaction id used to trace execution through the call chain.


Configures the component by passing its configuration parameters.

public configure(config: ConfigParams): void

  • config: ConfigParams - configuration parameters to be set.


Checks if the component is open.

public isOpen(): boolean

  • returns: boolean - True if the component is open and false otherwise.


Opens the component.

public open(correlationId: string): Promise<void>

  • correlationId: string - (optional) transaction id to trace execution through call chain.


Reads the container’s configuration from a JSON or YAML file and parameterizes it with the given values.

public readConfigFromFile(correlationId: string, path: string, parameters: ConfigParams): void

  • correlationId: string - (optional) transaction id used to trace execution through the call chain.
  • path: string - path to the configuration file
  • parameters: ConfigParams - configuration parameters or null to skip parameterization.


Sets references to dependent components.

public setReferences(references: IReferences): void

  • references: IReferences - references to locate the component dependencies.


Unsets (clears) previously set references to dependent components.

public unsetReferences()


======= config.yaml ========
- descriptor: mygroup:mycomponent1:default:default:1.0
param1: 123
param2: ABC
- type: mycomponent2,mypackage
param1: 321
param2: XYZ
let container = new Container();
container.addFactory(new MyComponentFactory());
let parameters = ConfigParams.fromValue(process.env);
container.readConfigFromFile("123", "./config/config.yml", parameters);
console.log("Container is opened");
await container.close("123");
console.log("Container is closed");

See also