Binding Scopes

This section documents controlling the scope of the dependencies.

inSingletonScope()

Each getting will return the same instance.

Example

container.bind(TOKENS.apiService).toInstance(ApiService).inSingletonScope();

const apiServiceFirst = container.get(TOKENS.apiService);

const apiServiceSecond = container.get(TOKENS.apiService);

expect(apiServiceFirst).toBe(apiServiceSecond);

---

inTransientScope()

New instance will be created with each getting.

Example

container.bind(TOKENS.apiService).toInstance(ApiService).inTransientScope();

const apiServiceFirst = container.get(TOKENS.apiService);

const apiServiceSecond = container.get(TOKENS.apiService);

expect(apiServiceFirst).not.toBe(apiServiceSecond);

---

inContainerScope()

The container will return the same instance with each getting. This is similar to being a singleton, however if the container has a child container or a clone, that child container or clone will get an instance unique to it.

Example

const parentContainer = new Container();

parentContainer

.bind(TOKENS.apiService)

.toInstance(ApiService)

.inTransientScope();

const childContainer = new Container(parentContainer);

/* Getting instances from the parent container. */

const apiServiceParentFirst = parentContainer.get(TOKENS.apiService);

const apiServiceParentSecond = parentContainer.get(TOKENS.apiService);

/* Getting instances from the child container */

const apiServiceChildFirst = childContainer.get(TOKENS.apiService);

const apiServiceChildSecond = childContainer.get(TOKENS.apiService);

/* The instances gotten from the same container are the same. */

expect(apiServiceParentFirst).toBe(apiServiceParentSecond);

expect(apiServiceChildFirst).toBe(apiServiceChildFirst);

/* The instances gotten from different containers are different. */

expect(apiServiceParentFirst).not.toBe(apiServiceChildFirst);

expect(apiServiceParentSecond).not.toBe(apiServiceChildSecond);

---

inResolutionScope()

The same instance will be got for each getting of this dependency during a single resolution chain.

Example

class EmailService {}

class SettingsService {

constructor(public emailService: EmailService) {}

}

class UserService {

constructor(

public settingsService: SettingsService,

public emailService: EmailService,

) {}

}

const TOKENS = {

emailService: token<EmailService>('emailService'),

settingsService: token<SettingsService>('settingsService'),

userService: token<UserService>('userService'),

};

injected(SettingsService, TOKENS.emailService);

injected(UserService, TOKENS.settingsService, TOKENS.emailService);

const container = new Container();

container

.bind(TOKENS.emailService)

.toInstance(EmailService)

.inResolutionScope(); /* ← `EmailService` in resolution scope. */

container

.bind(TOKENS.settingsService)

.toInstance(SettingsService)

.inTransientScope();

container.bind(TOKENS.userService).toInstance(UserService).inTransientScope();

const userService = container.get(TOKENS.userService);

/* `EmailService` instances are the same for this resolution chain. */

expect(userService.emailService).toBe(userService.settingsService.emailService);