Pointers and Registrators

Pointers

A pointer in Brandi terminology is a unique value that is used for relating entities.

token<T>(description)

Creates a unique token with the type.

Arguments

1. description: string — a description of the token to be used in logs and error messages.

Returns

Token<T> — a unique token with the type.

Type Safety

The token mechanism in Brandi provides type safety when binding and getting dependencies.

import { Container, token } from 'brandi';

const TOKENS = {

apiKey: token<string>('API Key') /* ← The token with `string` type. */,

};

const container = new Container();

/* ↓ Binding the `string` type value. It's OK. */

container.bind(TOKENS.apiKey).toConstant('#key9428');

/**

* ↓ Trying to bind the `string` type token to the `number` type value:

* TS Error: `Argument of type 'number' is not assignable

* to parameter of type 'string'. ts(2345)`.

*/

container.bind(TOKENS.apiKey).toConstant(9428);

const key = container.get(TOKENS.apiKey);

type Key = typeof key; /* ← The type is derived from the token. `type Key = string;`. */

/* ↓ TS Error: `Type 'string' is not assignable to type 'number'. ts(2322)` */

const numKey: number = container.get(TOKENS.apiKey);

---

tag(description)

Creates a unique tag.

Arguments

1. description: string — a description of the tag to be used in logs and error messages.

Returns

Tag — a unique tag.

---

Registrators

injected(target, ...tokens)

Registers target injections.

Arguments

1. target — constructor or function whose dependencies will be injected.
2. ...tokens: TokenValue[] — dependency tokens.

Returns

target — the first argument.

Example

ApiService.ts

import { injected } from 'brandi';

import { TOKENS } from './tokens';

import { Logger } from './Logger';

export class ApiService {

constructor(private apiKey: string, private logger?: Logger) {}

}

injected(ApiService, TOKENS.apiKey, TOKENS.logger.optional);

Type Safety

Injections in Brandi are strictly typed.

tokens.ts

import { token } from 'brandi';

export const TOKENS = {

strKey: token<string>('String API Key'),

numKey: token<number>('Number API Key'),

};

ApiService.ts

import { injected } from 'brandi';

import { TOKENS } from './tokens';

import { Logger } from './Logger';

export class ApiService {

constructor(

private apiKey: string /* ← The `string` type dependency. */,

private logger?: Logger /* ← The optional dependency. */,

) {}

}

injected(

ApiService,

TOKENS.strKey /* ← Injecting the `string` type dependency. It's OK. */,

TOKENS.logger.optional /* ← Injecting the optional dependency. It's OK. */,

);

injected(

ApiService,

TOKENS.numKey, /* ← Injecting the `number` type dependency.

* TS Error: `Type 'number' is not assignable to type 'string'. ts(2345)`.

*/

TOKENS.logger, /* ← Injecting the required value instead of the optional one.

* TS Error: `Argument of type 'Token<Logger>'

* is not assignable to parameter of type 'OptionalToken<Logger>'`.

*/

);

---

tagged(target, ...tags)

Tags target. For more information about tags, see the Conditional Bindings documentation section.

Arguments

1. target — constructor or function that will be tagged.
2. ...tags: Tag[] — tags.

Returns

target — the first argument.

Example

ApiService.ts

import { tagged } from 'brandi';

import { TAGS } from './tags';

export class ApiService {}

tagged(ApiService, TAGS.offline);