Organizando importações no Nest.js
Tags: node, typescript, tutorial, architecture
Published: 2022-07-11 21:09:54

**Sumário**
 1. [Contexto](#contexto)
 2. [Preparando o terreno](#preparando-o-terreno)
   1. [tsconfig.json](#tsconfigjson)
   2. [Path Mapping](#path-mapping)
 3. [Configuração](#configura%C3%A7%C3%A3o)
  1. [Configurando o tsconfig.json](#configurando-o-tsconfigjson)
  2. [Configurando o diretório shared](#configurando-o-diret%C3%B3rio-shared)
 4. [Conclusão](#conclus%C3%A3o)

*******

## Contexto 

Estive praticando bastante Nest.js com um pequeno projeto pessoal. No meio do desenvolvimento, o fato de tanto o Auto Import ou mesmo as importações manuais que eu fazia gerarem códigos muito compridos e bagunçados, como no exemplo abaixo, me incomodava bastante.

```js
import { Anything } from '../../../shared/anything.ts';
```

Na prática quando isso se mistura com Services, Controllers, Interceptors e muitas outras coisas, nós temos uma verbosidade muito grande para coisas muito simples e que podem, inclusive, atrapalhar em um processo futuro de leitura do código. Então eu fiquei pensando:

_**Como eu poderia organizar as minhas importações para obter algo bem mais semântico e organizado?**_

Felizmente, sanei minha dúvida e é sobre isso que quero dissertar aqui nesta publicação!

## Preparando o terreno

Antes de começarmos quaisquer configuração é importante que você entenda, de maneira geral, o que vamos ver, por isso, neste tópico, vamos passar pela definição de cada arquivo que vamos manipular.

### tsconfig.json

o arquivo **tsconfig.json** é responsável por especificar as configurações que serão aplicadas na compilação de nosso projeto.

Este arquivo sempre estará localizado na raíz de seu projeto.

### Path Mapping

O TypeScript tem suporte ao **[mapeamento de paths](https://www.typescriptlang.org/pt/docs/handbook/module-resolution.html#path-mapping)**. Esta ferramenta, nos permite definir **keywords** que servirão de atalhos para um caminho específico dentro da nossa aplicação, em outras palavras, nós conseguimos ter um resultado como este abaixo:

```js
import { Anything } from '@shared';
```
Isso confere a nossa aplicação uma organização absurda, além de facilitar a leitura do código.

## Configuração

Neste tópico iremos aplicar de fato toda configuração necessária para alcançarmos nosso objetivo.

### Configurando o tsconfig.json

- Dentro do arquivo `tsconfig.json`, insira a propriedade [moduleResolution](https://www.typescriptlang.org/pt/docs/handbook/module-resolution.html) e defina seu valor como `Node`

```json
"moduleResolution": "Node"
```
- Dentro do arquivo `tsconfig.json`, insira a propriedade [baseUrl](https://www.typescriptlang.org/tsconfig#baseUrl) e defina seu valor como `.`

- Dentro do arquivo `tsconfig.json`, insira a propriedade paths, como no exemplo abaixo:

```json
"paths": {
  "@shared": ["./src/shared/index"]
}
``` 
Ao final, teremos essa configuração:
```json
"moduleResolution": "Node",
"baseUrl": ".",
"paths": {
  "@shared": ["./src/shared/index"]
}
``` 

O que nós fizemos foi possibilitar que ao usarmos a notação `import from {} from "@shared"` o compilador consiga entender que na verdade nós estamos apontando para `./src/shared/index`.

<blockquote>
Entenda que este é apenas um exemplo, adapte para sua necessidade, ok?
</blockquote>

### Configurando o diretório shared

Agora que configuramos todo nosso arquivo `tsconfig.json`, precisamos agora adequar nosso diretório a estrutura desejada, vamos lá!

Primeiro, certifique-se de ter o nosso diretório `shared` de exemplo dentro do diretório `src` com a formatação correta, como no exemplo abaixo: 

```bash
shared
├── index.ts
├── anyfile.ts
├── anyfolder
│   └── index.ts
```

O que nós devemos entender agora é que podemos ter **N** arquivos e diretórios dentro de shared, porém, cada diretório dentro de shared deve conter um index responsável por exportar os arquivos alocados dentro de si, vamos para um exemplo mais claro.

dentro do diretório `anyfolder` crie um arquivo chamado anyfile.ts, dentro deste arquivo insira o código abaixo:

```ts
export class AnyClass {
 constructor(){}
 public anyMethod() {
   return 'Any value';
 }
}
```
agora, ainda no diretório `anyfolder` crie um arquivo chamado index.ts, dentro deste arquivo insira o código abaixo:

```js
import { AnyClass } from './anyfolder';
import { Anyfile  } from './anyfile';

export { AnyClass, Anyfile }
```

Tudo pronto, agora, você pode importar de qualquer lugar da aplicação a classe `AnyClass` simplesmente fazendo isso 

```js
import { AnyClass } from '@shared';
```

## Conclusão

Ao final desta publicação espero que tenha ficado claro a forma como você pode organizar todas as importações de suas aplicação. Vale ressaltar que este formato apresentado não é bala de prata, adapte para sua necessidade. Se restar alguma dúvida, por favor, poste aqui nos comentários, ficarei feliz em ajudar você!

Se este artigo foi útil para você, com certeza pode ser para muitas outras pessoas, o que acha de compartilhar com amigos e grupos?