Como usar bancos de dados SQL em um aplicativo NestJS com TypeORM

Um Mapeador Object-Relational (ORM) é uma biblioteca que implementa a técnica de mapeamento Object-Relational. Isso permite que você escreva consultas de banco de dados SQL usando o paradigma orientado a objetos de sua linguagem preferida.

TypeORM é um TypeScript ORM que facilita muito a interface com vários bancos de dados. Ele funciona com bancos de dados SQL, mas também tem uma boa interface com bancos de dados NoSQL, como o MongoDB.

NestJS fornece suporte de alto nível para TypeORM pronto para uso. O pacote dedicado TypeORM torna a integração relativamente fácil.

Etapa 1: instalando dependências

Antes de usar o TypeORM em um aplicativo NestJS, você deve instalá-lo com seu pacote NestJS nativo e seu banco de dados SQL preferido. SQLite é uma opção simples e sem instalação.

Execute o seguinte comando para instalar o TypeORM e seu pacote NestJS nativo, usando o gerenciador de pacotes npm:

npm instalar @nestjs/typeorm typeorm

Execute o seguinte comando para instalar o SQLite:

npm instalar sqlite3

Etapa 2: criar uma entidade

Uma entidade é uma coleção de campos que definem os dados armazenados em um banco de dados. TypeORM usa o arquivo de entidade para criar uma tabela em seu banco de dados.

Siga as etapas abaixo para criar uma entidade:

1. Crie um arquivo em seu módulo de aplicativo e nomeie-o seguindo a convenção de nomenclatura NestJS (.entidade.ts).
2. Em seu arquivo de entidade, importe o Entidade, Coluna, e Coluna Gerada Primária decoradores de tipo.
3. Em seu arquivo de entidade, crie e exporte uma classe.
4. Preencha a classe com os valores que você deseja em seu banco de dados, como Eu iria, nome, etc
5. Anote sua classe de entidade com o decorador Entity. Isso torna sua classe reconhecível para TypeORM como uma entidade.
6. Anote sua propriedade id com o decorador PrimaryGeneratedColumn. Isso diz ao TypeORM para marcar o Eu iria como chave primária e incrementá-la automaticamente.
7. Anote as propriedades restantes com o decorador Column. Isso os adiciona como colunas em seu banco de dados.

Por exemplo:

// src/test/test.entity.ts
importar { Entidade, Coluna, PrimaryGeneratedColumn } a partir de 'tipo';
@Entidade()
exportarclasseTeste{
@PrimaryGeneratedColumn()
 número de identidade;
@Coluna()
 propriedade_1: string;
@Coluna()
 propriedade_2: string;
@Coluna()
 propriedade_3: string;
}

O arquivo de entidade acima cria esta tabela em seu banco de dados:

o Documentação do TypeORM abrange entidades em mais detalhes.

Etapa 3: conectando seu aplicativo a um banco de dados

Agora que sua entidade está configurada, você precisará conectar seu aplicativo a um banco de dados. Este exemplo usa SQLite.

Siga as etapas abaixo para conectar seu aplicativo a um banco de dados:

1. No módulo raiz de seus aplicativos (geralmente o app.module.ts arquivo), importar TypeOrmModule a partir de @nestjs/typeorm.
2. No mesmo arquivo, importe todas as suas entidades.
3. No importações matriz, chame o forRoot método em TypeOrmModule. O método forRoot compartilha a conexão do banco de dados por meio de todos os módulos do seu aplicativo.
4. Passe um objeto vazio como argumento para o método forRoot; este será o objeto de configuração do TypeORM.
5. Adicione uma propriedade, modelo, para o objeto de configuração e defina-o como “sqlite”. A propriedade type denota o nome do banco de dados que você está usando.
6. Adicione outra propriedade, base de dados, para o objeto de configuração e defina-o como “teste.db”. A propriedade database denota seu nome preferido para seu banco de dados.
7. Adicione outra propriedade, entidades, para o objeto de configuração e defina-o como um array vazio. Preencha a matriz vazia com as entidades que você importou anteriormente.
8. Adicione outra propriedade, sincronizar, e defina-o verdadeiro; essa propriedade sincroniza suas entidades com seu banco de dados e o atualiza sempre que você executa o código. Você só deve definir esta propriedade para verdadeiro em desenvolvimento. Durante a produção, você deve configurá-lo para falso para evitar perda de dados.

// src/app.module.ts
importar { Módulo } a partir de '@nestjs/comum';
importar { TypeOrmModule } a partir de '@nestjs/typeorm';
importar { Teste } a partir de './test/test.entity';
importar { Entidade2 } a partir de './entidade/entidade.entidade';
importar { TestModule } a partir de './test/test.module';
@Módulo({
 importações: [
TypeOrmModule.forRoot({
 modelo: 'sqlite',
 base de dados: 'teste.db',
entidades: [Teste, Entidade2],
 sincronizar: verdadeiro, //somente desenvolvimento
 }),
 TestModule,
 ],
controladores: [],
provedores: [],
})
exportarclasseAppModule{}

Etapa 4: criando um repositório

Um repositório é a camada de acesso de uma entidade usada para fazer consultas (inserir, excluir, salvar, localizar, etc.) em uma tabela criada pela entidade no banco de dados. O TypeORM suporta o padrão de design de repositório, portanto, cada entidade possui seu próprio repositório.

O TypeORM cria automaticamente um repositório para sua entidade quando você segue as etapas abaixo:

1. No arquivo de módulo da sua entidade, importe TypeOrmModule a partir de @nestjs/typeorm e importe sua entidade.
2. Criar um importações matriz no @Módulo decorador.
3. Na matriz de importações, chame o paraRecurso método em TypeOrmModule.
4. Passe um array como um argumento para o seu e preencha o array com sua entidade.

// src/test/test.module.ts
importar { Módulo } a partir de '@nestjs/comum';
importar { TypeOrmModule } a partir de '@nestjs/typeorm';
importar { TestController } a partir de './test.controller';
importar {TesteServiço} a partir de './test.service';
importar { Teste } a partir de './test.entity';
@Módulo({
importações: [TypeOrmModule.forFeature([Test])],
provedores: [Serviço de teste],
controladores: [Controlador de teste],
})

Etapa 5: injetando seu repositório em seu serviço usando injeção de dependência

A injeção de dependência é uma técnica de engenharia de software que é uma forma do princípio de inversão de controle. Ele transfere a carga do gerenciamento de dependências do código do cliente para a biblioteca ou serviço do qual depende.

Siga as etapas abaixo para injetar seu repositório em um serviço:

1. Em seu arquivo de serviço, importe Repositório a partir de tipo e a InjectRepository decorador de @nestjs/typeorm. Importe também a entidade que você deseja injetar em seu repositório.
2. Em sua classe de serviço, crie um construtor.
3. Declare um privado variável, repositório, como um parâmetro no construtor para inicializá-lo.
4. Atribua um tipo de Repositório ao repositório com um tipo genérico de sua entidade.
5. Anote repo com o decorador InjectRepository e passe sua entidade como um argumento.

// teste.serviço.ts
importar { Injetável } a partir de '@nestjs/comum';
importar { Repositório } a partir de 'tipo';
importar { InjectRepository } a partir de '@nestjs/typeorm';
importar { Teste } a partir de './test.entity';
@Injetável()
exportarclasseTestService{
construtor(
@InjectRepository(Teste)
 repositório privado: repositório<Teste>,
 ) {}
}

Agora que sua configuração está completa, você pode fazer consultas SQL nele para recuperar ou modificar dados.

Fazendo consultas SQL com TypeORM

Você pode fazer qualquer consulta SQL simples chamando os métodos de repositório do TypeORM no repositório variável dentro de sua classe de serviço. Você também pode criar consultas SQL complexas usando o construtor de consultas do TypeORM.