Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/wessberg/DI
A compile-time powered Dependency-Injection container for Typescript that holds services and can produce instances of them as required.
https://github.com/wessberg/DI
Last synced: about 2 months ago
JSON representation
A compile-time powered Dependency-Injection container for Typescript that holds services and can produce instances of them as required.
- Host: GitHub
- URL: https://github.com/wessberg/DI
- Owner: wessberg
- License: mit
- Created: 2017-04-24T01:15:56.000Z (over 7 years ago)
- Default Branch: master
- Last Pushed: 2024-06-14T16:23:19.000Z (3 months ago)
- Last Synced: 2024-07-01T00:23:46.893Z (3 months ago)
- Language: TypeScript
- Homepage:
- Size: 299 KB
- Stars: 247
- Watchers: 5
- Forks: 6
- Open Issues: 7
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- Funding: .github/FUNDING.yml
- License: LICENSE.md
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
> A compile-time powered Dependency-Injection container for Typescript that holds services and can produce instances of them as required.
## Description
This is a tiny library that brings Dependency-Injection to Typescript. There are several competing libraries out there, but this one is unique in the sense
that:
- It is _seriously_ small.
- It does its work on compile-time. The only runtime dependency is the `DIContainer` itself.
- It doesn't ask you to reflect metadata or to annotate your classes with decorators. _"It just works"_.
- It maps interfaces to implementations. Most popular dependency injection systems for TypeScript doesn't do this. This allows you to truly decouple an abstraction from its implementation.
- It supports the .NET generic reflection flavour: `registerSingleton()`. No need for anything else.
This library provides constructor-based dependency injection. This means that your classes will receive dependency-injected services as arguments to their constructors.
This library is a runtime dependency, but you need to transform your code with the [`DI Custom Transformer`](https://github.com/wessberg/di-compiler) as part of your Typescript compilation step to make the reflection work.
## Backers
| 
| 
| 
| 
| 
| 
|
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
| [Bubbles](https://usebubbles.com)
Twitter: [@usebubbles](https://twitter.com/usebubbles) | [Christopher Blanchard](https://github.com/cblanc) | [Ideal Postcodes](https://github.com/ideal-postcodes) | [Xerox](https://www.xerox.com) | [Trent Raymond](https://changelog.me) | [scrubtheweb](https://scrubtheweb.com) |
### Patreon
## Table of Contents
- [Description](#description)
- [Backers](#backers)
- [Patreon](#patreon)
- [Table of Contents](#table-of-contents)
- [Install](#install)
- [npm](#npm)
- [Yarn](#yarn)
- [pnpm](#pnpm)
- [Usage](#usage)
- [Registering services](#registering-services)
- [Retrieving instances of services](#retrieving-instances-of-services)
- [Injecting instances of services into classes](#injecting-instances-of-services-into-classes)
- [Getting instances directly from the `DIContainer`](#getting-instances-directly-from-the-dicontainer)
- [Contributing](#contributing)
- [Maintainers](#maintainers)
- [FAQ](#faq)
- [This is pure magic. How does it work?](#this-is-pure-magic-how-does-it-work)
- [Is it possible to have multiple, scoped containers?](#is-it-possible-to-have-multiple-scoped-containers)
- [License](#license)
## Install
### npm
```
$ npm install @wessberg/di
```
### Yarn
```
$ yarn add @wessberg/di
```
### pnpm
```
$ pnpm add @wessberg/di
```
## Usage
This library is meant to be super straightforward, super simple to use.
The following examples hopefully shows that:
### Registering services
To register services, simply instantiate a new service container and add services to it.
Here's several examples of how you may do that:
```typescript
import {DIContainer} from "@wessberg/di";
// Instantiate a new container for services
const container = new DIContainer();
// Register the service as a Singleton. Whenever the 'IMyService' service is requested,
// the same instance of MyService will be injected
container.registerSingleton();
// Register the service as a Transient. Whenever the 'IMyService' service is requested,
// a new instance of MyService will be injected
container.registerTransient();
// Rather than mapping a class to an interface,
// here we provide a function that returns an object that implements
// the required interface
container.registerSingleton(() => myAppConfig);
// You don't have to map an interface to an implementation.
container.registerSingleton();
```
### Retrieving instances of services
#### Injecting instances of services into classes
...Works completely automatically. As long as your class is constructed via
a `DIContainer`, and as long as the services it depends on are registered,
the class will receive the services as arguments to its' constructor:
```typescript
class MyClass {
constructor(
private myService: IMyService,
private myOtherService: IMyOtherService,
private myAwesomeService: MyAwesomeService
) {}
}
```
The true power of this library in comparison to others is that all of this mapping happens on compile-time.
This is what enables you to depend on interfaces, rather than objects that live on runtime.
#### Getting instances directly from the `DIContainer`
Sure, you can do that if you want to:
```typescript
// Gets a concrete instance of 'IMyService'. The implementation will
// depend on what you provided when you registered the service
const service = container.get();
```
## Contributing
Do you want to contribute? Awesome! Please follow [these recommendations](./CONTRIBUTING.md).
## Maintainers
| 
|
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [Frederik Wessberg](mailto:[email protected])
Twitter: [@FredWessberg](https://twitter.com/FredWessberg)
Github: [@wessberg](https://github.com/wessberg)
_Lead Developer_ |
## FAQ
#### This is pure magic. How does it work?
It may look like it, but I assure you it is quite simple. [Read this answer for an explanation](https://github.com/wessberg/di-compiler#how-does-it-work-exactly).
#### Is it possible to have multiple, scoped containers?
Sure. You can instantiate as many as you want to, as long as you make sure the [Custom Transformer for DI](https://github.com/wessberg/di-compiler) get's to see the files that contain them.
## License
MIT © [Frederik Wessberg](mailto:[email protected]) ([@FredWessberg](https://twitter.com/FredWessberg)) ([Website](https://github.com/wessberg))