# @crux/di

> `@crux/di` is a TypeScript dependency injection container for node and the front-end.

Latest version **0.0.45-alpha** (published 2022-10-12) · 0 weekly downloads

## Install

```sh
npm install @crux/di
pnpm add @crux/di
yarn add @crux/di
bun add @crux/di
```

## Health

**Score 25/100 (F)** — status: abandoned.

Positive: has types; esm support; no vulnerabilities.

Warnings: low downloads; pre 1.0.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 0.0.45-alpha |
| Published | 2022-10-12 |
| First published | 2021-08-27 |
| Weekly downloads | 0 |
| TypeScript types | bundled |
| Module format | ESM + CommonJS |
| Dependencies | 0 |
| Unpacked size | 8 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| Maintainers | andyjessop |

## Links

- npm: https://www.npmjs.com/package/@crux/di
- npm.io page: https://npm.io/package/@crux/di

## Recent versions

- 0.0.45-alpha (latest) — 2022-10-12
- 0.0.44-alpha — 2022-09-26
- 0.0.43-alpha — 2022-09-26
- 0.0.42-alpha — 2022-09-26
- 0.0.41-alpha — 2022-09-23
- 0.0.40-alpha — 2022-08-23
- 0.0.39-alpha — 2022-08-19
- 0.0.38-alpha — 2022-08-19
- 0.0.37-alpha — 2022-08-19
- 0.0.36-alpha — 2022-08-18
- 0.0.35-alpha — 2022-08-12
- 0.0.34-alpha — 2022-08-09
- 0.0.33-alpha — 2022-08-08
- 0.0.32-alpha — 2022-08-08
- 0.0.31-alpha — 2022-08-07
- … 17 more at https://npm.io/package/@crux/di/versions

## README

# @crux/di

`@crux/di` is a TypeScript dependency injection container for node and the front-end.

## Installation

```bash
npm install --save @crux/di
```

## Usage

### Creating the container

```ts
import { di } from '@crux/di';

async function cache() = {
  return import('./cache-service').then(mod => mod.cacheService);
}

const container = di({
  cache: { factory: cache },
});
```

And the service:

```ts
// ./cache-service
export function cacheService() {
  return {
    get: (key: string) => {
      // retrieve key from cache
    },
    set: (key: string, value: unknown) => {
      // set value in cache
    }
  }
}
```

### Retrieving a service from the container

```ts
async function doSomething() {
  const cache = await container.get('cache');

  cache.get('myVal'); // get method is inferred by TypeScript here.
}
```

Notice that all services are retrieved asynchronously, which encourages you to dynamically import them to help code splitting in your app. The service has been lazily instantiated.

### Defining dependencies for a service

Your service may well not be standalone. For instance, your data service might depend on an http service. Let's see how you would define that in `@crux/di`.

The data service itself:

```ts
// ./data-service
export function dataService(http: httpService) {
  return {
    getUsers: () => http.get('/users'),
  }
}
```

Pulling it all together:

```ts
// The dynamic import.
async function data() = {
  return import('./data-service').then(mod => mod.cache);
}

const container = di({
  data: { factory: data, deps: ['http'] }, // 'http' refers to the key of the http service below
  http: { factory: http }
});

// Inside an async function
const data = await container.get('data');

const users = await data.getUsers();
```

Notice that `@crux/di` injected the `http` dependency into the data service when it was instantiated. You can have as many deps as you like and they are injected in order. For example:

```ts
const container = di({
  cache: { factory: cache }
  data: { factory: data, deps: ['http', 'cache'] },
  http: { factory: http }
});
```

Where the data service might now be something like:

```ts
export function dataService(http: httpService, cache: cacheService) {
  return {
    getUsers: () => http.get('/users').then(users => cache.set('users', users)),
  }
}
```

In order to inject a service as a singleton, define a separate service for each that you need:

```ts
const container = di({
  cache: { factory: cache, deps: ['httpCache'] },
  data: { factory: data, deps: ['httpData'] },
  httpCache: { factory: http },
  httpData: { factory: http },
});
```

This will ensure that the `data` service has a unique instance of the `http` service injected into it.

---
_Source: https://npm.io/package/@crux/di · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._