69 lines
1.7 KiB
Markdown
69 lines
1.7 KiB
Markdown
# Dependency manager
|
|
|
|
This lib provides a simplistic dependency manager.
|
|
|
|
## Features and limitations
|
|
|
|
- It resolves dependencies only when they are needed
|
|
- It detect circular dependency
|
|
|
|
## Usage
|
|
|
|
Create a manager:
|
|
|
|
```typescript
|
|
import { DependencyManager } from 'dependency-manager/mod.ts'
|
|
|
|
const manager = new DependencyManager()
|
|
```
|
|
|
|
Create providers for your dependencies.
|
|
A provider is a function that is called when attempting to retrieve the dependency for the first time.
|
|
It receive the dependency manager, and return the dependency value, or a promise that resolves to it.
|
|
|
|
```typescript
|
|
// dependency-free provider
|
|
function loggerProvider() {
|
|
return console.log
|
|
}
|
|
type Logger = ReturnType<typeof loggerProvider>;
|
|
|
|
// provider that need the 'logger' dependency
|
|
async function fooProvider(manager: DependencyManager) {
|
|
const logger = await manager.resolve<Logger>('logger');
|
|
|
|
return {
|
|
bar: () => logger('bar'),
|
|
baz: () => logger('baz'),
|
|
}
|
|
}
|
|
type Foo = Awaited<ReturnType<typeof fooProvider>>;
|
|
```
|
|
|
|
Register the dependency by passing the `register` method its name and provider:
|
|
|
|
```typescript
|
|
manager.register('logger', loggerProvider);
|
|
manager.register('foo', fooProvider);
|
|
```
|
|
|
|
Retrieve dependencies by resolving them (always asynchrone, even if the provider was synchrone):
|
|
|
|
```typescript
|
|
const foo = await manager.resolve<Foo>('foo');
|
|
foo.bar();
|
|
foo.baz();
|
|
```
|
|
|
|
## Typing
|
|
|
|
Types should be explicitly defined when resolving a dependency.
|
|
|
|
## Errors
|
|
|
|
The `register` method throw an error if:
|
|
- the name is already used.
|
|
|
|
The `resolve` method throw an error if:
|
|
- the name doesn't exist (if no module has been registred with the given name).
|
|
- a circular dependency is detected |