Antônio: Vamos continuar a retomada do nosso projeto. Já configuramos as variáveis de ambiente, Docker e Postgres Admin. Mas, nos deparamos com uma situação problemática onde as tabelas que ainda não foram criadas.
Como fazemos para nos alinhar com o restante do time que já está essas configurações de banco de dados implementadas em suas máquinas?
Para mostrar uma solução mais robusta para esse problema, vamos ir até o cartão "Criar Migrations" na coluna "Backlog" onde temos os cartões prontos para iniciar no Trello organizado pelo time.
Nesse cartão, temos a seguinte informação sobre o projeto:
O Banco de Dados da Compree ainda não possui migrations e está apenas utilizando a opção synchronize: true no Data Source do TypeORM. Essa opção é viável para uso apenas em ambiente de desenvolvimento, pois pode gerar perda de dados em produção.
Vamos implementar as migrations na nossa API para que haja um versionamento de BD mais robusto.
Opção sincronize: true
Vamos mostrar a opção synchronize: true no código para que você possa entender melhor. No VSCode, vamos até "src > config > postgres.config.service.ts". Esse arquivo que criamos no curso anterior faz a integração do NestJS com TypeORM.
postgres.config.service.ts:
@Injectable()
export class PostgresConfigService implements TypeOrmOptionsFactory {
constructor(private configService: ConfigService) {}
createTypeOrmOptions(): TypeOrmModuleOptions {
return {
type: 'postgres',
host: this.configService.get<string>('DB_HOST'),
port: this.configService.get<number>('DB_PORT'),
username: this.configService.get<string>('DB_USERNAME'),
password: this.configService.get<string>('DB_PASSWORD'),
database: this.configService.get<string>('DB_NAME'),
entities: [__dirname + '/../**/*.entity.{js,ts}'],
syncronize: true,
};
}
}
Nele, temos uma classe PostgresConfigService com o decorator @Injectable que implementa a TypeOrmOptionsFactory. Também tem um constructor que pega um configService, esse código já se relaciona com as variáveis de ambiente e como podem ser utilizadas no NestJS.
Por fim, temos o método createTypeOrmOptions() que retorna um objeto que se relaciona ao TypeORM. Esse objeto é o que chamamos de Data Source (fonte de dados) que contém as informações mais importantes para que o TypeORM consiga trabalhar.
Por isso, é nessa fonte de dados que informamos o banco de dados que estamos utilizando, o postgres. Também informamos o host, a porta, o nome de usuário, senha, o banco de dados e até as entidades que serão utilizadas pelo TypeORM.
Note que a última opção se chama syncronize e tem valor true. Essa opção faz o trabalho de criar automaticamente as tabelas e, por vezes, alguns registros a depender do volume guardado no Docker quando rodamos a API.
Se rodamos a API, as tabelas vão ser criadas automaticamente de acordo o esquema de entidades do TypeORM.
Porém, existe um grande problema nessa opção: ela não pode ser utilizada em produção porque pode acarretar em perda de dados. Por isso, é útil apenas para ambientes de desenvolvimento.
Por isso, não vamos utilizar essa opção para produção. Afinal, queremos te mostar quais são as práticas utilizadas no mercado.
Diante disso, vamos apagar a opção sincronize: true de método createTypeOrmOptions() e salvar o arquivo postgres.config.service.ts.
Agora, vamos substituir essa opção pela solução mais robusta utilizada no mercado: as migrations (migrações).
CLI do TypeORM
Para conseguir as migrations que são um recurso específico do TypeORM, precisamos instalar a CLI do TypeORM que é a linha de comando do TypeORM.
Para isso, vamos abrir o terminal integrado do VSCode e digitar npm i -g para instalar globalmente a versão [email protected].
Contudo, ela não vai funcionar necessariamente em conjunto com o projeto Nest, mas vai ser uma parte independente. Inclusive, a API nem precisa estar rodando para utilizar os comandos da CLI.
Vamos dar um "Enter" e aguardar o comando ser executado. Após instalar a CLI do TypeORM, vamos conseguir utilizar qualquer comando precisamos criar um Data Source específico.
Já temos o Data Source no Nest, mas lembra que a CLI não faz parte do projeto? Na verdade, vamos fazer um arquivo que vai configurar um objeto muito parecido com o utilizado no postgres.config.service.ts.
Dentro da pasta "src", vamos criar uma nova pasta chamada "db" que se refere a database. Nessa pasta, criamos um arquivo chamado data-source-cli.ts.
Nesse arquivo, vamos colocar uma configuração específica para o TypeORM. Por isso, digitamos const chamada dataSourceOptions que vai ser do tipo DataSourceOptions. Com isso, fizemos o auto import do tipo DataSourceOptions desde typeorm.
Vamos atribuir a essa constante o objeto que vai ser a fonte de dados. Vamos usar como base o objeto que está sendo retornado pelo método createTypeOrmOptions() em postgres.config.service.ts. Copiamos e colamos esse trecho na atribuição do dataSourceOptions.
Contudo, não vamos utilizar o this.configService porque é específico no NestJS para pegar informações do .env, como as variáveis DB_HOST e DB_PORT.
Na propriedade host, vamos substituir this.configService.get<String>() por process.env. para pegar diretamente da variável de ambiente. Vamos manter o DB_HOST, porém sem aspas, pois vamos remover a string e colocar como propriedade do process.env.
Vamos fazer o mesmo nas outras linhas. Na porta, vamos colocar process.env.DB_PORT. Porém, para não acusar erro de atribuição do tipo string para tipo number, vamos envolver process.env com Number(). Isso porque as variáveis de ambiente vêm automaticamente como string.
Para fazer essa substituição mais rapidamente, você pode posicionar o cursor no início do this.configService na linha de username. Em seguida, aperte "Ctrl + Alt" e a seta para baixo duas vezes para também selecionar as linhas de password e database.
Logo, aperte "Ctrl + Shift" e seta para direita até selecionar o início da string em this.configService.get<String>(). Agora, vamos apagar esse trecho selecionado e escrever process.env. Por fim, basta apagar as aspas e fecha parênteses no final de cada linha.
data-source-cli.ts:
import { DataSourceOptions } from 'typeorm';
const dataSourceOptions: DataSourceOptions = {
type: 'postgres',
host: process.env.DB_HOST,
port: Number(process.env.DB_PORT),
username: process.env.DB_USERNAME,
password: process.env.DB_PASSWORD,
database: process.env.DB_NAME,
entities: [__dirname + '/../**/*.entity.{js,ts}'],
};
Para conseguir utilizar as variáveis de ambiente desse modo, também precisamos instalar o pacote dotenv que ainda não está nesse projeto.
Para isso, abrimos o terminal integrado e escrever o comando para instalar a versão [email protected]
Após instalar, temos que importar o dotenv nesse arquivo data-source-cli.ts. Na primeira linha, importamos dotenv/config entre aspas.
Para finalizar as configurações do arquivo, após dataSourceOptions, vamos escreverconst dataSource que recebe new DataSource(), passando o dataSourceOptions como parâmetro. Com isso, importamos automaticamente o DataSource também desde typeorm.
Por fim, vamos exportar o dataSouce como export default. Essa é a linha que vai servir para a CLI do TypeORM, pois vai conter todas as informações do Data Source.
Essa é a maneira de criar um Data Source, passando as opções como parte do construtor. Só falta mais um detalhe que falta colocar nas opções da fonte de dados.
Após entities, vamos dar "Enter" para escrever migrations na próxima linha. É onde vamos indicar quais são as pastas do projeto que vão conter as migrations, seguindo um padrão similar ao usado da propriedade entities.
Entre colchetes, escrevemos __dirname + e, entre aspas, /migrations/*.{js,ts}. Isso significa que vamos configurar as migrações do projeto dentro da pasta "db" onde está esse arquivo data-source-cli.ts, mas dentro de uma pasta "migrations".
Dentro da pasta "migrations" que ainda vamos criar, vamos capturar qualquer arquivo que termine em .js ou .ts.
import 'dotenv/config';
import { DataSource, DataSourceOptions } from 'typeorm';
const dataSourceOptions: DataSourceOptions = {
type: 'postgres',
host: process.env.DB_HOST,
port: Number(process.env.DB_PORT),
username: process.env.DB_USERNAME,
password: process.env.DB_PASSWORD,
database: process.env.DB_NAME,
entities: [__dirname + '/../**/.entity.{js,ts}'],
migrations: [__dirname + '/migrations/.{js,ts}'],
};
const dataSource = new DataSource(dataSourceOptions);
export default dataSource;
Após salvar esse arquivo, vamos rodar um comando específico da CLI no terminal integrado para testar se o Data Source funciona.
Normalmente, precisaríamos colocar somente typeorm para utilizar os comandos da CLI. Porém, precisamos adicionar também -ts-node-esm porque trabalhamos com tipos TypeScript, como o data-source-cli.ts, e o ECMAScript module. Se não fosse esm, escreveríamos -ts-node-commonjs.
Em seguida, vamos adicionar a opção --dataSource com a letra "S" maiúscula (ou somente o atalho -d) para indicar o caminho do arquivo que acabamos de criar, começando pela raiz do projeto: src/db/data-source-cli.ts.
Agora, podemos dar o comando que queremos executar pela CLI do TypeORM. Nesse caso, o migration:show.
typeorm-ts-node-esm -d src/db/data-source-cli.ts migration:show
Após apertar "Enter", não acontece nada. O que é um bom sinal, já que não houve nenhum erro. Isso significa que conseguiu capturar corretamente as informações do arquivo.
Se tivesse dado algum problema, apareceria o seguinte erro no terminal:
Error during migration show
Error: Given data source file must contain export of a DataSource
O VSCode avisa que houve um erro em mostrar as migrações, pois o arquivo tinha que conter uma instância de Data Source.
Mas, se deu certo, por que não houve nenhum retorno?
Isso porque o comando migration:show mostra todas as migrações existentes no nosso código, porém, ainda não criamos nenhuma. Contudo, nosso arquivo já está preparado para criar essas migrações - o que vamos fazer no próximo vídeo.