TypeORM: O ORM que Você Precisa Conhecer para Trabalhar com Node.js e TypeScript
Tags: database, orm, typescript, node
Published: 2024-06-11 14:20:50

No mundo do desenvolvimento web, trabalhar com banco de dados é uma parte essencial da criação de aplicações robustas e escaláveis. Muitas vezes, os desenvolvedores buscam ferramentas que facilitem a interação com bancos de dados relacionais. Uma dessas ferramentas é o TypeORM, um Object-Relational Mapper (ORM) que tem ganhado popularidade entre desenvolvedores que utilizam Node.js e TypeScript. Neste artigo, vamos explorar o que é o TypeORM, suas principais funcionalidades, como começar a usá-lo e algumas dicas úteis para tirar o máximo proveito dessa ferramenta.

## O que é TypeORM?

TypeORM é um ORM que permite aos desenvolvedores trabalhar com bancos de dados relacionais usando uma abordagem orientada a objetos. Ele é escrito em TypeScript e foi projetado para ser usado com Node.js. O TypeORM suporta os principais bancos de dados, incluindo MySQL, PostgreSQL, MariaDB, SQLite, e até mesmo Microsoft SQL Server.

Com TypeORM, você pode definir entidades e relacionamentos diretamente no seu código TypeScript, permitindo uma integração perfeita entre a lógica da aplicação e o banco de dados. Ele também oferece suporte a migrações de banco de dados, permitindo que você mantenha o esquema do banco de dados sincronizado com o código da sua aplicação.

## Principais Funcionalidades do TypeORM

### 1. **Definição de Entidades**

No TypeORM, você define as entidades usando classes TypeScript. Aqui está um exemplo de uma entidade chamada `User`:

```typescript
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    name: string;

    @Column()
    email: string;
}
```

### 2. **Relacionamentos**

O TypeORM suporta todos os tipos de relacionamentos comuns: One-to-One, One-to-Many, Many-to-One e Many-to-Many. Veja um exemplo de um relacionamento One-to-Many entre `User` e `Post`:

```typescript
import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';
import { Post } from './Post';

@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    name: string;

    @Column()
    email: string;

    @OneToMany(() => Post, post => post.user)
    posts: Post[];
}
```

```typescript
import { Entity, PrimaryGeneratedColumn, Column, ManyToOne } from 'typeorm';
import { User } from './User';

@Entity()
export class Post {
    @PrimaryGeneratedColumn()
    id: number;

    @Column()
    title: string;

    @Column()
    content: string;

    @ManyToOne(() => User, user => user.posts)
    user: User;
}
```

### 3. **Repositórios e Gerenciamento de Dados**

Com TypeORM, você pode usar repositórios para gerenciar suas entidades. Aqui está um exemplo de como criar um novo usuário:

```typescript
import { getRepository } from 'typeorm';
import { User } from './entity/User';

const userRepository = getRepository(User);

const newUser = new User();
newUser.name = 'Thiago';
newUser.email = 'thiago@example.com';

await userRepository.save(newUser);
```

### 4. **Migrações**

TypeORM também oferece suporte a migrações, permitindo que você gerencie alterações no esquema do banco de dados de forma controlada:

```bash
typeorm migration:create -n CreateUsersTable
typeorm migration:run
```

## Como Começar com TypeORM

Para começar a usar TypeORM em um projeto Node.js com TypeScript, siga estas etapas:

1. **Instale as dependências necessárias:**

```bash
npm install typeorm reflect-metadata sqlite3
```

2. **Configure o TypeORM:**

Crie um arquivo `ormconfig.json` na raiz do seu projeto com a configuração do banco de dados:

```json
{
  "type": "sqlite",
  "database": "database.sqlite",
  "entities": ["src/entity/**/*.ts"],
  "synchronize": true
}
```

3. **Crie sua primeira entidade:**

No diretório `src/entity`, crie um arquivo `User.ts` com a definição da entidade `User`.

4. **Crie um arquivo de inicialização:**

No diretório `src`, crie um arquivo `index.ts` para inicializar o TypeORM e conectar-se ao banco de dados:

```typescript
import "reflect-metadata";
import { createConnection } from "typeorm";
import { User } from "./entity/User";

createConnection().then(async connection => {
    console.log("Connected to the database");

    const userRepository = connection.getRepository(User);

    const newUser = new User();
    newUser.name = 'Thiago';
    newUser.email = 'thiago@example.com';

    await userRepository.save(newUser);
    console.log("New user saved:", newUser);

}).catch(error => console.log(error));
```

## Dicas para Aproveitar o Máximo do TypeORM

1. **Use TypeScript:**

O TypeORM foi feito para ser usado com TypeScript, então aproveite ao máximo os benefícios de tipagem estática e autocompletar.

2. **Entenda os Decorators:**

Os decorators são uma parte essencial do TypeORM. Familiarize-se com eles para definir suas entidades e relacionamentos de forma eficiente.

3. **Mantenha suas Migrações Organizadas:**

Use migrações para gerenciar alterações no esquema do banco de dados, especialmente em projetos maiores e em produção.

4. **Explore a Documentação:**

A documentação do TypeORM é extensa e bem detalhada. Consulte-a sempre que tiver dúvidas ou precisar de informações adicionais.

## Conclusão

O TypeORM é uma ferramenta poderosa para qualquer desenvolvedor que trabalha com Node.js e TypeScript. Ele facilita a interação com bancos de dados relacionais de forma eficiente e organizada. Se você ainda não experimentou o TypeORM, agora é a hora de começar!

Se você gostou deste artigo e quer ver mais conteúdos sobre desenvolvimento, siga [IamThiago-IT no GitHub](https://github.com/IamThiago-IT). Lá você encontrará projetos interessantes e mais dicas úteis para desenvolvedores.

---

Espero que este artigo tenha ajudado você a entender melhor o TypeORM e como ele pode beneficiar seus projetos. Se tiver alguma dúvida ou sugestão, sinta-se à vontade para deixar um comentário!