DEV Community: Jhones Gonçalves

🧠 Como criar uma Fluent API no TypeORM (igual ao Entity Framework)

Jhones Gonçalves — Fri, 10 Oct 2025 15:07:22 +0000

💬 “O TypeORM não tem Fluent API igual ao Entity Framework...”

Pois é — não tinha.

Neste artigo eu vou te mostrar como implementei uma abordagem Fluent no TypeORM com NestJS + DDD,
permitindo definir entidades, enums e value objects sem decorators e sem poluir o domínio.

🎯 O problema

Se você vem do mundo .NET, provavelmente adora o EntityTypeConfiguration<T> do Entity Framework:
mapeamento fortemente tipado, fluente e separado do domínio.

Mas no TypeORM, o padrão é usar decorators:

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

  @Column()
  name: string;
}

Isso acopla o ORM ao domínio, dificulta testes e quebra a ideia de entidades puras do DDD.

🚀 A solução: criar uma Fluent API sobre o TypeORM

A ideia foi construir um EntityBuilder — uma camada que gera EntitySchema dinamicamente, imitando o EntityTypeBuilder do EF.

Assim, em vez de usar decorators, você escreve:

builder
  .property('id', { type: 'uuid', primary: true, generated: 'uuid' })
  .property('statusCode', { type: 'text', default: 'PENDING' })
  .index(['transactionNumber'], { unique: true });

⚙️ A arquitetura base

src/
 ├── domain/
 │    ├── value-objects/
 │    │    └── cpf.vo.ts
 │    ├── enums.ts
 │    └── transaction.ts
 ├── infra/
 │    ├── fluent/
 │    │    ├── entity-builder.ts
 │    │    ├── configs/
 │    │    │    └── transaction.config.ts
 │    │    └── schema-registry.ts
 │    ├── database/
 │    │    └── database.module.ts
 │    └── repositories/
 │         └── transaction.repository.ts
 ├── application/
 │    └── transaction.service.ts
 ├── app.module.ts
 └── main.ts

🧩 1. O domínio puro

Nada de decorators, nada de dependência com banco.

// src/domain/enums.ts
export enum TransactionType {
  CREDIT = 'CREDIT',
  DEBIT = 'DEBIT',
}

export enum TransactionStatus {
  PENDING = 'PENDING',
  COMPLETED = 'COMPLETED',
  CANCELLED = 'CANCELLED',
}

// src/domain/value-objects/cpf.vo.ts
export class Cpf {
  private readonly value: string;

  constructor(value: string) {
    if (!Cpf.isValid(value)) throw new Error('CPF inválido');
    this.value = Cpf.clean(value);
  }

  getValue(): string {
    return this.value;
  }

  static clean(cpf: string): string {
    return cpf.replace(/\D/g, '');
  }

  static isValid(cpf: string): boolean {
    cpf = this.clean(cpf);
    if (cpf.length !== 11 || /^(\d)\1+$/.test(cpf)) return false;
    let sum = 0;
    for (let i = 0; i < 9; i++) sum += parseInt(cpf[i]) * (10 - i);
    let d1 = (sum * 10) % 11; if (d1 === 10) d1 = 0;
    if (d1 !== parseInt(cpf[9])) return false;
    sum = 0;
    for (let i = 0; i < 10; i++) sum += parseInt(cpf[i]) * (11 - i);
    let d2 = (sum * 10) % 11; if (d2 === 10) d2 = 0;
    return d2 === parseInt(cpf[10]);
  }
}

// src/domain/transaction.ts
import { TransactionType, TransactionStatus } from './enums';
import { Cpf } from './value-objects/cpf.vo';

export class Transaction {
  constructor(
    public id: string,
    public transactionNumber: number,
    public typeCode: TransactionType,
    public statusCode: TransactionStatus,
    public amountValue: number,
    public creationDate: Date,
    public cpf: Cpf,
  ) {}
}

🧱 2. O `EntityBuilder`

Esse é o coração da Fluent API:

// src/infra/fluent/entity-builder.ts
import { EntitySchema } from 'typeorm';

export class EntityBuilder<T> {
  private name: string;
  private tableName: string;
  private columns: Record<string, any> = {};
  private indices: any[] = [];
  private relations: Record<string, any> = {};

  constructor(entity: { new (...args: any[]): T }, tableName?: string) {
    this.name = entity.name;
    this.tableName = tableName ?? entity.name.toLowerCase();
  }

  property(name: keyof T, options: any) {
    this.columns[name as string] = options;
    return this;
  }

  index(columns: (keyof T)[], options: any = {}) {
    this.indices.push({ columns: columns as string[], ...options });
    return this;
  }

  relation(name: string, options: any) {
    this.relations[name] = options;
    return this;
  }

  build(): EntitySchema<T> {
    return new EntitySchema<T>({
      name: this.name,
      tableName: this.tableName,
      columns: this.columns,
      indices: this.indices,
      relations: this.relations,
    });
  }
}

⚙️ 3. Configuração fluente da entidade

Aqui está onde a mágica acontece:
você escreve o mapeamento igual ao EF, mas em TypeScript.

// src/infra/fluent/configs/transaction.config.ts
import { Transaction } from '../../../domain/transaction';
import { EntityBuilder } from '../entity-builder';
import { TransactionStatus } from '../../../domain/enums';
import { Cpf } from '../../../domain/value-objects/cpf.vo';

export class TransactionConfig {
  static configure(): EntityBuilder<Transaction> {
    const builder = new EntityBuilder<Transaction>(Transaction, 'transactions');

    builder
      .property('id', { type: 'integer', primary: true, generated: true })
      .property('transactionNumber', { type: 'integer', unique: true, nullable: true })
      .property('typeCode', { type: 'text' })
      .property('statusCode', { type: 'text', default: TransactionStatus.PENDING })
      .property('amountValue', { type: 'decimal', default: 0 })
      .property('creationDate', { type: 'datetime', default: () => 'CURRENT_TIMESTAMP' })
      .property('cpf', {
        type: 'text',
        transformer: {
          to: (cpf: Cpf) => cpf?.getValue(),
          from: (value: string) => new Cpf(value),
        },
      })
      .index(['transactionNumber'], { unique: true })
      .index(['creationDate']);

    return builder;
  }
}

🧠 O transformer faz a ponte entre o banco e o domínio.

Quando grava → cpf.getValue()

Quando lê → new Cpf(value)

🧰 4. Registro automático no TypeORM

// src/infra/fluent/schema-registry.ts
import { TransactionConfig } from './configs/transaction.config';
export const Schemas = [TransactionConfig.configure().build()];

// src/infra/database/database.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Schemas } from '../fluent/schema-registry';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'fluent-demo.db',
      synchronize: true,
      entities: Schemas,
    }),
    TypeOrmModule.forFeature(Schemas),
  ],
  exports: [TypeOrmModule],
})
export class DatabaseModule {}

💾 5. Repositório e uso

// src/infra/repositories/transaction.repository.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Transaction } from '../../domain/transaction';
import { TransactionConfig } from '../fluent/configs/transaction.config';

@Injectable()
export class TransactionRepository {
  constructor(
    @InjectRepository(TransactionConfig.configure().build())
    private readonly repo: Repository<Transaction>,
  ) {}

  async save(transaction: Transaction): Promise<Transaction> {
    return this.repo.save(transaction);
  }

  async findAll(): Promise<Transaction[]> {
    return this.repo.find();
  }
}

🧪 6. Exemplo de uso no serviço

// src/application/transaction.service.ts
import { Injectable } from '@nestjs/common';
import { TransactionRepository } from '../infra/repositories/transaction.repository';
import { Transaction } from '../domain/transaction';
import { TransactionStatus, TransactionType } from '../domain/enums';
import { Cpf } from '../domain/value-objects/cpf.vo';

@Injectable()
export class TransactionService {
  constructor(private readonly repo: TransactionRepository) {}

  async createTransaction(): Promise<Transaction> {
    const txn = new Transaction(
      undefined,
      0,
      TransactionType.CREDIT,
      TransactionStatus.PENDING,
      100,
      new Date(),
      new Cpf('123.456.789-09'),
    );
    return this.repo.save(txn);
  }

  async getAll(): Promise<Transaction[]> {
    return this.repo.findAll();
  }
}

🚀 Resultado final

Ao rodar:

npm start

Você verá no console:

✅ Created transaction: Transaction {
  id: 1,
  transactionNumber: null,
  typeCode: 'CREDIT',
  statusCode: 'PENDING',
  amountValue: 100,
  creationDate: 2025-10-10T12:00:00.000Z,
  cpf: Cpf { value: '12345678909' }
}

🧭 Benefícios

Vantagem	Descrição
🧩 Domínio puro	Nenhum decorator ou dependência de ORM
🧱 Configuração centralizada	Igual ao `EntityTypeConfiguration` do EF
🧠 Suporte a Value Objects	Via `transformer` transparente
🚀 Compatível com NestJS e TypeORM	Usa `EntitySchema` sob o capô
🔄 Extensível	Pode adicionar `.hasMany()`, `.default()`, `.enum()`, etc.

🧭 Conclusão

Essa abordagem traz o melhor dos dois mundos:

O poder do EF Fluent API
A flexibilidade do TypeORM
E o isolamento do DDD.

Agora, seu domínio é totalmente independente da infraestrutura, e o mapeamento é expressivo, limpo e seguro.

Clean Architecture no NestJS 🏛️🚀

Jhones Gonçalves — Mon, 29 Apr 2024 14:51:49 +0000

Introdução 🎉

A arquitetura limpa (Clean Architecture) é um padrão de arquitetura de software que visa criar sistemas altamente testáveis, escaláveis e independentes de frameworks. Neste artigo, vamos explorar como aplicar os princípios da Clean Architecture em um projeto usando o framework NestJS.

O que é Clean Architecture? 🤔📘

A Clean Architecture, proposta por "Robert C. Martin"
, enfatiza a separação de preocupações e a independência de frameworks. Ela consiste em várias camadas concêntricas, cada uma com uma responsabilidade específica. As camadas principais são:

Entities (Entidades): Representam os objetos de negócio do sistema.
Use Cases (Casos de Uso): Implementam as regras de negócio do sistema.
Interfaces: São interfaces que definem como os Use Cases interagem com o mundo externo.
Frameworks e Drivers: São as camadas externas que interagem com o sistema, como frameworks web, bancos de dados, etc.

Implementação no NestJS 🛠️🐦

Vamos implementar a Clean Architecture em um projeto NestJS dividindo-o em módulos e seguindo uma estrutura de pastas que reflete as camadas da arquitetura.

Estrutura de Pastas 📁🔍

src/
├── modules/
│   ├── users/
│   │   ├── domain/
│   │   │   ├── entities/
│   │   │   │   └── user.entity.ts
│   │   │   ├── repositories/
│   │   │   │   └── user.repository.ts
│   │   │   └── services/
│   │   │       └── user.service.ts
│   │   ├── application/
│   │   │   ├── dto/
│   │   │   │   └── create-user.dto.ts
│   │   │   ├── interfaces/
│   │   │   │   └── user.interface.ts
│   │   │   └── use-cases/
│   │   │       └── create-user.use-case.ts
│   │   ├── infrastructure/
│   │   │   └── persistence/
│   │   │       └── user.persistence.module.ts
│   │   └── presentation/
│   │       ├── controllers/
│   │       │   └── user.controller.ts
│   │       ├── dtos/
│   │       │   └── user.dto.ts
│   │       └── view-models/
│   │           └── user.view-model.ts

Descrição das Pastas 📁🔍

Domain: Aqui moram as entidades, repositórios e serviços relacionados ao coração do módulo.
Application: Este é o cérebro do nosso módulo, onde os casos de uso, interfaces e DTOs fazem a mágica acontecer.
Infrastructure: Este é o alicerce do nosso projeto, onde implementamos os detalhes de infraestrutura, como módulos de persistência.
Presentation: Aqui é a hora do show! Contém os controladores, DTOs e view models que dão vida à nossa aplicação.

Conclusão 🎉🚀

A Clean Architecture no NestJS oferece uma maneira estruturada e modular de desenvolver aplicativos, promovendo a testabilidade, a escalabilidade e a manutenibilidade do código. Ao seguir os princípios da Clean Architecture, você pode construir sistemas mais robustos e independentes de frameworks.

Neste artigo, exploramos como organizar um projeto NestJS usando a Clean Architecture e uma estrutura de pastas que reflete as camadas da arquitetura. Espero que isso ajude você a criar aplicativos mais eficientes e fáceis de manter. Vamos construir coisas incríveis juntos! 💪😊

Criando um Repositório Genérico de Leitura com Generics, TypeORM e SQLite no NestJS 🚀

Jhones Gonçalves — Fri, 19 Jan 2024 03:16:32 +0000

Neste artigo, vamos explorar a criação de um repositório genérico de leitura no contexto do NestJS, uma estrutura de aplicativo Node.js para construção de aplicativos escaláveis e eficientes. Utilizaremos Generics, TypeORM (um popular ORM para TypeScript/JavaScript) e SQLite (um banco de dados leve e eficiente) para criar um repositório de leitura flexível e reutilizável.

Iniciando um Projeto NestJS 🚀

Para começar um novo projeto NestJS, certifique-se de ter o Node.js e o npm instalados em sua máquina. Em seguida, abra o terminal e execute os seguintes comandos:

# Instale o NestJS CLI globalmente
npm install -g @nestjs/cli

# Crie um novo projeto NestJS
nest new nome-do-projeto

Isso criará uma estrutura básica para o seu projeto NestJS. Navegue até o diretório recém-criado usando cd nome-do-projeto e continue com as próximas etapas da implementação do repositório genérico de leitura.

Agora, vamos começar a implementar o repositório genérico de leitura usando Generics, TypeORM e SQLite. Fique à vontade para adicionar seu código conforme avançamos no desenvolvimento.

Instalando SQLite e TypeORM no NestJS

Para o nosso projeto NestJS, vamos utilizar o SQLite como banco de dados e o TypeORM como ORM para interagir com o banco de dados. Siga os passos abaixo para configurar essas dependências:

1 - Instalando o SQLite:

O SQLite é um banco de dados leve e eficiente, perfeito para ambientes de desenvolvimento. Para instalá-lo, utilize o seguinte comando:

   npm install --save sqlite3

2 - Instalando o TypeORM:

O TypeORM é um ORM (Object-Relational Mapping) para TypeScript e JavaScript. Ele facilita a interação com o banco de dados SQLite. Instale o TypeORM usando o comando:

npm install --save @nestjs/typeorm typeorm

3 - Configurando a Conexão com o Banco de Dados:

No seu projeto NestJS, vá até o arquivo app.module.ts e importe os módulos do TypeORM e SQLite. Adicione a configuração da conexão ao banco de dados. Seu arquivo app.module.ts pode se parecer com algo assim:

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'db/sql',
      synchronize: true,
      entities: [User], // já vamos criar a entidade
    }),
  ],
})
export class AppModule {}

4 - Criando uma Entidade:

No diretório do seu projeto, crie uma pasta entities. Dentro dessa pasta, crie um arquivo user.entity.ts para representar a entidade do usuário. Exemplo:

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

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

  @Column()
  name: string;

  @Column()
  email: string;
}

5 - Criando a tabela e inserindo o dado:

Rode o comando:

npm run start

Com isso deve criar o arquivo db/sql.

Acesse o banco, no terminal rode o comando abaixo e entrará dentro do sqlite:

sqlite3 db/sql

Faça um insert na base para ter as informações para recuperar:

INSERT INTO user (name,email) VALUES ('Jhones', 'email@dominio.com');

Criando uma Pasta para ViewModels

Para manter uma estrutura organizada e reutilizável em nosso projeto, vamos criar uma pasta chamada viewmodels. Nela, teremos um arquivo chamado base.viewmodel.ts que conterá a classe BaseViewModel. Esta classe fornecerá um modelo base para as ViewModels do nosso sistema.

Criando a Pasta e o Arquivo:
- No diretório do seu projeto, crie uma nova pasta chamada viewmodels. Dentro dessa pasta, crie um arquivo chamado base.viewmodel.ts.
Conteúdo do base.viewmodel.ts:
- Adicione o seguinte conteúdo ao arquivo base.viewmodel.ts:

   export default class BaseViewModel<T extends Record<string, any>> {
     constructor(data?: Partial<T>) {
       this.initializeDefaultValues();
       Object.assign(this, data);
     }

     private initializeDefaultValues(): void {
       const prototype = Object.getPrototypeOf(this);
       const properties = Object.getOwnPropertyNames(prototype);

       for (const property of properties) {
         const defaultValue = this[property];
         if (defaultValue !== undefined) {
           this[property] = defaultValue;
         }
       }
     }
   }

Esta classe BaseViewModel aceita um objeto parcial durante a inicialização e preenche suas propriedades com valores padrão, garantindo uma consistência em todas as ViewModels.

Agora, estamos prontos para utilizar a BaseViewModel como base para as ViewModels específicas do nosso sistema. Isso proporcionará uma estrutura coesa e reutilizável para representar dados no nosso contexto.

Adicionando um Decorator `DefaultValue`

Decorators são uma poderosa ferramenta em TypeScript, permitindo-nos adicionar metadados e comportamentos adicionais às nossas classes e propriedades. Vamos criar um decorator chamado DefaultValue que garantirá valores padrão para propriedades específicas em nossas ViewModels.

Criando a Pasta e o Arquivo:
- No diretório do seu projeto, crie uma nova pasta chamada decorators. Dentro dessa pasta, crie um arquivo chamado default-value.decorator.ts.
Conteúdo do default-value.decorator.ts:
- Adicione o seguinte conteúdo ao arquivo default-value.decorator.ts:

   export default function DefaultValue(defaultValue: any) {
     return function (target: any, propertyKey: string) {
       let value = defaultValue;

       Object.defineProperty(target, propertyKey, {
         get() {
           return value;
         },
         set(newValue) {
           value = newValue !== undefined ? newValue : defaultValue;
         },
         enumerable: true,
         configurable: true,
       });
     };
   }

Este decorator DefaultValue permite definir um valor padrão para propriedades específicas em uma classe. Se a propriedade for configurada como undefined, o valor padrão será aplicado.

Criando uma ViewModel para Usuário

Agora que temos nossa classe base BaseViewModel, podemos criar ViewModels específicas para diferentes entidades do sistema. Vamos começar com uma UserViewModel que representa um usuário.

Criando o Arquivo user.viewmodel.ts:
- Dentro da pasta viewmodels, crie um arquivo chamado user.viewmodel.ts.
Conteúdo do user.viewmodel.ts:
- Adicione o seguinte conteúdo ao arquivo user.viewmodel.ts:

   import DefaultValue from 'src/decorators/default-value.decorator';
   import BaseViewModel from './base.viewmodel';

   export default class UserViewModel extends BaseViewModel<UserViewModel> {
     constructor(data?: Partial<UserViewModel>) {
       super(data);
     }

     @DefaultValue('')
     name: string;

     @DefaultValue('')
     email: string;
   }

Nesta UserViewModel, estamos estendendo a BaseViewModel e definindo duas propriedades: name e email. Além disso, estamos utilizando um decorator @DefaultValue('') que é necessário para quando inicializar a classe o repositório reconheça as propriedades.

Criando uma Pasta para Repositórios

Agora, vamos organizar nossos repositórios em uma pasta chamada repositories. Dentro dessa pasta, criaremos um arquivo chamado read.repository.ts que conterá nosso repositório genérico de leitura.

Criando a Pasta e o Arquivo:
- No diretório do seu projeto, crie uma nova pasta chamada repositories. Dentro dessa pasta, crie um arquivo chamado read.repository.ts.
Conteúdo do read.repository.ts:
- Adicione o seguinte conteúdo ao arquivo read.repository.ts:

   import { InjectEntityManager } from '@nestjs/typeorm';
   import BaseViewModel from 'src/viewmodels/base.viewmodel';
   import { EntityManager } from 'typeorm';

   export class ReadRepository {
     constructor(
       @InjectEntityManager()
       private readonly entityManager: EntityManager,
     ) {}

     public async getAllOrBy<TModel extends BaseViewModel<TModel>>(
       modelType: new () => TModel,
       query: string,
       parameters?: any[],
     ): Promise<TModel[]> {
       const result = await this.entityManager.query(query, parameters);
       return result.map((row: any) => this.mapper<TModel>(row, modelType));
     }

     public async getOne<TModel extends BaseViewModel<TModel>>(
       modelType: new () => TModel,
       query: string,
       parameters?: any[],
     ): Promise<TModel> {
       const result = await this.entityManager.query(query, parameters);
       const resultMapped = result.map((row) =>
         this.mapper<TModel>(row, modelType),
       );
       return resultMapped[0] ?? null;
     }

     private mapper<TModel extends BaseViewModel<TModel>>(
       row: any,
       modelType: new () => TModel,
     ): TModel {
       const instance = new modelType();
       const prototype = Object.getPrototypeOf(instance);

       Object.keys(prototype).forEach((key) => {
         prototype[key] = row[key];
       });

       return prototype;
     }
   }

Este arquivo contém nosso repositório genérico de leitura (ReadRepository). Ele utiliza o TypeORM e o SQLite para realizar operações de leitura no banco de dados e mapeia os resultados para as ViewModels correspondentes.

Agora, estamos prontos para utilizar o ReadRepository em nosso serviço para interações de leitura com o banco de dados.

Utilizando o Repositório Genérico no Controller

Agora que temos nosso repositório genérico de leitura, podemos integrá-lo ao nosso controlador (AppController). Vamos fazer algumas alterações no app.controller.ts para utilizar o ReadRepository e realizar operações de leitura no banco de dados.

Conteúdo Atualizado do app.controller.ts:
- Altere o conteúdo do arquivo app.controller.ts para o seguinte:

   import { Controller, Get, Param } from '@nestjs/common';
import { ReadRepository } from './repositories/read.repository';
import UserViewModel from './viewmodels/user.viewmodel';

@Controller()
export class AppController {
  constructor(private readonly readRepository: ReadRepository) {}

  @Get('/users')
  async getUsers() {
    const query = 'SELECT * FROM user';

    const users = await this.readRepository.getAllOrBy<UserViewModel>(
      UserViewModel,
      query,
    );
    return users;
  }

  @Get('/users/:id')
  async getUser(@Param('id') id: number) {
    // pegar o id da rota
    const query = 'SELECT * FROM user WHERE id = ?';

    const users = await this.readRepository.getOne<UserViewModel>(
      UserViewModel,
      query,
      [id],
    );
    return users;
  }
}

Neste arquivo atualizado, utilizamos o método getAllOrBy para obter todos os usuários e o método getOne para obter um usuário específico com base no ID fornecido na rota.

Essas alterações garantem que nosso controlador utilize o repositório genérico para interações de leitura com o banco de dados SQLite. Continue a implementação do seu projeto, ajustando conforme necessário para atender aos requisitos específicos.

Configurando o Módulo para Injeção de Dependência

Para garantir que o ReadRepository seja injetado corretamente no AppController, é necessário fazer algumas configurações no módulo principal (AppModule). Vamos ajustar o arquivo app.module.ts para incluir o ReadRepository como um provedor.

Conteúdo Atualizado do app.module.ts:
- No arquivo app.module.ts, atualize o conteúdo para incluir o ReadRepository como um provedor:

   @Module({
    imports: [
      TypeOrmModule.forRoot({
        type: 'sqlite',
        database: 'db/sql',
        synchronize: true,
        entities: [User],
    }),
    TypeOrmModule.forFeature([User]),
  ],
  controllers: [AppController],
  providers: [AppService, ReadRepository],
})
export class AppModule {}
   export class AppModule {}

Essas alterações configuram o módulo para reconhecer e injetar corretamente o ReadRepository quando necessário.

Continue a desenvolver seu projeto e, conforme necessário, ajuste essas configurações para atender aos requisitos específicos do seu aplicativo.

Resultado: Personalizando o Retorno da API 🎨

Ao implementar o repositório genérico de leitura e mapear os resultados para objetos ViewModel, conseguimos personalizar o retorno da API de acordo com a estrutura definida no ViewModel. Notavelmente, o campo "id" foi omitido do resultado, proporcionando uma resposta mais alinhada com a estrutura desejada.

Exemplo de Retorno:


[
  {
    "name": "Jhones",
    "email": "email@dominio.com"
  }
]

O mapeamento inteligente no repositório garante que apenas os campos definidos no ViewModel sejam apresentados no resultado final. Isso não apenas simplifica a resposta da API, mas também reforça a consistência nos dados retornados, contribuindo para uma experiência de desenvolvimento mais previsível.

Conclusão 🚀

A implementação de um repositório genérico de leitura com Generics, TypeORM e SQLite no NestJS oferece uma série de benefícios significativos para o desenvolvimento de aplicativos. Ao abstrair as operações de leitura do banco de dados para um repositório genérico, podemos obter ganhos notáveis em termos de reutilização de código, manutenção simplificada e maior coesão.

Principais Benefícios:

Reutilização de Código: O repositório genérico permite que operações de leitura comuns sejam encapsuladas e reutilizadas em todo o aplicativo, reduzindo a duplicação de código. 🔄
Manutenção Simplificada: Mudanças nas operações de leitura podem ser gerenciadas centralmente no repositório genérico, simplificando a manutenção e evitando alterações em várias partes do código. 🛠️
Coerência no Acesso aos Dados: Ao padronizar o acesso aos dados por meio do repositório genérico, promovemos uma abordagem consistente na recuperação de informações do banco de dados. 📊

No exemplo apresentado, utilizamos o NestJS, TypeORM e SQLite para criar um repositório genérico de leitura. Este repositório foi integrado a um controlador que realiza operações de leitura em uma entidade User. Os benefícios proporcionados por essa implementação servem como uma base sólida para expandir e adaptar conforme as necessidades específicas do seu projeto.

Ao seguir as práticas apresentadas neste artigo, você estará apto a criar repositórios de leitura genéricos em seus próprios projetos, promovendo uma arquitetura mais limpa e modular.

Continue explorando e personalizando conforme necessário para atender aos requisitos específicos do seu aplicativo. 🌟

Espero que este artigo tenha sido útil na compreensão e implementação de repositórios genéricos de leitura no NestJS. Boas práticas de programação e sucesso no desenvolvimento do seu projeto! 🚀

Monorepo: Uma Armadilha Disfarçada de Praticidade (Anti-pattern)

Jhones Gonçalves — Fri, 24 Nov 2023 11:01:44 +0000

Introdução:

Nos últimos anos, o conceito de monorepositório, ou monorepo, tem sido propagado como uma solução para todos os males do desenvolvimento de software. No entanto, neste artigo, desafiaremos essa narrativa, expondo as armadilhas e desvantagens associadas ao uso do monorepo em contextos onde ele muitas vezes se revela mais um problema do que uma solução.

Figura 1: O "Monorepo" como uma solução única.

Estrutura monorepo:

monorepo/
|-- api/
|   |-- index.js
|   |-- package.json
|
|-- frontend/
|   |-- index.html
|   |-- main.js
|   |-- package.json
|
|-- package.json

A estrutura gera uma falsa sensação de organização porem isso se torna um pesadelo pois você tem tudo em um só lugar onde os commits, as branchs , os conflitos estão tudo em um só lugar.

Desvantagens do Monorepo:

Escala Descontrolada:

À medida que um projeto cresce, o monorepo pode se transformar em uma fera incontrolável. O aumento de escala frequentemente resulta em tempos de compilação e testes mais longos, prejudicando a eficiência do processo de desenvolvimento.

Complexidade Crescente:

A ideia de centralizar tudo em um único repositório pode parecer atraente, mas a complexidade associada a isso pode rapidamente se tornar esmagadora. Manter uma visão clara e concisa do código em um monorepo pode ser uma tarefa hercúlea.

Dificuldades na Adoção Gradual:

Migrar para um monorepo é uma tarefa complexa, especialmente para projetos já existentes. A transição abrupta pode levar a períodos de instabilidade e desorientação na equipe.

Controle de Acesso Complicado:

Garantir que as equipes certas tenham acesso às áreas apropriadas do código pode se tornar uma dor de cabeça. O controle de acesso e permissões no contexto de um monorepo pode se tornar um desafio, especialmente em organizações maiores.

Dificuldades no Processo de Deploy:

Com o monorepo, torna-se muito desafiador a construção de pipelines, visto que o projeto ganha uma complexidade enorme com vários projetos em um só lugar.

Figura 2: Desafios no processo de Deploy.

Dificuldades na Estratégia de Branchs:

Com o monorepo, a estratégia de branches se torna muito complicada devido ao grande volume de alterações dentro do repositório.

🏆 Conclusão:

Em um mundo onde o monorepo é frequentemente apresentado como uma bola de prata para os desafios do desenvolvimento de software, é crucial questionar se essa abordagem é sempre a melhor escolha. Projetos menores, equipes reduzidas e contextos onde as fronteiras entre componentes são claras muitas vezes se beneficiam mais de alternativas mais flexíveis. Ao considerar a implementação de um monorepo, é fundamental pesar os benefícios em relação às possíveis armadilhas e avaliar se essa abordagem se alinha verdadeiramente com as necessidades específicas do projeto em questão.

🚨 Cuidado com o Monorepo! Avalie suas necessidades antes de se comprometer. 🚨

Vertical Slice Architecture no NestJS: Uma abordagem modular e escalável

Jhones Gonçalves — Fri, 02 Jun 2023 11:17:37 +0000

Introdução

Quando se trata de desenvolver aplicações web complexas, a arquitetura é um fator crucial para garantir um código organizado, de fácil manutenção e escalabilidade. Uma abordagem arquitetural popular é a Vertical Slice Architecture, que promove a organização do código em torno de funcionalidades completas em vez de camadas horizontais tradicionais.

Neste artigo, exploraremos o conceito de Vertical Slice Architecture e como aplicá-lo ao desenvolvimento de aplicações Node.js usando o framework NestJS. Discutiremos os benefícios dessa abordagem e forneceremos exemplos práticos para ajudá-lo a implementar a Vertical Slice Architecture em seus projetos NestJS.

O que é Vertical Slice Architecture? 🏗️

A Vertical Slice Architecture é uma abordagem arquitetural que envolve a organização do código em torno de funcionalidades ou recursos específicos da aplicação. Em vez de separar o código em camadas horizontais, como camada de apresentação, camada de lógica de negócio e camada de acesso a dados, a Vertical Slice Architecture agrupa todos os componentes relacionados a uma funcionalidade em um único módulo vertical.

A ideia principal por trás da Vertical Slice Architecture é que todas as partes relacionadas a uma funcionalidade devem estar próximas umas das outras, facilitando a compreensão e a manutenção do código. Cada módulo vertical contém os controladores, serviços, modelos de dados e qualquer outra coisa necessária para implementar completamente uma funcionalidade específica.

Vertical Slice Architecture no NestJS 🚀

O NestJS é um framework Node.js que utiliza o padrão de arquitetura MVC (Model-View-Controller) e é altamente adaptável para a implementação da Vertical Slice Architecture. O NestJS fornece recursos poderosos, como módulos, controladores e provedores de serviço, que facilitam a organização do código em módulos verticais.

Definindo a estrutura do projeto 📁

Definir a estrutura do projeto de acordo com a arquitetura de fatia vertical. Cada funcionalidade deve ser agrupada em um módulo separado, contendo todos os componentes relacionados a ela (controladores, serviços, modelos de dados, etc.).

src/
├── users/
│   ├── controllers/
│   ├── services/
│   ├── models/
│   └── users.module.ts
├── products/
│   ├── controllers/
│   ├── services/
│   ├── models/
│   └── products.module.ts
├── orders/
│   ├── controllers/
│   ├── services/
│   ├── models/
│   └── orders.module.ts
└── app.module.ts

Para implementar a Vertical Slice Architecture no NestJS, podemos seguir os seguintes passos:

1. Criando módulos verticais 🧩

No NestJS, um módulo é uma unidade básica de organização do código. Podemos criar um módulo para cada funcionalidade da aplicação. Por exemplo, se estivermos desenvolvendo uma aplicação de e-commerce, podemos ter módulos como "Usuários", "Produtos", "Pedidos" e assim por diante.

Cada módulo deve conter os controladores, serviços, modelos de dados e outros componentes necessários para implementar completamente a funcionalidade específica.

@Module({
  controllers: [UsersController],
  providers: [UsersService],
})
export class UsersModule {}

2. Organizando as rotas 🛣️

No NestJS, as rotas são definidas nos controladores. Ao usar a Vertical Slice Architecture, cada módulo deve ter seu próprio controlador para lidar com as rotas relacionadas à funcionalidade específica.

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }

3. Implementando os serviços ⚙️

Os serviços são responsáveis por realizar a lógica de negócio da funcionalidade. Cada módulo deve ter seu próprio serviço para lidar com as operações relacionadas à funcionalidade específica.

@Injectable()
export class UsersService {
  constructor(private readonly userRepository: UserRepository) {}

  findAll(): Promise<User[]> {
    return this.userRepository.findAll();
  }

  // Outros métodos de serviço relacionados aos usuários
}

4. Gerenciando os modelos de dados 🗃️

Os modelos de dados representam as entidades ou objetos do mundo real com os quais estamos trabalhando. Cada módulo deve ter seus próprios modelos de dados para refletir a estrutura dos dados relacionados à funcionalidade específica.

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

  @Column()
  name: string;

  // Outros campos e propriedades do usuário
}

5. Conectando os módulos 🔗

Por fim, devemos conectar os módulos em nosso aplicativo NestJS. Podemos fazer isso importando os módulos verticais necessários no módulo raiz do aplicativo ou em outros módulos relevantes.

@Module({
  imports: [UsersModule, ProductsModule, OrdersModule],
})
export class AppModule {}

Benefícios da Vertical Slice Architecture 🎁

A utilização da Vertical Slice Architecture no NestJS oferece vários benefícios significativos para o desenvolvimento de aplicações:

Organização do código: A abordagem de fatia vertical organiza o código em torno de funcionalidades completas, tornando-o mais compreensível e fácil de manter.
Separação de responsabilidades: Cada módulo vertical é responsável por uma funcionalidade específica, o que ajuda a manter a coesão e a separação clara de responsabilidades.
Escalabilidade: Os módulos verticais podem ser facilmente escalados independentemente uns dos outros, permitindo que a aplicação cresça de forma modular.
Reutilização de código: Os módulos verticais podem ser reutilizados em diferentes partes da aplicação ou em outros projetos, aumentando a eficiência e a produtividade do desenvolvimento.

Conclusão 🎉

A Vertical Slice Architecture é uma abordagem eficaz para organizar e estruturar o código em aplicações NestJS. Ao agrupar todos os componentes relacionados a uma funcionalidade em um único módulo vertical, podemos obter um código mais limpo, organizado e de fácil manutenção.

Neste artigo, exploramos os princípios básicos da Vertical Slice Architecture no NestJS e fornecemos exemplos práticos de como implementá-la em um projeto. Esperamos que você possa aplicar esses conceitos em seus próprios projetos e aproveitar os benefícios dessa abordagem modular e escalável.

Happy coding!

Implementando o padrão Specification no Node.js com TypeScript

Jhones Gonçalves — Sun, 16 Apr 2023 11:30:36 +0000

O padrão Specification é um padrão de projeto de software que permite definir regras de negócio em um formato legível e reutilizável. Ele é particularmente útil em aplicações que precisam implementar regras de negócio complexas que envolvem múltiplas entidades. Neste artigo, vamos ver como implementar o padrão Specification em uma aplicação Node.js com TypeScript.

Definindo a entidade

Para exemplificar o uso do padrão Specification, vamos criar uma entidade simples chamada Transaction. Ela possui três propriedades: amount (valor da transação), date (data da transação) e description (descrição da transação).

Crie um arquivo chamado transaction.ts na pasta src/entities com o seguinte conteúdo:

export class Transaction {
  constructor(
    public readonly amount: number,
    public readonly date: Date,
    public readonly description: string,
  ) {}
}

Esta classe representa uma transação financeira com os seguintes atributos:

amount: o valor da transação
date: a data da transação
description: uma descrição da transação

Criando as regras de negócio

Agora que temos a entidade de transação, vamos criar as regras de negócio para verificar se uma transação é válida ou não. Crie um arquivo chamado specification.ts na pasta src/specifications com o seguinte conteúdo:

export interface Specification<T> {
  isSatisfiedBy(candidate: T): boolean;
  and(other: Specification<T>): Specification<T>;
  or(other: Specification<T>): Specification<T>;
  not(): Specification<T>;
}

export class CompositeSpecification<T> implements Specification<T> {
  public isSatisfiedBy(candidate: T): boolean {
    throw new Error("Not implemented");
  }

  public and(other: Specification<T>): Specification<T> {
    return new AndSpecification(this, other);
  }

  public or(other: Specification<T>): Specification<T> {
    return new OrSpecification(this, other);
  }

  public not(): Specification<T> {
    return new NotSpecification(this);
  }
}

class AndSpecification<T> extends CompositeSpecification<T> {
  constructor(
    private readonly left: Specification<T>,
    private readonly right: Specification<T>
  ) {
    super();
  }

  public isSatisfiedBy(candidate: T): boolean {
    return (
      this.left.isSatisfiedBy(candidate) && this.right.isSatisfiedBy(candidate)
    );
  }
}

export class OrSpecification<T> extends CompositeSpecification<T> {
  constructor(
    private readonly left: Specification<T>,
    private readonly right: Specification<T>
  ) {
    super();
  }

  public isSatisfiedBy(candidate: T): boolean {
    return (
      this.left.isSatisfiedBy(candidate) || this.right.isSatisfiedBy(candidate)
    );
  }
}

export class NotSpecification<T> extends CompositeSpecification<T> {
  constructor(private readonly specification: Specification<T>) {
    super();
  }

  public isSatisfiedBy(candidate: T): boolean {
    return !this.specification.isSatisfiedBy(candidate);
  }
}

Este arquivo define uma interface Specification que representa uma regra de negócio e uma classe CompositeSpecification que implementa a lógica de combinação de regras de negócio.

As classes AndSpecification, OrSpecification e NotSpecification são subclasses de CompositeSpecification que implementam as operações lógicas AND, OR e NOT, respectivamente.

Crie um arquivo chamado transaction.ts na pasta src/specifications com o seguinte conteúdo:


import { Transaction } from "../entities/transaction";
import { CompositeSpecification } from "./specification";

export class TransactionSpecification extends CompositeSpecification<Transaction> {
  public isSatisfiedBy(candidate: Transaction): boolean {
    return TransactionSpecification.amountIsGreaterThan(50)
      .and(TransactionSpecification.dateIsGreaterThan(new Date(2022, 0, 1)))
      .and(TransactionSpecification.descriptionContains("supermercado"))
      .isSatisfiedBy(candidate);
  }

  public static amountIsGreaterThan(value: number): TransactionSpecification {
    return new (class extends TransactionSpecification {
      public isSatisfiedBy(candidate: Transaction): boolean {
        return candidate.amount > value;
      }
    })();
  }

  public static amountIsLessThan(value: number): TransactionSpecification {
    return new (class extends TransactionSpecification {
      public isSatisfiedBy(candidate: Transaction): boolean {
        return candidate.amount < value;
      }
    })();
  }

  public static dateIsGreaterThan(value: Date): TransactionSpecification {
    return new (class extends TransactionSpecification {
      public isSatisfiedBy(candidate: Transaction): boolean {
        return candidate.date > value;
      }
    })();
  }

  public static dateIsLessThan(value: Date): TransactionSpecification {
    return new (class extends TransactionSpecification {
      public isSatisfiedBy(candidate: Transaction): boolean {
        return candidate.date < value;
      }
    })();
  }

  public static descriptionContains(value: string): TransactionSpecification {
    return new (class extends TransactionSpecification {
      public isSatisfiedBy(candidate: Transaction): boolean {
        return candidate.description.includes(value);
      }
    })();
  }
}

A classe TransactionSpecification é uma subclasse de CompositeSpecification que define as regras de negócio específicas para a entidade Transaction.

As funções estáticas amountIsGreaterThan, amountIsLessThan, dateIsGreaterThan, dateIsLessThan e descriptionContains retornam instâncias de TransactionSpecification que representam cada uma das regras de negócio. O método isSatisfiedBy contem a composição da regra. a classe esta com as subsclasses publica a modo que ao criar uma outra regra pode ser apenas ajustada e extendida para compor.

Utilizando as regras de negócio

Agora que temos as regras de negócio definidas, podemos utilizá-las para validar uma transação. Crie um arquivo chamado transaction.ts na pasta src/validators com o seguinte conteúdo:

import { Transaction } from './Transaction';
import { TransactionSpecification, Specification } from './TransactionSpecification';

export class TransactionValidator {
  constructor(private readonly specification: Specification<Transaction>) {}

  public validate(transaction: Transaction): boolean {
    return this.specification.isSatisfiedBy(transaction);
  }
}

// testando o validator
const transaction = new Transaction(100, new Date(), 'Compra no supermercado');

const validator = new TransactionValidator()

console.log(validator.validate(transaction)); // true

Este arquivo define a classe TransactionValidator, que recebe uma instância de Specification<Transaction> no construtor e possui um método validate que recebe uma transação e retorna um valor booleano indicando se a transação é válida ou não.

No exemplo acima, criamos uma transação com valor 100, data new Date() e descrição 'Compra no supermercado'. Em seguida, criamos uma instância de TransactionValidator as regra de negócio verifica se o valor da transação é maior que 50, se a data da transação é maior que 01/01/2022 e se a descrição da transação contém a palavra 'supermercado'. Finalmente, chamamos o método validate passando a transação criada e exibimos o resultado no console.

Conclusão

Neste artigo, vimos como implementar o padrão Specification em uma aplicação Node.js com TypeScript. Criamos uma entidade Transaction, definimos regras de negócio para validar uma transação utilizando a classe TransactionSpecification e criamos um validador de transações utilizando a classe TransactionValidator.

O padrão Specification pode ser aplicado em diversos contextos e é uma boa opção quando precisamos implementar regras de negócio complexas que envolvem múltiplas entidades. Com ele, podemos tornar o código mais modular, fácil de manter e extensível.

Segue exemplo no github: https://github.com/jhonesgoncalves/example-specification-ts

Começando com NestJS

Jhones Gonçalves — Tue, 28 Mar 2023 23:24:33 +0000

🚀 Borá?

Se você está procurando uma maneira rápida e eficaz de aprender NestJS, está no lugar certo! Neste artigo, vou te guiar pelo caminho correto para começar a aprender o framework NestJS de maneira eficiente e com boa prática de desenvolvimento.

🤔 O que é o NestJS?

NestJS é um framework de desenvolvimento web para Node.js. Ele é baseado no popular framework Angular e oferece muitos recursos úteis para criar aplicativos da web escaláveis e robustos. O NestJS usa uma abordagem modular e fortemente tipada para construir aplicativos da web, tornando-o uma ótima escolha para grandes projetos.

📚 Conhecimentos prévios

Antes de começar a estudar o NestJS, é importante ter um conhecimento básico de JavaScript e do funcionamento do Node.js. Você deve estar familiarizado com conceitos como módulos, classes, operadores e callbacks. Além disso, você deve estar confortável com o uso de um terminal para executar comandos do Node.js e instalar pacotes do npm.

🚀 Começando com NestJS

Agora que você tem os pré-requisitos para começar, vamos às dicas para iniciar sua jornada com o NestJS:

1. Comece com a documentação oficial

A documentação oficial do NestJS é um ótimo ponto de partida. Ela é bem organizada e oferece muitos exemplos de código para ajudá-lo a entender o funcionamento do framework. Além disso, a documentação oficial do NestJS é sempre atualizada com as últimas versões do framework, o que garante que você esteja sempre por dentro das melhores práticas e recursos.

📖 Documentação do NestJS

2. Utilize o NestJS CLI

O NestJS CLI é uma ferramenta de linha de comando que ajuda a criar rapidamente novos projetos e componentes do NestJS. Ele vem com muitos recursos úteis, como a criação automática de módulos, controladores e provedores. Utilizar o NestJS CLI pode economizar muito tempo e garantir que você esteja seguindo as melhores práticas do framework.

A maneira mais fácil de começar é criar um novo projeto usando o CLI do Nest. Para fazer isso, primeiro, certifique-se de que você tem o Node.js instalado em sua máquina. Em seguida, abra o terminal e execute o seguinte comando:

npm i -g @nestjs/cli

Este comando instalará o CLI do NestJS globalmente em sua máquina. Agora, você pode criar um novo projeto NestJS executando o seguinte comando:

nest new project-name

Substitua project-name pelo nome que você deseja dar ao seu projeto. Este comando irá criar uma nova pasta com o nome do seu projeto, contendo a estrutura básica do projeto NestJS.

Agora que você tem um projeto NestJS em branco, é hora de começar a criar alguns endpoints para sua API. Para fazer isso, crie um novo controlador executando o seguinte comando:

nest generate controller cats

Este comando criará um novo arquivo cats.controller.ts na pasta src/ do seu projeto. Abra este arquivo e adicione o seguinte código:

import { Controller, Get } from '@nestjs/common';

@Controller('cats')
export class CatsController {
  @Get()
  findAll(): string {
    return 'This action returns all cats';
  }
}

Este código define um novo controlador CatsController que responde a solicitações GET na rota /cats e retorna a string 'This action returns all cats'.

Agora, execute o seguinte comando para iniciar o servidor do NestJS:

npm run start

Este comando iniciará o servidor do NestJS e você poderá acessar sua API em http://localhost:3000/cats.

3. Aprenda com projetos reais

Aprender com projetos reais é uma das melhores maneiras de entender como o NestJS funciona na prática. Tente encontrar projetos open source do NestJS e estude como eles foram construídos. Além disso, construir seus próprios projetos do zero pode ajudá-lo a consolidar seus conhecimentos e a praticar suas habilidades.

NestJS Realworld Example App - um projeto exemplo construído com o NestJS que segue as especificações do RealWorld app para implementar um aplicativo completo.
NestJS Starter - um projeto exemplo para iniciar um aplicativo com o NestJS que inclui autenticação de usuário, banco de dados e uma API RESTful.
NestJS CQRS Example - um projeto exemplo que usa o padrão CQRS (Command Query Responsibility Segregation) com o NestJS.
NestJS GraphQL Example - um projeto exemplo que usa o NestJS com GraphQL para criar uma API de todo list.
NestJS Swagger Example - um projeto exemplo que usa o NestJS com Swagger para documentar uma API.

4. Comunidade NestJS

A comunidade do NestJS é ativa e acolhedora. Você pode encontrar muitas informações úteis em fóruns, grupos de discussão e no Discord oficial do NestJS. Além disso, você pode acompanhar as atualizações do NestJS no Twitter e no blog oficial do NestJS.

🚀 Discord do NestJS

Recursos e Cursos Oficiais da NestJS e Afins

A equipe da NestJS oferece uma variedade de cursos oficiais que podem ajudá-lo a aprender o NestJS de forma mais eficaz. Aqui estão alguns dos cursos mais populares:

NestJS Fundamentals - Este é um curso oficial da NestJS que cobre os fundamentos da estrutura, incluindo os conceitos básicos de injeção de dependência, controladores, provedores e módulos.
NestJS Zero to Hero - Este curso é uma introdução completa ao NestJS e cobre tudo, desde os conceitos básicos até recursos avançados, como autenticação, autorização e testes.
Advanced NestJS - Este curso avançado é destinado a desenvolvedores que já têm experiência com o NestJS e desejam aprimorar suas habilidades em áreas como microserviços, mensageria e arquitetura de software.()

Esses cursos são ministrados por instrutores especializados da NestJS. .

Certifique-se de verificar o site oficial da NestJS para obter informações atualizadas sobre os cursos disponíveis e os detalhes de preços.

🏆 Conclusão

O NestJS é um framework poderoso e popular para o desenvolvimento web com Node.js. Aprender o NestJS do Jeito Certo pode garantir que você esteja seguindo as melhores práticas e desenvolvendo aplicativos da web escaláveis.

Guia para Aprender Klingon

Jhones Gonçalves — Tue, 28 Mar 2023 22:37:53 +0000

Se você é fã de Star Trek e está interessado em aprender klingon, a língua fictícia dos guerreiros alienígenas da série, este guia é para você! Aprender klingon pode ser um desafio emocionante, mas com os recursos e estratégias certos, você pode começar a falar como um verdadeiro klingon em pouco tempo.

1. Obtenha recursos de aprendizado

Há uma variedade de recursos disponíveis on-line e em livros que podem ajudá-lo a aprender klingon. Algumas opções incluem:

O livro "The Klingon Dictionary" de Marc Okrand: Este é um dos recursos mais conhecidos para aprender klingon e oferece uma visão abrangente da língua klingon.
Sites como o "Klingon Language Institute" e o "Hol 'ampaS": Esses sites oferecem cursos on-line gratuitos e outros recursos para ajudá-lo a aprender klingon.

2. Comece com o básico

Antes de mergulhar nas frases complicadas e conversas em klingon, é importante começar com o básico, como o alfabeto e as regras gramaticais. Certifique-se de entender a estrutura básica das frases em klingon e praticar a pronúncia.

3. Pratique com outros aprendizes

Junte-se a um grupo de estudos de klingon ou fórum on-line para praticar suas habilidades com outras pessoas que estão aprendendo a língua. Isso pode ajudá-lo a aprimorar suas habilidades e também oferece uma oportunidade para conhecer outras pessoas interessadas na cultura klingon.

4. Assista a episódios de Star Trek em klingon

Se você é fã de Star Trek, assistir a episódios em klingon pode ser uma maneira divertida de praticar suas habilidades de compreensão auditiva. Há uma série de episódios de Star Trek com diálogos em klingon disponíveis em DVDs e plataformas de streaming.

5. Pratique regularmente

Assim como com qualquer língua, é importante praticar regularmente para melhorar suas habilidades em klingon. Dedique um tempo diário para estudar e praticar a língua, e tente incorporar o klingon em sua vida cotidiana, como por exemplo pensando em algumas palavras ou frases em klingon enquanto você executa tarefas diárias.

Além dessas estratégias, há também um curso de klingon oferecido pelo Duolingo. O curso é gratuito e pode ser acessado através do site ou aplicativo do Duolingo. O curso de klingon do Duolingo inclui lições interativas que abrangem tópicos como vocabulário, gramática e pronúncia, além de exercícios de escuta e fala. O curso é projetado para ser acessível a alunos de todos os níveis de habilidade, e oferece uma maneira divertida e interativa de aprender klingon.

Inclusive estou fazendo o curso do duolingo e estou gostando bastante, vai te ajudar bastante e é gratuito.

Em resumo, aprender klingon pode ser um desafio emocionante, mas com os recursos e estratégias certos, você pode começar a falar como um verdadeiro klingon em pouco tempo.

6. Participar de convenções e eventos

Participar de convenções e eventos relacionados a Star Trek e à cultura klingon pode ser uma ótima maneira de praticar suas habilidades em klingon e conhecer outras pessoas que compartilham seu interesse pela língua e pela cultura. Existem muitos eventos que ocorrem em todo o mundo, desde eventos on-line até convenções ao vivo.

7. Assista a vídeos no YouTube

Há uma série de vídeos no YouTube que podem ajudá-lo a aprender klingon. Alguns canais populares incluem o canal "Learn Klingon", que oferece uma variedade de lições em klingon, e o canal "Klingon Language Institute", que também oferece lições e outras informações sobre a língua.

8. Imersão na cultura klingon

Para realmente se tornar fluente em klingon, é importante imergir na cultura klingon. Isso significa não apenas estudar a língua, mas também aprender sobre a história, tradições e crenças klingon. Isso pode ser feito lendo livros relacionados a Star Trek e à cultura klingon, assistindo a episódios de Star Trek que apresentam os klingons e se envolvendo em comunidades on-line dedicadas a Star Trek e à cultura klingon.

Conclusão

Aprender klingon pode ser um desafio emocionante e gratificante para os fãs de Star Trek. Com recursos de aprendizado disponíveis on-line, estratégias de estudo e prática regular, você pode se tornar fluente em klingon em pouco tempo. Não se esqueça de participar de convenções e eventos, assistir a vídeos no YouTube e imergir na cultura klingon para aprimorar suas habilidades e conhecer outros fãs da cultura. E não se esqueça de se divertir enquanto aprende a língua dos guerreiros alienígenas mais famosos da galáxia!

Guia de Estudos de Matemática para Programadores

Jhones Gonçalves — Wed, 01 Mar 2023 00:29:30 +0000

A matemática é uma disciplina fundamental para a formação de um programador. Se você deseja aprimorar suas habilidades como programador, é importante dedicar tempo para estudar e praticar matemática.

Álgebra Linear

A álgebra linear é uma área da matemática que lida com vetores e matrizes. Ela é fundamental para a criação de gráficos 3D, aprendizado de máquina, processamento de imagens, entre outras aplicações em programação. Aqui estão alguns recursos de estudo para a álgebra linear:

📚 Khan Academy: um recurso abrangente e gratuito para aprender álgebra linear.
📚 MIT OpenCourseWare: um curso completo de álgebra linear do MIT.

Cálculo

O cálculo é uma área da matemática que lida com o estudo de funções e limites. Ele é fundamental para a análise de algoritmos, simulações físicas e muitas outras aplicações em programação. Aqui estão alguns recursos de estudo para o cálculo:

📚 Khan Academy: um recurso abrangente e gratuito para aprender cálculo.
📚 MIT OpenCourseWare: um curso completo de cálculo do MIT.

Estatística

A estatística é uma área da matemática que lida com a coleta, análise e interpretação de dados. Ela é fundamental para a análise de dados, aprendizado de máquina e muitas outras aplicações em programação. Aqui estão alguns recursos de estudo para a estatística:

📚 Khan Academy: um recurso abrangente e gratuito para aprender estatística.
📚 Stanford Online: um curso introdutório de aprendizado de máquina e estatística.

Teoria dos Grafos

A teoria dos grafos é uma área da matemática que lida com o estudo de grafos e redes. Ela é fundamental para a análise de algoritmos, redes sociais, sistemas de transporte, entre outras aplicações em programação. Aqui estão alguns recursos de estudo para a teoria dos grafos:

📚 Khan Academy: um recurso abrangente e gratuito para aprender teoria dos grafos.
📚 Coursera: um curso online gratuito sobre algoritmos em grafos.

Planejamento Semanal de Estudos de Matemática para Programadores

Repita as orientações para as próximas semanas só incremente o capítulo

Segunda-feira

Álgebra Linear

Assista as aulas do capítulo 1 do curso de Álgebra Linear da Khan Academy.
Resolva os exercícios propostos no final do capítulo.

Terça-feira

Cálculo

Assista as aulas do capítulo 1 do curso de Cálculo da Khan Academy.
Resolva os exercícios propostos no final do capítulo.

Quarta-feira

Estatística

Assista as aulas do capítulo 1 do curso de Estatística da Khan Academy.
Resolva os exercícios propostos no final do capítulo.

Quinta-feira

Teoria dos Grafos

Assista as aulas do capítulo 1 do curso de Teoria dos Grafos da Khan Academy.
Resolva os exercícios propostos no final do capítulo.

Sexta-feira

Álgebra Linear

Assista as aulas do capítulo 2 do curso de Álgebra Linear da Khan Academy.
Resolva os exercícios propostos no final do capítulo.

Sábado

Cálculo

Assista as aulas do capítulo 2 do curso de Cálculo da Khan Academy.
Resolva os exercícios propostos no final do capítulo.

Domingo

Estatística

Assista as aulas do capítulo 2 do curso de Estatística da Khan Academy.
Resolva os exercícios propostos no final do capítulo.

A Importância da Matemática para Programadores

Jhones Gonçalves — Wed, 01 Mar 2023 00:00:20 +0000

A matemática é uma disciplina fundamental para a formação de um programador. Embora muitas vezes não seja percebida como tal, a matemática está presente em diversas áreas da programação, desde a criação de algoritmos até o desenvolvimento de inteligência artificial. Neste artigo, vamos explorar a importância da matemática para programadores e como ela é aplicada na programação.

Algoritmos e Estruturas de Dados

Algoritmos e estruturas de dados são elementos básicos da programação. Eles são usados para resolver problemas de forma eficiente e para organizar dados em memória. Ambos são fundamentados em conceitos matemáticos, como álgebra booleana, teoria dos conjuntos e grafos.

Por exemplo, o algoritmo de ordenação Quicksort é baseado em um conceito matemático chamado de divisão e conquista. Ele divide uma lista em duas partes menores, ordena cada uma delas separadamente e depois as une novamente. O Quicksort é considerado um dos algoritmos de ordenação mais eficientes e é amplamente utilizado em diversas áreas da programação.

As estruturas de dados também são baseadas em conceitos matemáticos. Por exemplo, a estrutura de dados conhecida como árvore é uma estrutura hierárquica que é baseada em grafos. As árvores são amplamente utilizadas em bancos de dados, em sistemas de busca e em muitas outras aplicações.

Cálculo e Análise Numérica

A matemática também é fundamental para a análise numérica e para o cálculo de funções. A análise numérica é a área da matemática que estuda métodos para resolver problemas matemáticos usando computadores. Esses métodos são usados em diversas áreas da programação, como na criação de jogos, na análise de dados e em muitas outras aplicações.

Por exemplo, a criação de jogos geralmente envolve cálculos de física para simular movimentos e colisões. A análise numérica é usada para resolver esses cálculos de forma eficiente e para criar jogos mais realistas.

Inteligência Artificial

A matemática também é fundamental para o desenvolvimento de inteligência artificial. A inteligência artificial é uma área da programação que se baseia em modelos matemáticos para criar sistemas inteligentes que podem aprender e se adaptar ao ambiente.

Por exemplo, a rede neural é um modelo matemático que é amplamente utilizado em inteligência artificial. As redes neurais são inspiradas no funcionamento do cérebro humano e são usadas para criar sistemas que podem aprender a partir de dados. Elas são usadas em muitas áreas da programação, como reconhecimento de imagens, tradução de idiomas e muitas outras aplicações.

Confira meu guia de estudos de matemática para programadores:

📚 Guia de estudos: com planejamento semanal.

Conclusão

A matemática é fundamental para a programação. Ela está presente em todas as áreas da programação, desde a criação de algoritmos até o desenvolvimento de inteligência artificial. Por isso, é importante que os programadores tenham uma boa base em matemática para poderem desenvolver soluções eficientes e inovadoras. Se você está começando a programar, não subestime a importância da matemática e dedique-se a estudá-la com afinco.

Usando Elastic APM com servidor Docker para monitorar uma aplicação Node.js

Jhones Gonçalves — Sat, 25 Feb 2023 21:24:37 +0000

Introdução

O Elastic APM é uma ferramenta de monitoramento de desempenho de aplicativos que permite coletar e analisar dados de desempenho em tempo real. Neste artigo, vamos ver como configurar o Elastic APM como um servidor Docker para monitorar uma aplicação Node.js.

Pré-requisitos

Antes de começarmos, você deve ter o seguinte instalado em sua máquina:

Docker
Docker Compose

Passo 1: Crie uma aplicação Node.js

Para este artigo, vamos criar uma aplicação Node.js simples. Crie um novo diretório e crie um arquivo chamado index.js. Adicione o seguinte código ao arquivo:

const http = require('http');

const server = http.createServer((req, res) => {
    if (req.url === '/health') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify({ status: 'UP' }));
    } else {
        res.writeHead(200, { 'Content-Type': 'text/plain' });
        res.end('Hello, world!\n');
    }
});

const port = process.env.PORT || 3000;

server.listen(port, () => {
    console.log(Server running on port ${port});
});

Este código cria um servidor HTTP simples que responde com "Hello, world!" quando você acessa a raiz do servidor. Quando você acessa /health, o servidor retorna um JSON que indica que está saudável.

Passo 2: Crie um arquivo `Dockerfile`

O próximo passo é criar um arquivo Dockerfile para empacotar a aplicação Node.js em um contêiner Docker. Crie um novo arquivo chamado Dockerfile no diretório raiz do seu projeto e adicione o seguinte conteúdo:

FROM node:14-alpine

WORKDIR /app

COPY package.json .
COPY package-lock.json .
RUN npm install

COPY . .

EXPOSE 3000

CMD ["npm", "start"]

Este arquivo define uma imagem Docker que usa a imagem node:14-alpine como base. Ele define um diretório de trabalho na imagem, instala as dependências da aplicação, copia os arquivos da aplicação para o contêiner Docker e expõe a porta 3000. Por fim, ele define o comando npm start como o comando padrão que deve ser executado quando o contêiner é iniciado.

Passo 3: Crie um arquivo `docker-compose.yml`

O próximo passo é criar um arquivo docker-compose.yml para orquestrar a execução dos contêineres da aplicação e do Elastic APM. Crie um novo arquivo chamado docker-compose.yml no diretório raiz do seu projeto e adicione o seguinte conteúdo:

version: '3.8'

services:
  app:
    build: .
    ports:
      - '3000:3000'
    environment:
      - ELASTIC_APM_SERVICE_NAME=my-node-app
      - ELASTIC_APM_SERVER_URL=http://apm-server:8200
      - ELASTIC_APM_ENVIRONMENT=development
      - ELASTIC_APM_LOG_LEVEL=debug
    depends_on:
      - apm-server

  apm-server:
    image: docker.elastic.co/apm/apm-server:
    ports:
      - '8200:8200'
      - '1514:1514/udp'
    environment:
      - output.elasticsearch.hosts=[elasticsearch:9200]
      - apm-server.secret_token=${ELASTIC_APM_SECRET_TOKEN}
    volumes:
      - './apm-server/config/apm-server.yml:/usr/share/apm-server/apm-server.yml:ro'

  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.16.2
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - ES_JAVA_OPTS=-Xms256m -Xmx256m
      - http.host=0.0.0.0
      - transport.host=127.0.0.1
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    ports:
      - '9200:9200'
      - '9300:9300'
    volumes:
      - esdata:/usr/share/elasticsearch/data

volumes:
  esdata:
    driver: local

Este arquivo define três serviços:

app: o serviço que executa a aplicação Node.js.
apm-server: o serviço que executa o servidor Elastic APM.
elasticsearch: o serviço que executa o Elasticsearch.

O serviço app é construído a partir da imagem definida no arquivo Dockerfile e expõe a porta 3000. Ele também define algumas variáveis de ambiente que são usadas pela biblioteca Elastic APM para se conectar ao servidor Elastic APM.

O serviço apm-server é construído a partir da imagem docker.elastic.co/apm/apm-server. Ele expõe as portas 8200 e 1514/udp, que são usadas para se comunicar com a biblioteca Elastic APM. Ele também define uma variável de ambiente que define a chave secreta usada pelo servidor Elastic APM para autenticação.

O serviço elasticsearch é construído a partir da imagem docker.elastic.co/elasticsearch/elasticsearch. Ele expõe as portas 9200 e 9300, que são usadas pelo Elasticsearch para se comunicar com a aplicação. Ele também define algumas variáveis de ambiente que são usadas para configurar o Elasticsearch.

Passo 4: Inicie os contêineres

Agora que temos todos os arquivos necessários, podemos iniciar os contêineres. Para fazer isso, execute o seguinte comando no diretório raiz do seu projeto:

docker-compose up -d

Este comando inicia os três contêineres definidos no arquivo docker-compose.yml. Você deverá ver mensagens de log para cada contêiner à medida que eles são iniciados.

Passo 5: Verifique se o Elastic APM está funcionando

Para verificar se o Elastic APM está funcionando, abra o Kibana em seu navegador em http://localhost:5601. No painel de navegação à esquerda, clique em "APM" para acessar a página de monitoramento de desempenho.

Se tudo estiver funcionando corretamente, você deverá ver sua aplicação Node.js listada na página "APM". Clique na aplicação para ver mais informações sobre o desempenho da aplicação.

Exemplo de aplicação no apm:

Conclusão

Neste artigo, vimos como usar o Elastic APM para monitorar uma aplicação Node.js em um ambiente Docker. O Elastic APM é uma ferramenta poderosa que fornece insights detalhados sobre o desempenho da sua aplicação, permitindo que você identifique problemas e otimize o desempenho.

Começamos criando um arquivo Dockerfile que define o ambiente de execução da nossa aplicação Node.js e adicionando a biblioteca Elastic APM à nossa aplicação. Em seguida, criamos um arquivo docker-compose.yml que define os contêineres para a aplicação Node.js, o servidor Elastic APM e o Elasticsearch.

Ao iniciar os contêineres, podemos verificar se o Elastic APM está funcionando acessando o Kibana e verificando se a nossa aplicação Node.js está listada na página "APM". A partir daí, podemos usar o Elastic APM para monitorar o desempenho da nossa aplicação e identificar possíveis gargalos ou problemas de desempenho.

Esperamos que este artigo tenha sido útil para você e que você agora tenha uma compreensão melhor de como usar o Elastic APM para monitorar uma aplicação Node.js em um ambiente Docker. Lembre-se de que o monitoramento do desempenho é uma parte importante do processo de desenvolvimento de software e pode ajudar a identificar problemas e melhorar a experiência do usuário.

Domain Notification em NodeJS 🚀

Jhones Gonçalves — Wed, 22 Feb 2023 01:23:02 +0000

Introdução

Uma das responsabilidades do domínio de uma aplicação é garantir que os dados que a aplicação manipula estejam em um estado válido. No entanto, há casos em que os dados não estão em um estado válido, e o domínio precisa notificar o usuário sobre esses problemas. A notificação do usuário pode ser feita por meio de exceções ou erros, mas isso pode prejudicar a experiência do usuário e a confiabilidade do sistema. Uma alternativa é usar o padrão de Domain Notification para notificar o usuário sobre problemas em seus dados.

O padrão de Domain Notification permite que a aplicação capture todos os problemas em seus dados e apresente-os ao usuário de uma maneira amigável. Ele é usado para notificar o usuário sobre problemas de validação, erros de negócio, etc. Neste artigo, discutiremos como implementar o padrão de Domain Notification em NodeJS usando o pacote flunt-js.

O que é o flunt-js?

Flunt-js é uma biblioteca criada por min para validação de dados em JavaScript. Ele oferece uma abordagem simples e intuitiva para validar objetos. O flunt-js é inspirado no Flunt para .NET do André Baltieri e é compatível com o ES6 e o TypeScript ( Irei trabalhar na implementação para suportar 100% sem ter que sinalizar no arquivo para permitir js).

Implementação

Para implementar o padrão de Domain Notification, você precisa criar uma classe que encapsule a lógica de validação e notificação. Essa classe será responsável por notificar o usuário sobre quaisquer problemas em seus dados.

Vamos criar uma entidade de exemplo User que possui as seguintes propriedades: nome, email, senha e cpf. Vamos usar o flunt-js para validar as propriedades de User e notificar o usuário sobre quaisquer problemas.

Primeiro, precisamos instalar a biblioteca:

npm install flunt-js

Usando o FluntJS e criando um entidade com validações

const { Notifiable, Contract } = require('flunt-js');

class User extends Notifiable {
  constructor(nome, email, senha, cpf) {
    super();

    this.nome = nome;
    this.email = email;
    this.senha = senha;
    this.cpf = cpf;
    this.dataCadastro = new Date();

    super.AddNotifications(
      new Contract()
        .isEmail(email, 'O email informado é inválido.')
        .hasMaxLen(nome, 50, 'O nome deve ter no máximo 50 caracteres.')
        .hasMinLen(senha, 6, 'A senha deve ter no mínimo 6 caracteres.')
        .isFixedLen(cpf, 11, 'O CPF informado é inválido.')
    );

  }
}

const usuario = new User('John Doe', 'johndoe@example.com', '123456', '12345678901');

// Executa a validação e imprime as mensagens de erro, se houver
if (!usuario.isValid()) {
  console.log(usuario.getMessages());
} else {
  console.log('Usuário válido.');
}

Nesse código, a classe User encapsula a lógica de validação e notificação usando o flunt-js. A função validar() usa o flunt-js para validar as propriedades de User e notificar o usuário sobre quaisquer problemas.

O flunt-js suporta vários tipos de validação, incluindo validação de comprimento máximo (hasMaxLen), validação de comprimento mínimo (hasMinLen), validação de formato de e-mail (isEmail), validação de valor fixo (isFixedLen), etc. É possível personalizar as mensagens de erro retornadas por cada validação.


const usuario = new User('John Doe', 'johndoe@example.com', '123', '1234564233432478901');

// Executa a validação e imprime as mensagens de erro, se houver
if (!usuario.isValid()) {
  console.log(usuario.getMessages());
} else {
  // não entra aqui pois os dados são inválidos
  console.log('Usuário válido.');
}

Nesse código, criamos um novo usuário com dados inválidos e validamos esses dados. Se a validação falhar, a função notifications retornará uma lista de mensagens de erro. Podemos usar essa lista para notificar o usuário sobre quaisquer problemas.

Agora que temos nossa entidade User, podemos usá-la para validar os dados do usuário em uma rota POST. Por exemplo, se estivermos criando um novo usuário em nossa aplicação, podemos fazer o seguinte:

const express = require('express');
const User = require('./User');

const app = express();
app.use(express.json());

app.post('/users', (req, res) => {
  const { name, email, password } = req.body;

  const user = new User(name, email, password);

  if (user.isValid()) {
    // retorna a lista de notificações ( caso queria somente as mensagens pode usar o getMessages() )
    return res.status(400).json(user.notifications);
  }

  // Salvar usuário no banco de dados
});

Conclusão

O padrão de Domain Notification é uma maneira de notificar o usuário sobre problemas em seus dados. Ele permite que a aplicação capture todos os problemas em seus dados e apresente-os ao usuário de uma maneira amigável.

Neste artigo, discutimos como implementar o padrão de Domain Notification em Node.js usando o pacote flunt-js. É uma biblioteca para validação de dados em JavaScript que oferece uma abordagem simples e intuitiva para validar objetos.

A validação usando o flunt-js ajuda a garantir que os dados estejam em um estado válido e notifica o usuário sobre quaisquer problemas. Usando a validação, podemos garantir que a aplicação está recebendo dados válidos e evitar problemas futuros.

Referências

Flunt-js: https://github.com/jhonesgoncalves/flunt
Flunt: https://github.com/andrebaltieri/Flunt
Domain Notification: https://docs.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/ddd-oriented-microservice#domain-events-and-notifications

DEV Community: Jhones Gonçalves

🧠 Como criar uma Fluent API no TypeORM (igual ao Entity Framework)

🎯 O problema

🚀 A solução: criar uma Fluent API sobre o TypeORM

⚙️ A arquitetura base

🧩 1. O domínio puro

🧱 2. O EntityBuilder

⚙️ 3. Configuração fluente da entidade

🧰 4. Registro automático no TypeORM

💾 5. Repositório e uso

🧪 6. Exemplo de uso no serviço

🚀 Resultado final

🧭 Benefícios

🧭 Conclusão

Clean Architecture no NestJS 🏛️🚀

Introdução 🎉

O que é Clean Architecture? 🤔📘

Implementação no NestJS 🛠️🐦

Estrutura de Pastas 📁🔍

Descrição das Pastas 📁🔍

Conclusão 🎉🚀

Criando um Repositório Genérico de Leitura com Generics, TypeORM e SQLite no NestJS 🚀

Iniciando um Projeto NestJS 🚀

Instalando SQLite e TypeORM no NestJS

Criando uma Pasta para ViewModels

Adicionando um Decorator DefaultValue

Criando uma ViewModel para Usuário

Criando uma Pasta para Repositórios

Utilizando o Repositório Genérico no Controller

Configurando o Módulo para Injeção de Dependência

Resultado: Personalizando o Retorno da API 🎨

Conclusão 🚀

Principais Benefícios:

Monorepo: Uma Armadilha Disfarçada de Praticidade (Anti-pattern)

Introdução:

Desvantagens do Monorepo:

🏆 Conclusão:

Vertical Slice Architecture no NestJS: Uma abordagem modular e escalável

Introdução

O que é Vertical Slice Architecture? 🏗️

Vertical Slice Architecture no NestJS 🚀

Definindo a estrutura do projeto 📁

1. Criando módulos verticais 🧩

2. Organizando as rotas 🛣️

3. Implementando os serviços ⚙️

4. Gerenciando os modelos de dados 🗃️

5. Conectando os módulos 🔗

Benefícios da Vertical Slice Architecture 🎁

Conclusão 🎉

Implementando o padrão Specification no Node.js com TypeScript

Definindo a entidade

Criando as regras de negócio

Utilizando as regras de negócio

Conclusão

Começando com NestJS

🚀 Borá?

🤔 O que é o NestJS?

📚 Conhecimentos prévios

🚀 Começando com NestJS

1. Comece com a documentação oficial

2. Utilize o NestJS CLI

3. Aprenda com projetos reais

4. Comunidade NestJS

Recursos e Cursos Oficiais da NestJS e Afins

🏆 Conclusão

Guia para Aprender Klingon

1. Obtenha recursos de aprendizado

2. Comece com o básico

3. Pratique com outros aprendizes

4. Assista a episódios de Star Trek em klingon

5. Pratique regularmente

6. Participar de convenções e eventos

7. Assista a vídeos no YouTube

8. Imersão na cultura klingon

Conclusão

Guia de Estudos de Matemática para Programadores

Álgebra Linear

Cálculo

Estatística

Teoria dos Grafos

🧱 2. O `EntityBuilder`

Adicionando um Decorator `DefaultValue`

Passo 2: Crie um arquivo `Dockerfile`

Passo 3: Crie um arquivo `docker-compose.yml`