Why you should use dependency injection
Tags: dependencie, injection, typescript
Published: 2021-04-09 15:22:50

As a software developer I've learned dependency injection (DI) longer than I'd like. After the first contact it was love at first sign. 

In this text I'll explain some basics concept and how it will let you life easier.

# First...what is a dependency?
In the world around you, a dependency is the state of existence of an entity or an item such that its stability is dictated by another entity or resource. For example, children are dependents on their parents to survive, plants are dependent on water and sunligth, and so on.

In the setting of coding, the definition of dependency shifts somewhat.

When class A uses some functionality of class B, then its said that class A has a dependency of class B. In Typescript, before we can use methods of other classes, we first need to create the object of that class. For example, you a have a controller class responsible to receive the signup request.

The SignUp controller tasks are:
* Validate the fields from the request. Check if received name, email, password and password confirmation correctly.
* Signup the user. Save the user data in the database.
* Auth the user and send him a token.

In this example we see clearly that the signup class hast at least three dependencies. Without DI we could write our class like this:

```typescript
class SignUpController{
  async handle (httpRequest: HttpRequest): Promise<HttpResponse> {
      const validation = new Validation() // First dependency
      const error = validation.validate(httpRequest.body)
      if (error) {
        .... return 400 Bad Request
      }

      const { name, email, password } = httpRequest.body
      
      const addAccount = new AddAccount() // Sencond dependency
      const account = await addAccount.add({ email, password, name })

      if (!account) {
        ... return 403 Forbidden
      }
      
      const authentication = new Authentication() // Third dependency
      const accessToken = await this.authentication.auth({ email, password })
      ...return 200 with a token JWT
  }
}
```      

# What is dependency injection?
Dependency injection is a programming technique that makes a class independent of its dependencies.

In the code above we see that the dependencies are being initialized within the method. That is not a good way to code because it became your code less easy to change (more coupling) and more difficult to test.

Instead of create the objects of another classes we could receive the objects in the constructor of the SignUp class. Hence the name: Dependency Injection. It injects the objects inside the class. 

```typescript
class SignUpController
    constructor (
      private readonly addAccount: AddAccount,
      private readonly validation: Validation,
      private readonly authentication: Authentication
    ) { }

    ...

}
```
   
# Why does DI help with decoupling?

In the code above AddAccount, Validation and Authentication are interfaces. This allows our class to be independent of wich class will implement their respective methods. Our class don't care if we are using MongoDB or Postgres, if we are using a own class to validate or a third-party package.

So it's not necessary change our method if we decide to change some of the depencies implementation as long as it remains obeying the interface.

# Why does DI help with testing?

I'll will explain this with example.

Imagine if we have to test if the method is returning 403 if the email provided is already in use.

Fisrt scenario - Not using DI
```typescript
test('Should return 403 if email is already in use', async () => {
    const signUpController = new SignUpController()
    await signUpController .handle(makeFakeRequest('vitor@email.com')) // Creating the first user with the email
    const httpResponse = await signUpController.handle(makeFakeRequest('vitor@email.com')) // Trying to create the second user with the same email
    expect(httpResponse).toEqual(forbidden(new FieldInUseError('Email'))) // Expect to receive 403
})
```
Second scenario - Using DI
```typescript
test('Should return 403 if AddAccount returns null', async () => {
    const addAccountStub = new AddAccountStub() // Creating a stub class that implements the AddAccount interface
    const signUpController = new SignUpController(addAccountStub, ...) // It has to send the others dependencies too
    jest.spyOn(addAccountStub, 'add').mockReturnValueOnce(null) // Setting a null return on the method add of the addAccountStub object
    const httpResponse = await sut.handle(makeFakeRequest('vitor@email.com')) // Creating the user with the email
    expect(httpResponse).toEqual(forbidden(new FieldInUseError('Email')))
})
```

In terms of quantity of code the first scenario seems to be shorter than the first. It's correct!! Using DI we have to write more code but we have more power to controll the returns of its dependencies. The main reason why DI helps to write unit test is because whe can mock the dependencies and control everything. If we are testing on method, we simply mock a return of another method to not disturb the test.

# Conclusion

DI is not very easy to understand on the first glance for someone who don't use it because it's counterintuitive to write more code and increase the complexity but at the moment we start to write unit test, it is clear how important DI is. It decreases the necessity to know each detail of implementation of other classes dependencies.
It allows changes and become your code more reusable. In my point of view, DI it's essential in most cases.

# Study more

* https://www.youtube.com/watch?v=oqYRl06DNHQ
* https://www.freecodecamp.org/news/a-quick-intro-to-dependency-injection-what-it-is-and-when-to-use-it-7578c84fa88f/