# Introduction

## Motivation

`true-di` is designed to be used with [Apollo Server](https://github.com/apollographql/apollo-server) considering to make resolvers as thin as possible, to keep all business logic testable and framework agnostic by strictly following **S**.**O**.**L**.**I**.**D** Principles.

Despite the origin motivation being related to Apollo Server the library could be used with any other framework or library that supports injection through the context.

The [Getting Started Example](https://github.com/DScheglov/true-di/tree/master/examples/getting-started) shows how to use `true-di` with one of the most popular nodejs libraries: [Express](https://expressjs.com/). Almost all code in the example (\~95%) is covered with tests that prove your business logic could be easily decoupled and kept independent even from dependency injection mechanism.

Thanking to business logic does not depend on specific injection mechanism you can defer the choice of framework. Such deferring is suggested by Robert Martin:

> The purpose of a good architecture is to defer decisions, delay decisions. The job of an architect is not to make decisions, the job of an architect is to build a structure that allows decisions to be delayed as long as possible.

[© 2014, Robert C. Martin: Clean Architecture and Design, NDC Conference](https://vimeo.com/68215570),

Summarizing, `true-di` is based on:

* emulattion of a plain object that allows to specify exact type for each item and makes strict static type checking possible
* explicit dependency injection for business logic (see example: [./src/container.ts](https://github.com/DScheglov/true-di/tree/master/examples/getting-started/src/container.ts))
* transperent injection through the context for framework-integrated components (see example: [./src/index.ts](https://github.com/DScheglov/true-di/tree/master/examples/getting-started/src/index.ts))

## Some useful facts about `true-di`?

1. No syntatic decorators (annotations) as well as `reflect-metadata` are needed
2. `diContainer` uses `getters` under the hood. Container doesn't create an item until your code requests
3. Constructor-injection of cyclic dependency raises an exception
4. The property-, setter- dependency injects is also supported (what allows to resolve cyclic dependencies)
5. `diContainer`-s could be composed
6. Symbolic names are also supported for items

## Installation

```bash
npm i --save true-di
```

```bash
yarn add true-di
```

## Usage Example:

* [Live Demo on Sandbox](https://codesandbox.io/s/github/DScheglov/true-di/tree/master/examples/getting-started?fontsize=14\&hidenavigation=1\&initialpath=%2Forders\&module=%2Fsrc%2Fcontainer.ts\&theme=dark)
* [Example Source Code](https://github.com/DScheglov/true-di/tree/master/examples/getting-started)

{% tabs %}
{% tab title="./src/container.ts" %}

```typescript
import diContainer from 'true-di';
import { ILogger, IDataSourceService, IECommerceService } from './interfaces';
import Logger from './Logger';
import DataSourceService from './DataSourceService';
import ECommerceService from './ECommerceService';

type IServices = {
  logger: ILogger,
  dataSourceService: IDataSourceService,
  ecommerceService: IECommerceService,
}

export default diContainer<IServices>({
  logger: () =>
    new Logger(),

  dataSourceService: ({ logger }) =>
    new DataSourceService(logger),

  ecommerceService: ({ logger, dataSourceService }) =>
    new ECommerceService(logger, dataSourceService),
});
```

{% endtab %}

{% tab title="./src/ECommerceService/index.ts" %}

```typescript
import {
  IECommerceService, IDataSourceService, Order, IInfoLogger
} from '../interfaces';

class ECommerceSerive implements IECommerceService {
  constructor(
    private readonly _logger: IInfoLogger,
    private readonly _dataSourceService: IDataSourceService,
  ) {
    _logger.info('ECommerceService has been created');
  }

  async getOrders(): Promise<Order[]> {
    const { _logger, _dataSourceService } = this;
    // do something
  }

  async getOrderById(id: string): Promise<Order | null> {
    const { _logger, _dataSourceService } = this;
    // do something
  }
}

export default ECommerceSerive;
```

{% endtab %}

{% tab title="./src/controller.ts" %}

```typescript
import Express from 'express';
import { IGetOrderById, IGetOrders } from './interfaces';
import { Injected } from './interfaces/IRequestInjected';
import { sendJson } from './utils/sendJson';
import { expectFound } from './utils/NotFoundError';

export const getOrders = (
  { injected: { ecommerceService } }: Injected<{ ecommerceService: IGetOrders }>,
  res: Express.Response,
  next: Express.NextFunction,
) =>
  ecommerceService
    .getOrders()
    .then(sendJson(res), next);

export const getOrderById = (
  { params, injected: { ecommerceService } }:
    { params: { id: string } } & Injected<{ ecommerceService: IGetOrderById }>,
  res: Express.Response,
  next: Express.NextFunction,
) =>
  ecommerceService
    .getOrderById(params.id)
    .then(expectFound(`Order(${params.id})`))
    .then(sendJson(res), next);
```

{% endtab %}

{% tab title="./src/index.ts" %}

```typescript
import express from 'express';
import container from './container';
import { getOrderById, getOrders } from './controller';
import { handleErrors } from './middlewares';

const app = express();

app.use((req, _, next) => {
  req.injected = container;
  next();
});

app.get('/orders', getOrders);
app.get('/orders/:id', getOrderById);

app.use(handleErrors);

if (module.parent == null) {
  app.listen(8080, () => {
    console.log('Server is listening on port: 8080');
    console.log('Follow: http://localhost:8080/orders');
  });
}

export default app;
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://dscheglov.gitbook.io/true-di/intro.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.