arquitetura.md

-### Principios da arquitetura utilizada Front e Back
+| [Home](home) | [**Escopo**](escopo) | [Processo](processo) | [Design/Mockups](design_mockups) | [Gerência](gerencia) | [Estudos](estudos) | [Arquitetura](arquitetura) | [Contratos](contratos) | [BD](banco_dados) | [Qualidade](qualidade) | [Configuração](configuracao) | [Instalação](instalacao) | [Instruções](instrucoes) | [Utilização](utilizacao) | [Analytics](Analytics) |
+| :----------: | :----------: | :----------: | :----------: | :----------: | :----------: | :----------: | :----------: | :----------: | :----------: | :----------: | :----------: | :----------: | :----------: | :----------: |
 
-### TDD (Test-Driven Development)
-TDD é uma abordagem de desenvolvimento de software em que os testes são escritos antes do código funcional. O ciclo básico do TDD é "Red, Green, Refactor":
-1. **Red**: Escreva um teste que falhe (não há funcionalidade implementada ainda).
-2. **Green**: Escreva código suficiente para fazer o teste passar.
-3. **Refactor**: Refatore o código para melhorar sua estrutura sem alterar sua funcionalidade.
 
-O TDD ajuda a garantir que o código seja bem testado e que os desenvolvedores criem código funcional que atende exatamente aos requisitos especificados pelos testes.
+# Arquitetura da Aplicação
 
-### BDD (Behavior-Driven Development)
-BDD é uma metodologia de desenvolvimento de software que estende o TDD (Test-Driven Development) para incluir uma abordagem centrada no comportamento do usuário. Em BDD, o foco está em definir o comportamento do sistema em termos de histórias de usuários e critérios de aceitação, escritos em uma linguagem natural que é compreensível para todas as partes interessadas, incluindo desenvolvedores, testadores e clientes.
+## Descrição
 
-**Exemplo de como funciona:**
-- Um cenário típico em BDD é escrito na forma "Dado que... Quando... Então...". 
-- **Dado que**: define o estado inicial do sistema.
-- **Quando**: descreve a ação que o usuário executa.
-- **Então**: especifica o resultado esperado dessa ação.
+Nesta seção, detalhamos a arquitetura da aplicação, abordando as tecnologias utilizadas, o fluxo de deploy e a estrutura dos componentes. Além disso, descrevemos as metodologias de desenvolvimento adotadas, que visam garantir a qualidade e a eficiência no ciclo de vida do software.
 
-BDD permite que as equipes capturem os requisitos funcionais de uma maneira clara e testável, focando no valor para o usuário final.
+## Sumário
 
-### DDD (Domain-Driven Design)
-DDD é uma abordagem para o desenvolvimento de software que enfatiza a importância do modelo de domínio no centro de todos os processos de design. Em DDD, o software é estruturado em torno do domínio principal, usando uma linguagem ubíqua que reflete as preocupações do negócio.
+- [Definição das Tecnologias](#definição-das-tecnologias)
+  - [Backend](#backend)
+  - [Frontend](#frontend)
+- [Diagrama de Componentes](#diagrama-de-componentes)
+- [Diagrama de Deploy](#diagrama-de-deploy)
+- [Metodologias de Desenvolvimento](#metodologias-de-desenvolvimento)
+  - [Backend - BDD e DDD](#backend---bdd-e-ddd)
+  - [Frontend - MVC](#frontend---mvc)
 
-**Componentes principais do DDD:**
-- **Entidades**: Objetos que têm uma identidade única ao longo do tempo.
-- **Agregados**: Um grupo de objetos que devem ser tratados como uma unidade.
-- **Serviços de Domínio**: Lógicas que não pertencem a uma entidade específica.
-- **Repositórios**: Objetos que fornecem acesso ao armazenamento de entidades e agregados.
-- **Value Objects**: Objetos que são definidos apenas por seus atributos, sem identidade única.
+## Definição das Tecnologias 
 
-### Uso de MVC em Aplicações Frontend
-O MVC (Model-View-Controller) é uma arquitetura de software que separa as responsabilidades em três componentes:
-- **Model**: Lida com a lógica de dados e a regra de negócios.
-- **View**: Cuida da apresentação dos dados ao usuário.
-- **Controller**: Intermediário que manipula as interações do usuário, chamando o modelo para processar os dados e atualizando a visualização.
+### Backend 
 
-**Justificativa no Frontend:**
-No seu projeto de frontend, que envolve TypeScript, Next.js, e Tailwind CSS, a aplicação do MVC ajuda a organizar o código de forma que as responsabilidades estejam claramente definidas:
-- **Model**: Representa os dados e a lógica que manipula esses dados, talvez via hooks ou state management.
-- **View**: Implementa a interface do usuário, provavelmente usando componentes React estilizados com Tailwind CSS.
-- **Controller**: Pode ser representado pelos handlers ou pela lógica de roteamento no Next.js, coordenando as interações do usuário e manipulando as requisições e respostas.
+- **Linguagem**: JavaScript + TypeScript
+- **Ambiente de execução**: Node.js
+- **Framework para API**: Nest.js
+- **Banco de dados**: PostgreSQL
+- **Interface de persistência**: Prisma ORM
+- **Documentação da API**: Swagger
+- **Testes**: Jest
+- **Containerização**: Docker + Docker Compose
 
-Essa separação facilita a manutenção, testes e evolução da aplicação, permitindo que diferentes partes do código possam ser desenvolvidas, testadas e refatoradas de maneira independente.
+### Frontend
 
-### Estrutura Modular no Backend
-No backend, uma estrutura modular significa organizar o código em módulos independentes que encapsulam a lógica relacionada a um único aspecto do sistema (ex. autenticação, manipulação de dados, etc.).
+- **Linguagem**: JavaScript + TypeScript
+- **Ambiente de execução**: Node.js
+- **Framework**: Next.js
+- **Estilização**: Tailwind CSS
+- **Gerenciamento de requisições HTTP**: Axios
+- **Testes**: Jest
 
-**Justificativa no seu projeto:**
-Em seu projeto, que utiliza um backend com Nest.js e o padrão de Clean Architecture, a estrutura modular é crucial para manter a separação de preocupações:
-- **Modularidade**: Cada módulo no backend (como módulos de autenticação, banco de dados, API) é encapsulado, o que significa que suas dependências e lógicas são isoladas. Isso facilita o desenvolvimento paralelo e a refatoração.
-- **Testabilidade**: A modularidade também permite testes mais granulares. Por exemplo, você pode testar um módulo de autenticação sem ter que se preocupar com a lógica do banco de dados.
-- **Escalabilidade**: À medida que o sistema cresce, novos módulos podem ser adicionados sem impactar diretamente os existentes. Isso também ajuda a adotar práticas como DDD, onde cada módulo pode representar um agregado ou serviço de domínio.
+## Diagrama de Componentes
 
-Portanto, tanto o MVC no frontend quanto a estrutura modular no backend complementam o uso de TDD, BDD e DDD, fornecendo uma base sólida para o desenvolvimento de software escalável, testável e orientado ao domínio.
+O diagrama de componentes abaixo ilustra a estrutura principal da aplicação, evidenciando a interação entre os componentes do frontend e backend. 
\ No newline at end of file
+
+### Frontend:
+O frontend é composto por dois módulos principais:
+- **App**: Representa as telas que compõem a interface do usuário, onde ocorrem as interações.
+- **Components**: São partes reutilizáveis da interface, como botões e formulários, que podem ser incorporados em diferentes telas.
+
+### Backend:
+No backend, seguindo o padrão modular do Nest.js, os subcomponentes são divididos de acordo com responsabilidades específicas, facilitando a escalabilidade e manutenção da aplicação. Estes módulos lidam com autenticação, comunicação com o banco de dados, lógica de negócios, entre outras funções críticas.
+
+![Diagrama de Componentes](resources/images/arquitetura/hortti_logo.jpeg)
+
+## Diagrama de Deploy
+
+O diagrama de deploy a seguir detalha o processo automatizado de entrega contínua da aplicação. Cada vez que um commit é enviado para a branch principal (Main), são acionadas várias etapas de verificação e validação, incluindo:
+
+1. **Linting**: Verificação de boas práticas e padrões de código.
+2. **Testes Unitários**: Execução de testes automatizados para garantir a integridade das funcionalidades.
+3. **Deploy**: Após as validações, o código é automaticamente enviado e implantado em instâncias da AWS.
+
+### Infraestrutura:
+- **Frontend e Backend**: Ambos são executados dentro de containers no mesmo EC2, garantindo consistência e isolamento de ambiente.
+- **Banco de dados**: O PostgreSQL também está em execução na AWS, comunicando-se diretamente com o backend para garantir a persistência dos dados.
+
+Essa automação garante que as atualizações do código sejam rapidamente entregues ao ambiente de produção, assegurando que a aplicação esteja sempre com a versão mais recente disponível para os usuários.
+
+![Diagrama de Deploy](resources/images/arquitetura/hortti_logo.jpeg)
+
+## Metodologias de Desenvolvimento
+
+### Backend - BDD e DDD
+
+#### BDD (Behavior-Driven Development)
+O **BDD** é uma metodologia que expande o TDD (Test-Driven Development) ao focar no comportamento do sistema do ponto de vista do usuário. Essa abordagem permite uma comunicação clara entre as partes interessadas e a equipe de desenvolvimento, utilizando uma linguagem comum, acessível para todos os envolvidos.
+
+- **Formato típico**: Os cenários em BDD seguem o formato "Dado que... Quando... Então...", onde:
+  - **Dado que**: Define o estado inicial do sistema.
+  - **Quando**: Descreve a ação do usuário.
+  - **Então**: Especifica o resultado esperado.
+
+Isso garante que o software seja desenvolvido de acordo com os requisitos funcionais e focado nas necessidades reais dos usuários.
+
+#### DDD (Domain-Driven Design)
+O **DDD** foca na modelagem do domínio de negócios, estabelecendo uma linguagem comum entre os desenvolvedores e especialistas do domínio. A estrutura do software é baseada no entendimento profundo das regras e processos do negócio.
+
+Principais conceitos do DDD:
+- **Entidades**: Objetos com identidade única.
+- **Agregados**: Conjuntos de entidades que formam uma unidade lógica.
+- **Serviços de Domínio**: Funcionalidades que não pertencem diretamente a uma entidade.
+- **Repositórios**: Interfaces que lidam com o armazenamento e recuperação de entidades.
+- **Value Objects**: Objetos que são definidos apenas por seus atributos.
+
+Essa metodologia permite que o software evolua de forma orgânica, acompanhando as mudanças no domínio de negócio.
+
+### Frontend - MVC
+
+#### MVC (Model-View-Controller)
+A arquitetura **MVC** separa a aplicação em três partes principais, facilitando o desenvolvimento e a manutenção do código:
+
+- **Model**: Gerencia os dados e a lógica de negócios da aplicação. No frontend, isso pode incluir hooks, estados e manipulação de dados da API.
+- **View**: Define a interface visual da aplicação, utilizando componentes React estilizados com Tailwind CSS para garantir uma experiência de usuário consistente e responsiva.
+- **Controller**: Atua como intermediário, lidando com as interações do usuário e as respostas da API, implementado no Next.js através de rotas e controladores.
+
+Essa abordagem garante uma clara separação de responsabilidades, tornando a aplicação mais modular e fácil de escalar.
+
+---
+
+                                                                                                         [**Topo**](#arquitetura-da-aplicação)
\ No newline at end of file