Conditional Bindings

Brandi allows you to use tags and targets to control which implementation of the abstraction will be injected to a target.

Creating tokens:

tokens.ts

import { token } from 'brandi';

import type { Cacher } from './Cacher';

import type { UserService } from './UserService';

import type { SettingsService } from './SettingsService';

import type { AdminService } from './AdminService';

export const TOKENS = {

cacher: token<Cacher>('cacher'),

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

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

adminService: token<AdminService>('adminService'),

};

Creating tags:

tags.ts

import { tag } from 'brandi';

export const TAGS = {

offline: tag('offline'),

};

Creating two types of cacher with a common interface:

Cacher.ts

export interface Cacher {

/* ... */

}

export class OnlineCacher implements Cacher {

/* ... */

}

export class LocalCacher implements Cacher {

/* ... */

}

Creating some services with a dependency on the Cacher:

UserService.ts

import { injected } from 'brandi';

import { TOKENS } from './tokens';

import { Cacher } from './Cacher';

export class UserService {

constructor(private cacher: Cacher) {}

/* ... */

}

injected(UserService, TOKENS.cacher);

SettingsService.ts

import { injected } from 'brandi';

import { TOKENS } from './tokens';

import { Cacher } from './Cacher';

export class SettingsService {

constructor(private cacher: Cacher) {}

/* ... */

}

injected(SettingsService, TOKENS.cacher);

AdminService.ts

import { injected } from 'brandi';

import { TOKENS } from './tokens';

import { Cacher } from './Cacher';

export class AdminService {

constructor(private cacher: Cacher) {}

/* ... */

}

injected(AdminService, TOKENS.cacher);

Configuring the container:

container.ts

import { Container, tagged } from 'brandi';

import { TOKENS } from './tokens';

import { TAGS } from './tags';

import { OnlineCacher, LocalCacher } from './Cacher';

import { UserService } from './UserService';

import { SettingsService } from './SettingsService';

import { AdminService } from './AdminService';

tagged(SettingsService, TAGS.offline); /* ← Tags `SettingsService`. */

export const container = new Container();

container

.bind(TOKENS.cacher) /* ← Binds to `OnlineCacher` in common cases. */

.toInstance(OnlineCacher)

.inTransientScope();

container

.when(TAGS.offline) /* ← Binds to `LocalCacher` when target tagget by `offline` tag. */

.bind(TOKENS.cacher)

.toInstance(LocalCacher)

.inTransientScope();

container

.when(AdminService) /* ← Binds to `LocalCacher` when target is `AdminService`. */

.bind(TOKENS.cacher)

.toInstance(LocalCacher)

.inTransientScope();

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

container.bind(TOKENS.settingsService).toInstance(SettingsService).inTransientScope();

container.bind(TOKENS.adminService).toInstance(AdminService).inTransientScope();

Dependencies are injected into services based on the tag:

index.ts

import { TOKENS } from './tokens';

import { OnlineCacher, LocalCacher } from './Cacher';

import { container } from './container';

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

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

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

expect(userService.cacher).toBeInstanceOf(OnlineCacher);

expect(settingsService.cacher).toBeInstanceOf(LocalCacher);

expect(adminService.cacher).toBeInstanceOf(LocalCacher);