Vamos começar a evoluir o AnyBank? Vamos abrir o terminal. Já baixamos o projeto inicial. As instruções estão na atividade "Preparando o Ambiente", você pode baixá-lo também.
Já rodamos o npm install para instalar as dependências. Agora, vamos abrir o VSCode dentro do projeto e pedir para o npm executar o script de dev (npm run dev) para levantar a aplicação no localhost:5173. Podemos dar uma olhada nela para ver com o que vamos trabalhar.
Explorando o projeto
A página inicial já está carregada. O que queremos destacar neste primeiro momento é que a camada visual já está desenvolvida, mas não possui comportamento algum. O único comportamento existente é o de navegação. Podemos navegar para a página de cadastro clicando em "Abrir conta" e para a página de login clicando em "Login". Quando clicamos no logo do AnyBank, voltamos para a página inicial. Esse é o único comportamento desenvolvido até agora.
Se observarmos o projeto no VSCode, vamos abrir o arquivo que está em "src > router > index.tsx". Este é o nosso roteador, e estamos usando o react-router-dom neste projeto.
import { createBrowserRouter } from "react-router-dom";
import Home from "../Home";
import RootLayout from "../RootLayout";
import Login from "../Login";
import Register from "../Register";
import AuthLayout from "../AuthLayout";
export const router = createBrowserRouter([
{
path: "/",
element: <RootLayout />,
children: [
{
path: "",
element: <Home />,
},
{
path: "/auth",
element: <AuthLayout />,
children: [
{
path: "login",
element: <Login />,
},
{
path: "register",
element: <Register />,
},
]
},
],
},
]);
Vamos destacar alguns pontos de atenção. Primeiro, temos um RootLayout. Vamos fazer um Ctrl + Clique para entrar nele, que basicamente organiza o Header e renderiza o Outlet.
const RootLayout = () => {
return (
<>
<Header />
<Container>
<Outlet />
</Container>
</>
)
}
Além disso, temos o AuthLayout, que é um layout específico que renderiza tudo dentro de um card.
const AuthLayout = () => {
return (
<Card>
<Outlet />
</Card>
)
}
Na tela, ao clicar em "Abrir conta" e "Login", esse card já está organizado no projeto.
Temos três rotas disponíveis: a página inicial, que é a rota /, um grupo de rotas que é /auth, e dentro desse grupo temos /auth/login e /auth/register. Com isso, temos a base necessária para começar.
Se você tiver dificuldade para ver como esses componentes foram desenvolvidos, vamos dar detalhes sobre um específico, e você pode explorar os outros.
Por exemplo, no componente "Button", no "index.tsx", estamos usando Styled Components. Há várias coisas já desenvolvidas focadas no CSS e no layout. Essa é a base do projeto. Toda a camada visual já está pronta.
Pensando os casos de uso
Agora que falamos sobre isso, por onde vamos começar? Vamos voltar ao navegador e focar na parte de login. Vamos começar a pensar nas interações com a aplicação como se fosse um caso de uso. Temos um cenário onde a pessoa usuária gostaria de executar o login ou, olhando para o cadastro, gostaria de se cadastrar na aplicação. Com esse pensamento, vamos organizar isso e pensar em um caso de uso para o nosso cadastro.
Vamos para o VSCode. Dentro de "src", vamos criar uma pasta chamada "domain". Vamos criar uma pasta chamada "domain" porque ela representa o domínio da nossa aplicação. Tudo que estiver mais próximo da regra de negócio e de como a aplicação deve se comportar, e menos da parte de implementação, como CSS, modules ou styled components, começamos a separar.
Dentro dessa pasta "domain", vamos criar três pastas. A primeira será "useCases". Já conversamos que vamos organizar nosso pensamento baseado em casos de uso, então serão "useCases".
O código está todo em inglês, então vamos manter esse padrão, mas traduziremos os termos conforme necessário.
Vamos criar também outra pasta dentro de "domain", chamada "Entities". Pensando em entidade, podemos começar pensando no fluxo da aplicação com o cadastro. Precisamos imaginar como será a interface da pessoa usuária.
Implementando a parte de cadastro
Vamos criar um novo arquivo no VSCode, chamá-lo de "IUser.ts", e criar uma interface e já exportá-la:
export interface IUser {
id: string;
name: string;
email: string;
password: string;
}
No projeto, optamos por indicar interfaces com o prefixo I, uma convenção que trazemos do C#. Isso ajuda a identificar interfaces rapidamente. Se preferir, você pode não usar esse prefixo, mas neste projeto, usaremos I para indicar interfaces.
Pensando no formato da pessoa usuária, temos id, name, email e password, todos como string. Esses campos vêm da nossa página de cadastro.
Dando sequência, vamos pensar no nosso caso de uso. Dentro de "useCases", vamos criar o nosso primeiro caso de uso, chamado "CreateUser.ts". Vamos exportar uma classe com o mesmo nome:
export class CreateUser {
execute(user: IUser) {
}
}
Queremos executar uma ação, então chamaremos um método execute, que receberá um usuário por parâmetro. Queremos cadastrar esse usuário em algum lugar, mas não queremos detalhes dessa implementação agora. Vamos criar um código que não compila, mas serve para começarmos a desenvolver. Vamos criar um construtor para essa classe:
export class CreateUser {
constructor(private userRepository: IUserRepository) {}
execute(user: IUser) {
}
}
Queremos que o construtor receba um repositório de usuário, responsável por cadastrar o usuário. O tipo será IUserRepository, e ele será injetado. A classe IUserRepository ainda não existe, então vamos criá-la.
Dentro de "domain", vamos criar uma pasta chamada "repositories" e criar a interface IUserRepository.ts:
export interface IUserRepository {
createUser(user: Omit<IUser, 'id'>): Promise<void>;
}
Essa interface terá um método createUser, que receberá um usuário sem o id, pois ele deve ser criado depois. O método será assíncrono, retornando uma Promise<void>.
No arquivo "CreateUser", vamos implementar o método execute. Porém, como o repositório não receberá o id logo de cara, isso também não acontece na execução. Em seguida, faremos um this. userRepository já injetado e chamar o createUser passando o usuário que acabamos de receber. Podemos dizer uqe o método é assíncrono acrescentando async na frente ou indicá-lo como uma Promise<void>.
export class CreateUser {
constructor(private userRepository: IUserRepository) {}
async execute(user: Omit<IUser, 'id'>) {
this.userRepository.createUser(user);
}
}
Agora temos o nosso caso de uso, o repositório e a interface, mas ainda está abstrato. Precisamos pensar na camada mais concreta: qual será o repositório que realmente cadastrará o usuário? Vamos fazer isso no próximo vídeo.