Porquê usar bancos de dados SQL em um aplicativo NestJS com TypeORM

Um Mapeador Object-Relational (ORM) é uma livraria 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, porquê o MongoDB.

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

Lanço 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 preposto. 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 install @nestjs/typeorm typeorm

Execute o seguinte comando para instalar o SQLite:

npm install sqlite3

Lanço 2: produzir uma entidade

Uma entidade é uma coleção de campos que definem os dados armazenados em um banco de dados. TypeORM usa o registo de entidade para produzir uma tábua em seu banco de dados.

Siga as etapas aquém para produzir uma entidade:

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

Por exemplo:

import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
@Entity()
export class Test {
@PrimaryGeneratedColumn()
id: number;
@Column()
property_1: string;
@Column()
property_2: string;
@Column()
property_3: string;
}

O registo de entidade supra cria esta tábua em seu banco de dados:

A documentação do TypeORM cobre as entidades com mais detalhes.

Lanço 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. Leste exemplo usa SQLite.

Siga as etapas aquém para conectar seu aplicativo a um banco de dados:

1. No módulo raiz de seus aplicativos (geralmente o app.module.ts registo), importar TypeOrmModule a partir de @nestjs/typeorm.
2. No mesmo registo, 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 porquê argumento para o método forRoot; leste será o objeto de formato do TypeORM.
5. Adicione uma propriedade, padrãopara o objeto de formato e defina-o porquê “sqlite”. A propriedade type denota o nome do banco de dados que você está usando.
6. Adicione outra propriedade, base de dadospara o objeto de formato e defina-o porquê “teste.db”. A propriedade database denota seu nome preposto para seu banco de dados.
7. Adicione outra propriedade, entidades, para o objeto de formato e defina-o porquê um array vazio. Preencha a matriz vazia com as entidades que você importou anteriormente.
8. Adicione outra propriedade, sincronizare 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.

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Test } from './test/test.entity';
import { Entity2 } from './entity/entity.entity';
import { TestModule } from './test/test.module';
@Module({
imports: [
TypeOrmModule.forRoot({
type: 'sqlite',
database: 'test.db',
entities: [Test, Entity2],
synchronize: true, 
}),
TestModule,
],
controllers: [],
providers: [],
})
export class AppModule {}

Lanço 4: criando um repositório

Um repositório é a classe de ingresso de uma entidade usada para fazer consultas (inserir, excluir, salvar, localizar, etc.) em uma tábua 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 maquinalmente um repositório para sua entidade quando você segue as etapas aquém:

1. No registo de módulo da sua entidade, importe TypeOrmModule a partir de @nestjs/typeorm e importe sua entidade.
2. Fabricar 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 porquê um argumento para o seu e preencha o array com sua entidade.

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TestController } from './test.controller';
import { TestService } from './test.service';
import { Test } from './test.entity';
@Module({
imports: [TypeOrmModule.forFeature([Test])],
providers: [TestService],
controllers: [TestController],
})

Lanço 5: injetando seu repositório em seu serviço usando injeção de sujeição

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

Siga as etapas aquém para injetar seu repositório em um serviço:

1. Em seu registo 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órioporquê 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 porquê um argumento.

import { Injectable } from '@nestjs/common';
import { Repository } from 'typeorm';
import { InjectRepository } from '@nestjs/typeorm';
import { Test } from './test.entity';
@Injectable()
export class TestService {
constructor(
@InjectRepository(Test)
private repo: Repository<Test>,
) {}
}

Agora que sua formato está completa, você pode fazer consultas SQL nele para restaurar 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 produzir consultas SQL complexas usando o construtor de consultas do TypeORM.