Skip to content

9. Estudo de caso: o servidor de cálculo de imposto em NestJS

Image

9.1. Recapitulação do requisito

O servidor a ser portado é um servidor de cálculo de imposto de renda (PHP) (veja Introdução à linguagem PHP7 por meio de exemplos), com arquitetura em camadas (Config / Entities / Model-DAO-Business / Controllers / Responses / Views), com um controller front-end (main.php) que roteia as requisições recebidas — todas elas na forma de URL (main.php?action=...) — para o controller apropriado de acordo com a ação. O objetivo do port era preservar exatamente essa arquitetura MVC no NestJS, ação por ação, código de status por código de status, de modo que permanecesse compatível com o cliente HTML/TypeScript já escrito para o servidor PHP.

9.2. A arquitetura MVC é mantida

O mapeamento entre os dois servidores é direto:

  • Config/config.json ↔ ConfigService;
  • Entities/*.php ↔ entities/*.entity.ts (TaxAdminData, Simulation);
  • Model/ServerDao*.php ↔ ServerDaoService (camada [DAO], Capítulo 5);
  • Model/ServerBusiness.php ↔ ServerBusinessService (camada [business], escopo linha a linha);
  • Controllers/*Controller.php (um por ação) ↔ um controller de ação por classe TypeScript, selecionado dinamicamente por um registro (ActionsRegistryService);
  • Responses/*Response.php ↔ ResponseSenderService (JSON, XML) e HtmlViewRendererService (HTML);
  • Views/*.php ↔ templates EJS (views/*.ejs), com o mesmo layout Bootstrap.
Nota: Todas as ações deste servidor passam por uma única rota, http://localhost:3000/main.php; o nome da ação requisitada é sempre fornecido como parâmetro da query string, ?action=nome-da-ação — nunca no caminho da URL. Trata-se de um desenho de URL deliberado, que difere dos exemplos dos capítulos anteriores (ações [/a01], [/m01]... roteadas por segmento de caminho), e que é mantido aqui exatamente como era no servidor PHP original, para permanecer compatível com o cliente já escrito.

9.3. Estrutura de arquivos do projeto

Antes de detalhar cada camada, eis a estrutura completa de diretórios do projeto nestjs-case-study, como ela aparece depois de executar npm install (a pasta dist/ , gerada por npm run build, e o diretório node\_modules/ não são mostrados):

nestjs-case-study/
+-- .env.example
+-- .gitignore
+-- README.md
+-- create_dbtaxes.sql
+-- nest-cli.json
+-- package.json
+-- tsconfig.json
+-- tsconfig.build.json
+-- data/
| +-- tax-admin-data.json
+-- Logs/
+-- public/
| +-- Resources/
| +-- logo.jpg
+-- views/
| +-- view-authentication.ejs
| +-- view-tax-calculation.ejs
| +-- view-simulations-list.ejs
| +-- view-errors.ejs
| +-- partials/
| +-- banner.ejs
| +-- menu.ejs
| +-- authentication-form.ejs
| +-- tax-calculation-form.ejs
| +-- simulations-list-table.ejs
+-- src/
    +-- main.ts
    +-- app.module.ts
    +-- main.controller.ts
    +-- config/
    | +-- config.service.ts
    +-- entities/
    | +-- simulation.entity.ts
    | +-- tax-admin-data.entity.ts
    | +-- tax-exception.ts
    +-- model/
    | +-- server-dao.interface.ts
    | +-- server-dao.service.ts
    | +-- server-business.service.ts
    +-- actions/
    | +-- action-controller.interface.ts
    | +-- actions-registry.service.ts
    | +-- init-session.controller.ts
    | +-- authenticate-user.controller.ts
    | +-- calculate-tax.controller.ts
    | +-- display-tax-calculation.controller.ts
    | +-- list-simulations.controller.ts
    | +-- delete-simulation.controller.ts
    | +-- end-session.controller.ts
    | +-- admin-data.controller.ts
    +-- responses/
    | +-- response-sender.service.ts
    +-- views/
    | +-- view-models.ts
    | +-- html-view-renderer.service.ts
    +-- session/
    | +-- session.types.ts
    +-- utilities/
    | +-- logger.service.ts
    +-- filters/ (reserved, currently empty)

O papel de cada elemento:

  • .env / .env.example — variáveis de ambiente (porta, segredo da sessão, parâmetros do MySQL e de TAX_DATA_SOURCE etc.) lidas por ConfigService; .env não é versionado (.gitignore); .env.example serve de modelo para copiar (cp .env.example .env);
  • .gitignore — exclui node_modules/, dist/, .env, e os logs do repositório;
  • README.md — documentação do projeto (instalação, mapeamento entre PHP e NestJS, estrutura de diretórios anotada): este capítulo resume e amplia esse conteúdo;
  • create_dbtaxes.sql — script de criação do banco de dados MySQL dbtaxes-2019 (tabelas tbbrackets, tbconstants..., usado somente quando TAX_DATA_SOURCE=mysql);
  • nest-cli.json, tsconfig.json, tsconfig.build.json — configuração da CLI, do NestJS e do compilador TypeScript, já discutidas nos capítulos anteriores;
  • package.json — dependências (ejs, express-session, mysql2, js2xmlparser, dotenv...) e scripts npm (start, start:dev, build);
  • data/tax-admin-data.json — conjunto de dados tributários de reserva, usado quando TAX_DATA_SOURCE=json: não é preciso instalar o MySQL para testar o servidor;
  • Logs/ — diretório de logs da aplicação (logs.txt), gravado por LoggerService; criado automaticamente na inicialização, caso ainda não exista;
  • public/Resources/logo.jpg — imagem estática, servida tal como está por app.useStaticAssets(...) em main.ts, usada pelo banner das views HTML;
  • views/ (na raiz do projeto) — os templates EJS e seus partials, detalhados mais adiante em “Construindo páginas HTML”;
  • src/main.ts — ponto de entrada: inicia o servidor NestJS (veja abaixo);
  • src/app.module.ts — módulo raiz: declara MainController como único controller e todos os providers da aplicação;
  • src/main.controller.ts — o controller front-end, já descrito acima;
  • src/config/ — a configuração da aplicação (ConfigService), detalhada mais adiante;
  • src/entities/ — as classes de dados (Simulation, TaxAdminData, TaxException), detalhadas mais adiante;
  • src/model/ — as camadas [DAO] e [business];
  • src/actions/ — um controller por ação, a interface comum ActionController, e o registro ActionsRegistryService;
  • src/responses/ — geração de respostas (JSON/XML) e tratamento de CORS (ResponseSenderService);
  • src/views/ — Nota: não confunda com o diretório views/ da raiz do projeto. Esta pasta contém apenas TypeScript: a construção dos modelos de exibição (view-models.ts) e a seleção/renderização da view (EJS) (html-view-renderer.service.ts);
  • src/session/ — tipagem TypeScript da sessão do Express (session.types.ts);
  • src/utilities/ — logging (LoggerService);
  • src/filters/ — diretório reservado, atualmente vazio: ainda não utilizado nesta versão do projeto.

Dois arquivos merecem uma menção adicional: src/main.ts e src/app.module.ts, ambos específicos deste projeto (além do framework já abordado nos capítulos anteriores). Trecho de src/main.ts:

async function bootstrap() {
  const app = await NestFactory.create<NestExpressApplication>(AppModule);

  app.useStaticAssets(join(process.cwd(), 'public'));

  app.use(
    session({
      secret: process.env.SESSION_SECRET ?? 'change-me-in-production',
      resave: false,
      saveUninitialized: false,
      cookie: { httpOnly: true, sameSite: 'lax', secure: false, path: '/' },
    }),
  );

  const port = Number(process.env.PORT ?? 3000);
  await app.listen(port);
}

Vamos comentar este código:

  • linha 4: app.useStaticAssets(join(process.cwd(), 'public')); — serve tal como estão os arquivos da pasta public/ (aqui, public/Resources/logo.jpg) por meio de uma rota estática, sem passar por um controller do NestJS;
  • Linha 6: app.use(session({...})); — instala o middleware express-session diretamente na aplicação NestJS: app.use(...) funciona aqui exatamente como em uma aplicação Express comum, sobre a qual o NestJS é construído — é isso que dá sentido a request.session em MainController e em cada controller de ação;
  • linha 13: const port = Number(process.env.PORT ?? 3000); — a porta de escuta, como o restante das configurações ajustáveis, vem de uma variável de ambiente (no .env arquivo), com 3000 como valor padrão.

src/app.module.ts é o módulo raiz (já encontrado nos capítulos anteriores): ele declara MainController como único controller e lista todos os providers da aplicação em seu array providers — os serviços (ConfigService, LoggerService, ServerDaoService, ServerBusinessService, ResponseSenderService, HtmlViewRendererService, ActionsRegistryService) e os oito controllers de ação, todos os quais podem ser injetados uns nos outros por esse mesmo mecanismo de injeção de dependência.

9.4. O controller front-end

Um único controller (NestJS, MainController) recebe todas as requisições para /main.php?action=... (@All('main.php')): ele recupera o parâmetro action, verifica as pré-condições comuns a todas as ações (ação conhecida, sessão inicializada, usuário autenticado) e, em seguida, delega ao controller da ação em questão.

Trecho de src/main.controller.ts:

@Controller()
export class MainController {
  constructor(
    private readonly configService: ConfigService,
    private readonly responseSender: ResponseSenderService,
    private readonly actionsRegistry: ActionsRegistryService,
  ) {}

  @All('main.php')
  async handle(@Req() request: Request, @Res() response: Response): Promise<void> {
    const action = String(request.query.action ?? '').toLowerCase();

    if (!this.actionsRegistry.has(action)) {
      // ... status 102: ação inválida
    }
    if (!request.session.type && action !== 'init-session') {
      // ... status 103: nenhuma sessão em andamento
    }
    if (!request.session.user && action !== 'authenticate-user' && action !== 'init-session') {
      // ... status 104: usuário não autenticado
    }

    const controller = this.actionsRegistry.get(action);
    const result = await controller.execute(config, request, request.session);
    // ... construção e envio da resposta (§6.7)
  }
}

Vamos comentar este código:

  • linha 1: [@Controller()] — este decorador marca a classe como um controller NestJS -- usado aqui sem argumentos, ele não define nenhum prefixo comum: é a rota especificada abaixo, no próprio método, que determinará o prefixo exato;
  • linha 3: [constructor(...)] — injeção via construtor de três @Injectable() providers: o serviço de configuração, o serviço de envio de respostas e o registro de ações -- o NestJS os instancia e os fornece automaticamente, sem que seja preciso escrever new ConfigService() em lugar algum;
  • linha 9: [@All('main.php')] — @All é um decorador de rota que associa o método seguinte a todos os métodos HTTP (GET, POST, PUT, DELETE...) para a URL indicada — aqui /main.php (esse nome, herdado do servidor PHP, refere-se apenas a um caminho de URL no NestJS, e não a um arquivo PHP real que seja executado); é isso que permite que este mesmo controller trate tanto as ações de leitura (GET, por exemplo, init-session) quanto as que enviam dados (POST, por exemplo, calculate-tax), com uma única rota declarada;
  • linha 10: [@Req() request: Request, @Res() response: Response] — dois decoradores de parâmetro que já encontramos: @Req() injeta o objeto de requisição completo (método HTTP, cabeçalhos, query, body, sessão...) e @Res() injeta o objeto de resposta do Express, dando controle total sobre o que é retornado — necessário aqui porque este controller deve, conforme a situação, escolher ele mesmo o código de status HTTP e o formato da resposta (JSON, XML ou HTML), o que uma simples instrução return não permitiria com tanta precisão;
  • linha 11: [const action = String(request.query.action ?? '').toLowerCase();] — o parâmetro action é lido manualmente a partir de request.query — como optamos por @Req() em vez do decorador @Query('action') visto no capítulo anterior, o código precisa recuperar o valor no próprio objeto de requisição;
  • Linha 21: [const controller = this.actionsRegistry.get(action);] — uma vez verificadas as pré-condições, MainController não processa a ação por conta própria: ele usa o nome da ação para localizar o controller de ação correspondente (veja a próxima seção) e delega o trabalho a ele.
Nota: Este controller usa @Req() e @Res() em vez dos decoradores individuais (@Query(), @Body()etc.) do capítulo anterior: ele precisa de acesso completo à requisição (método, todos os parâmetros) e de controle total sobre a resposta enviada (escolha do código de status, formato) — exatamente como main.php fazia com os objetos Request e Response do Symfony.

9.5. Um controller de ação

Cada ação tem seu próprio controller, que implementa uma interface comum ActionController— a contrapartida em TypeScript da interface PHP InterfaceController. Eis uma versão simplificada do controller da ação [calculate-tax]:

Trecho de src/actions/calculate-tax.controller.ts:

@Injectable()
export class CalculateTaxController implements ActionController {
  constructor(
    private readonly dao: ServerDaoService,
    private readonly business: ServerBusinessService,
  ) {}

  async execute(config, request, session): Promise<ActionResult> {
    // ... validação dos parâmetros postados [married, children, salary]
    // (mesmos códigos de status numéricos do controller PHP original)

    const taxAdminData = await this.dao.getTaxAdminData();
    const result = this.business.calculateTax(married, children, salary, taxAdminData);

    const simulations = session.simulations ?? [];
    simulations.push(Simulation.fromAttributes({ married, children, salary, ...result }));
    session.simulations = simulations;

    return { statusCode: 200, status: 300, content: { response: result }, headers: {} };
  }
}

Vamos analisar este código:

  • linha 1: [@Injectable()] — primeiro ponto importante a observar aqui: CalculateTaxController é um provider comum (@Injectable()), e não um controller NestJS — ele não tem @Controller() nem rotas (@Get, @Post...); somente MainController (visto acima) é reconhecido pelo roteador HTTP do NestJS;
  • Linha 2: [export class CalculateTaxController implements ActionController] — esta classe implementa a interface específica do projeto ActionController (definida em action-controller.interface.ts), que exige apenas um método: execute(...) -- trata-se de uma convenção do projeto, não de um mecanismo do NestJS;
  • linha 3: [constructor(...)] — injeção via construtor de dois serviços: DAO ([DAO] camada, acesso aos dados do imposto) e lógica de negócio ([business] camada, cálculo puro);
  • linha 8: [async execute(config, request, session): Promise<ActionResult>] — o método chamado por MainController.handle() (controller.execute(...), veja acima) -- seus parâmetros não são decoradores do NestJS (@Body(), @Session()...), já que este método nunca é chamado diretamente pelo roteador HTTP: MainController já lhe passa manualmente a requisição e a sessão que ele próprio recebeu via @Req();
  • linha 12: [const taxAdminData = await this.dao.getTaxAdminData();] — recupera os dados do imposto (faixas, limites) necessários para o cálculo, por meio da [DAO] camada apresentada no capítulo anterior;
  • linha 19: [return { statusCode: 200, status: 300, content: { response: result }, headers: {} };] — segundo ponto importante: o que execute() retorna não é enviado como está ao navegador — é a estrutura específica do projeto ActionResult (statusCode, status, content, headers), que é analisada por MainController e depois repassada a ResponseSenderService, que constrói a resposta HTTP efetivamente enviada (JSON, XML ou HTML, conforme o tipo da sessão — veja abaixo).

Esta ação é disparada por uma requisição POST para http://localhost:3000/main.php?action=calculate-tax, com os três parâmetros "married," "children" e "salary" incluídos no corpo da requisição (e não na URL) — aliás, essa é a primeira coisa que execute() verifica, antes mesmo de ler esses parâmetros.

9.6. Os outros controllers de ação

Cada ação tem seu próprio controller, e todos implementam a mesma interface (a contrapartida em TypeScript da interface PHP InterfaceController) — trecho de src/actions/action-controller.interface.ts:

export interface ActionResult {
  statusCode: number;
  status: number;
  content: Record<string, unknown>;
  headers: Record<string, string>;
}

export interface ActionController {
  execute(config: AppConfig, request: Request, session: AppSession): Promise<ActionResult>;
}

e todos identificados por seus nomes de ação por meio de um registro, que por sua vez é injetado pelo construtor em MainController — trecho de src/actions/actions-registry.service.ts:

  constructor(
    initSession: InitSessionController,
    authenticateUser: AuthenticateUserController,
    calculateTax: CalculateTaxController,
    listSimulations: ListSimulationsController,
    deleteSimulation: DeleteSimulationController,
    endSession: EndSessionController,
    displayTaxCalculation: DisplayTaxCalculationController,
    adminData: AdminDataController,
  ) {
    this.registry = {
      'init-session': initSession,
      'authenticate-user': authenticateUser,
      'calculate-tax': calculateTax,
      'list-simulations': listSimulations,
      'delete-simulation': deleteSimulation,
      'end-session': endSession,
      'display-tax-calculation': displayTaxCalculation,
      'get-admindata': adminData,
    };
  }

Vamos analisar este código:

  • O NestJS instancia cada um dos oito controllers de ação (usando @Injectable()) e os passa todos, já construídos, ao construtor de ActionsRegistryService— que simplesmente os armazena em um array associativo indexado pelo nome da ação;
  • esta tabela (this.registry) cumpre exatamente a mesma função da tabela [actions] em Config/config.json no lado PHP, mas sem nunca instanciar nada manualmente: has(action) e get(action) são os dois únicos métodos usados por MainController.

A ação [calculate-tax] já foi descrita em detalhes acima. Eis o que distingue cada um dos outros sete controllers de ação:

  • init-session.controller.ts — inicializa o tipo de resposta da sessão (session.type = json, html, ou xml); deve ser a primeira ação chamada (é a única dispensada, por MainController, da verificação de “nenhuma sessão atual”); exige o método GET e exatamente dois parâmetros de requisição (action, type);
  • authenticate-user.controller.ts — verifica o par login/password enviado em relação à lista em config.users; constrói seu código de status somando bits de erro (status += 2 se username estiver ausente, status += 4 se password estiver ausente) — mesma lógica numérica do validador PHP original;
  • list-simulations.controller.ts — o mais simples de todos: retorna session.simulations ?? [], sem nenhum cálculo;
  • delete-simulation.controller.ts — executa uma série de verificações (método/número de parâmetros, presença do parâmetro “number”, sintaxe numérica, índice dentro dos limites do array), acumulando o código de status bit a bit a cada etapa bem-sucedida, e então chama simulations.splice(number, 1) e salva novamente o array na sessão;
  • display-tax-calculation.controller.ts — ainda mais curto que list-simulations: não faz absolutamente nada além de retornar o código de status 800, para que o cliente simplesmente mude para outra view (de volta ao formulário de cálculo) sem nenhum processamento no servidor;
  • admin-data.controller.ts — delega diretamente a ServerDaoService.getTaxAdminData() e intercepta TaxException para retornar o status de erro 1041; junto com calculate-tax, é um dos dois únicos controllers de ação que injetam a [DAO] camada em seu construtor;

O caso de src/actions/end-session.controller.ts merece uma análise mais detida por causa de uma armadilha clássica do Express-Session:

async execute(config: AppConfig, request: Request, session: AppSession): Promise<ActionResult> {
  const method = request.method.toLowerCase();
  const nbParams = Object.keys(request.query).length;
  if (method !== 'get' || nbParams !== 1) {
    return {
      statusCode: 400,
      status: 401,
      content: { response: "GET required with the single parameter [action] in the URL" },
      headers: {},
    };
  }
  const type = session.type;
  await new Promise<void>((resolve) => session.regenerate(() => resolve()));
  request.session.type = type;
  return {
    statusCode: 200,
    status: 400,
    content: { response: 'session deleted' },
    headers: {},
  };
}

Vamos comentar este código:

  • linha 9: const type = session.type; — guardamos o tipo de resposta (json/html/xml) antes de destruir a sessão, pois precisaremos restaurá-lo na nova;
  • linha 10: await new Promise<void>((resolve) => session.regenerate(() => resolve())); — um ponto delicado deste controller: session.regenerate(callback), fornecido por express-session, é um método baseado em callback, e não uma Promise; por isso o envolvemos em uma Promise para poder usar await nele como no resto do código; regenerate() limpa a sessão atual e lhe atribui um identificador totalmente novo (o equivalente à destruição de sessão do Symfony);
  • linha 11: request.session.type = type; — segundo ponto delicado: após regenerate(), request.session aponta para uma nova instância de sessão; a antiga session referência, capturada nos parâmetros de execute() antes da chamada, agora está órfã — e é por isso que o tipo é reatribuído a request.session em vez de a session; caso contrário, ele seria perdido silenciosamente.

9.7. A camada [DAO]

ServerDaoService (§5.1) fornece os dados do imposto (faixas, limites) à camada de negócio, seja a partir de um arquivo JSON (útil para testes sem banco de dados), seja a partir do MySQL com mysql2, conforme um parâmetro de configuração.

Trecho de src/model/server-dao.interface.ts— um contrato mínimo, um único método que toda implementação da [DAO] camada deve fornecer:

1
2
3
export interface IServerDao {
  getTaxAdminData(): Promise<TaxAdminData>;
}

Trecho de src/model/server-dao.service.ts, a única implementação desse contrato neste projeto:

@Injectable()
export class ServerDaoService implements IServerDao {
  constructor(private readonly configService: ConfigService) {}

  async getTaxAdminData(): Promise<TaxAdminData> {
    const { taxDataSource } = this.configService.config;
    if (taxDataSource === 'mysql') {
      return this.getTaxAdminDataFromMysql();
    }
    return this.getTaxAdminDataFromJson();
  }

  private async getTaxAdminDataFromJson(): Promise<TaxAdminData> {
    const { jsonTaxDataFile } = this.configService.config;
    try {
      const fileContents = fs.readFileSync(jsonTaxDataFile, 'utf-8');
      const attributes = JSON.parse(fileContents);
      return TaxAdminData.fromAttributes(attributes);
    } catch (ex) {
      throw new TaxException(
        `The tax data file [${jsonTaxDataFile}] could not be processed: ${(ex as Error).message}`,
      );
    }
  }

  private async getTaxAdminDataFromMysql(): Promise<TaxAdminData> {
    const { mysql: dbConfig } = this.configService.config;
    let connection: mysql.Connection | null = null;
    try {
      connection = await mysql.createConnection({
        host: dbConfig.host,
        port: dbConfig.port,
        database: dbConfig.database,
        user: dbConfig.user,
        password: dbConfig.password,
      });

      // faixas do imposto (tabela tbbrackets)
      const [brackets] = await connection.query<RowDataPacket[]>(
        'select limits, coeffR, coeffN from tbbrackets order by id',
      );
      const limits = brackets.map((row) => Number(row.limits));
      const coeffR = brackets.map((row) => Number(row.coeffR));
      const coeffN = brackets.map((row) => Number(row.coeffN));

      // constantes de cálculo (tabela tbconstants)
      const [constantsRows] = await connection.query<RowDataPacket[]>(
        'select halfShareQfCeiling, ... from tbconstants limit 1',
      );
      const row = constantsRows[0];

      return TaxAdminData.fromAttributes({
        limits, coeffR, coeffN,
        halfShareQfCeiling: Number(row.halfShareQfCeiling),
        // ... mesmas conversões Number(...) para as oito outras constantes
        // (veja o arquivo-fonte para a lista completa)
      });
    } catch (ex) {
      throw new TaxException(`[mysql] ${(ex as Error).message}`);
    } finally {
      if (connection) {
        await connection.end();
      }
    }
  }
}

Vamos comentar este código:

  • async getTaxAdminData(): Promise<TaxAdminData> { if (taxDataSource === 'mysql') ... } — o processo de decisão cabe em uma única linha: conforme config.taxDataSource (lido da variável de ambiente TAX_DATA_SOURCE), os dados são buscados no arquivo JSON ou no MySQL, mas o contrato exposto ao restante da aplicação (IServerDao) permanece inalterado — CalculateTaxController e AdminDataController não fazem ideia de qual fonte está realmente sendo usada;
  • getTaxAdminDataFromJson() — lê e analisa data/tax-admin-data.json de forma síncrona (fs.readFileSync); qualquer erro (arquivo ausente, JSON inválido) é interceptado e registrado como uma TaxException, com uma mensagem explícita — nunca uma exceção bruta do Node, que não seria propagada corretamente de volta ao cliente;
  • getTaxAdminDataFromMysql() — abre uma conexão MySQL a cada chamada usando mysql2/promise (nenhum pool de conexões é reutilizado: em coerência com a ausência de um cache Redis mencionada no README, cada consulta reverifica tudo); executa as duas consultas SQL (faixas e, depois, constantes), reconstrói um TaxAdminData a partir das linhas recuperadas e fecha sistematicamente a conexão em um bloco finally , independentemente de a leitura ter sido bem-sucedida ou não;
  • ambos os métodos privados retornam o mesmo tipo (Promise<TaxAdminData>), o que permite que getTaxAdminData() continue sendo uma simples fachada, sem nenhuma lógica de negócio própria.

9.8. A camada [business]

ServerBusinessService desconhece HTTP, sessões e o banco de dados: é uma portagem linha a linha do cálculo do imposto do servidor PHP, pura e testável independentemente do restante.

Trecho de src/model/server-business.service.ts:

@Injectable()
export class ServerBusinessService {
  calculateTax(
    married: string,
    children: number,
    salary: number,
    taxAdminData: TaxAdminData,
  ): TaxCalculationResult {
    // ... mesmo algoritmo de Model/ServerBusiness.php: quociente familiar,
    // teto, desconto, redução
  }

  private getTaxableIncome(salary: number, taxAdminData: TaxAdminData): number {
    let allowance = 0.1 * salary;
    if (allowance > taxAdminData.tenPercentAllowanceMax) {
      allowance = taxAdminData.tenPercentAllowanceMax;
    }
    if (allowance < taxAdminData.tenPercentAllowanceMin) {
      allowance = taxAdminData.tenPercentAllowanceMin;
    }
    return Math.floor(salary - allowance);
  }
}
  • linha 1: [@Injectable()] — mais uma vez, este mesmo decorador, pela mesma razão vista em outras partes deste capítulo: sem ele, o NestJS não conseguiria instanciar ServerBusinessService nem injetá-lo em CalculateTaxController acima;
  • linha 2: [export class ServerBusinessService {] — a partir daqui, exceto por este primeiro decorador, o código deixa de ser específico do NestJS: calculateTax(...) e getTaxableIncome(...) são código TypeScript padrão — uma portagem linha a linha do algoritmo PHP, sem HTTP nem banco de dados.

9.9. A configuração da aplicação

src/config/config.service.ts reúne, em um único serviço do NestJS, o que antes estava dividido entre Config/config.json e Config/database.json no lado PHP — com a diferença esperada de que a configuração sensível (senhas, segredos de sessão) agora vem de variáveis de ambiente (.env arquivo), em vez de um arquivo JSON versionado:

@Injectable()
export class ConfigService {
  readonly config: AppConfig;

  constructor() {
    this.config = {
      corsAllowed: (process.env.CORS_ALLOWED ?? 'true') !== 'false',
      actions: {
        'init-session': 'InitSessionController',
        // ... uma entrada por ação (veja actions-registry.service.ts),
        // mantida apenas para fins de documentação
      },
      types: ['json', 'html', 'xml'],
      users: [{ login: 'admin', passwd: 'admin' }],
      taxDataSource: (process.env.TAX_DATA_SOURCE as 'json' | 'mysql') ?? 'json',
      jsonTaxDataFile: path.join(process.cwd(), 'data', 'tax-admin-data.json'),
      mysql: {
        host: process.env.DB_HOST ?? 'localhost',
        port: Number(process.env.DB_PORT ?? 3306),
        database: process.env.DB_NAME ?? 'dbtaxes-2019',
        user: process.env.DB_USER ?? 'admtaxes',
        password: process.env.DB_PASSWORD ?? 'pwdtaxes',
      },
      logsFilename: path.join(process.cwd(), 'Logs', 'logs.txt'),
      sessionSecret: process.env.SESSION_SECRET ?? 'change-me-in-production',
      views: {
        'view-authentication': [700, 221, 400],
        'view-tax-calculation': [200, 300, 341, 350, 800],
        'view-simulations-list': [500, 600],
      },
      errorsView: 'view-errors',
      viewsDir: path.join(process.cwd(), 'views'),
    };
    const logsDir = path.dirname(this.config.logsFilename);
    if (!fs.existsSync(logsDir)) {
      fs.mkdirSync(logsDir, { recursive: true });
    }
  }
}

Vamos comentar este código:

  • actions: { ... } — esta tabela é mantida unicamente para fins de documentação (ela descreve fielmente a arquitetura original): o roteamento real das ações não depende dela; ele é feito, em vez disso, por meio da injeção de dependência em ActionsRegistryService;
  • taxDataSource: (process.env.TAX_DATA_SOURCE as ...) ?? 'json' — lido da variável de ambiente TAX_DATA_SOURCE, este campo seleciona a fonte dos dados do imposto usada por ServerDaoService (veja acima);
  • views: { ... } — associa cada nome de template EJS à lista de status de resposta que devem exibi-lo (por exemplo, view-tax-calculation para os status 200, 300, 341, 350, 800); HtmlViewRendererService (veja “Construção das páginas HTML”) usa esta tabela para selecionar a view a ser renderizada;
  • errorsView: 'view-errors' — a view de contingência, exibida sempre que nenhuma view corresponder ao status atual;
  • última linha: if (!fs.existsSync(logsDir)) { fs.mkdirSync(logsDir, { recursive: true }); } — Ao ser criado, o próprio serviço cria a Logs/ pasta caso ela ainda não exista, para que LoggerService possa sempre gravar nela sem nunca precisar se preocupar com isso.

9.10. Entidades, sessão e logs

src/entities/ contém três classes de dados, portadas de Entities/*.php. Trecho de simulation.entity.ts— uma simulação de cálculo, armazenada em session.simulations:

export class Simulation {
  married: string;
  children: number;
  salary: number;
  tax: number;
  surcharge: number;
  discount: number;
  reduction: number;
  rate: number;

  static fromAttributes(attributes: Partial<Simulation>): Simulation {
    const simulation = new Simulation();
    Object.assign(simulation, attributes);
    return simulation;
  }
}

Trecho de tax-admin-data.entity.ts— as faixas do imposto e as constantes de cálculo lidas pela [DAO] camada:

export class TaxAdminData {
  limits: number[] = [];
  coeffR: number[] = [];
  coeffN: number[] = [];
  halfShareQfCeiling = 0;
  // ... as oito outras constantes de cálculo (veja o arquivo-fonte)

  static fromAttributes(attributes: Partial<TaxAdminData>): TaxAdminData {
    const entity = new TaxAdminData();
    Object.assign(entity, attributes);
    return entity;
  }
}

e tax-exception.ts — uma exceção de aplicação tipada, lançada pela [DAO] camada em caso de fonte de dados inacessível (arquivo JSON ilegível, falha na conexão MySQL...) e interceptada pelos handlers de ação que a exigem (calculate-tax, get-admindata):

1
2
3
4
5
6
export class TaxException extends Error {
  constructor(message: string, public readonly code: number = 0) {
    super(message);
    this.name = 'TaxException';
  }
}

src/session/session.types.ts não é um serviço: é uma declaração de tipos que estende o módulo express-session, para que o TypeScript possa acessar o conteúdo específico da aplicação (tipo de sessão, usuário autenticado, simulações salvas):

1
2
3
4
5
6
7
8
9
declare module 'express-session' {
  interface SessionData {
    type?: 'json' | 'html' | 'xml';
    user?: boolean;
    simulations?: Simulation[];
  }
}

export type AppSession = Session & Partial<SessionData>;
Nota: Esta técnica — a extensão de módulo (`declare module 'express-session'`) — é o que permite escrever `request.session.simulations` ou `session.user` em outras partes do projeto sem que o compilador `TypeScript` acuse erro; AppSession, o tipo real de req.session usado em todos os controllers de ação, deriva diretamente dela.

Por fim, src/utilities/logger.service.ts registra tudo o que o servidor faz (nova requisição, ação solicitada, controller selecionado, resposta retornada etc.) em Logs/logs.txt:

@Injectable()
export class LoggerService {
  constructor(private readonly configService: ConfigService) {}

  write(message: string): void {
    const timestamp = new Date().toISOString().replace('T', ' ').replace('Z', '');
    fs.appendFile(
      this.configService.config.logsFilename,
      `${timestamp} : ${message}\n`,
      () => { /* registro de log em melhor esforço, como no lado PHP */ },
    );
  }
}
Nota: A gravação é feita em modo best-effort (fs.appendFile assíncrono, sem esperar nem verificar o resultado): um problema ao gravar nos logs nunca deve fazer uma requisição falhar — exatamente a abordagem adotada por Utilities/Logger.php no lado PHP.

9.11. As respostas JSON, XML e HTML

ResponseSenderService constrói a resposta JSON ou XML (usando a biblioteca js2xmlparser), replica o tratamento de CORS do servidor PHP original (cabeçalhos Access-Control-Allow-* apenas para a origem localhost) e trata o caso especial do método OPTIONS (preflight de CORS).

Trecho de src/responses/response-sender.service.ts, que de fato constrói essa resposta:

async send(
  request: Request, response: Response, config: AppConfig,
  statusCode: number, content: Record<string, unknown>,
  headers: Record<string, string>, type: 'json' | 'html' | 'xml',
): Promise<void> {
  let body: string;
  let contentType: string;
  switch (type) {
    case 'xml':
      body = js2xmlparser.parse('root', content);
      contentType = 'application/xml';
      break;
    case 'html':
      body = await this.htmlViewRenderer.render(content, request);
      contentType = 'text/html';
      break;
    case 'json':
    default:
      body = JSON.stringify(content);
      contentType = 'application/json';
      break;
  }
  headers = { ...headers, 'content-type': contentType };
  this.sendResponse(request, response, statusCode, body, headers, config);
  this.logger.write(`response=${JSON.stringify(content)}\n`);
}

private sendResponse(
  request: Request, response: Response, statusCode: number,
  content: string, headers: Record<string, string>, config: AppConfig,
): void {
  if (config.corsAllowed) {
    const origin = request.headers.origin ?? '';
    if (origin.startsWith('http://localhost') || origin.startsWith('https://localhost')) {
      headers = {
        ...headers,
        'Access-Control-Allow-Origin': origin,
        'Access-Control-Allow-Headers': 'Accept, Content-Type',
        'Access-Control-Allow-Methods': 'GET, POST',
        'Access-Control-Allow-Credentials': 'true',
      };
    }
  }
  const method = request.method.toLowerCase();
  if (method === 'options') {
    content = '';
    statusCode = 200;
  }
  Object.entries(headers).forEach(([name, value]) => response.setHeader(name, value));
  response.status(statusCode).send(content);
}

Vamos comentar este código:

  • switch (type) { ... } — os três formatos de resposta são construídos aqui, e somente aqui: JSON por JSON.stringify, XML pela biblioteca js2xmlparser (que transforma o objeto content em um documento XML, com o elemento <root> como raiz) e HTML delegando inteiramente a HtmlViewRendererService.render(...), detalhado mais adiante;
  • this.logger.write(response=${JSON.stringify(content)}); — no modo HTML também, é o conteúdo da aplicação da resposta (content) que é registrado, nunca a página HTML inteira produzida — como HtmlResponse.php fazia;
  • em sendResponse(...), a verificação origin.startsWith('http://localhost') || origin.startsWith('https://localhost') replica exatamente a política de CORS do servidor PHP original (ParentResponse::sendResponse): somente origens localhost recebem os cabeçalhos Access-Control-Allow-*; nunca um domínio arbitrário;
  • if (method === 'options') { content = ''; statusCode = 200; } — caso especial do preflight de CORS: para uma requisição OPTIONS, só os cabeçalhos importam; o corpo da resposta é limpo e o código de status é forçado a 200, independentemente do processamento solicitado.

Para o modo type=html , HtmlViewRendererService replica a lógica de seleção de views do servidor PHP: cada status de resposta corresponde a uma view, selecionada a partir de uma tabela de configuração, com contingência para uma página de erro genérica caso nenhuma view corresponda. Cada view é um template EJS (views/*.ejs), uma tradução direta dos arquivos PHP originais, alimentado por um “template de exibição” gerado por uma função dedicada — o mesmo princípio do par getModelForThisView(...) / view PHP, com o benefício adicional do escape automático dos valores exibidos.

Nota: Para quem já conheceu o NestJS em outros contextos: esta renderização de HTML não usa o decorador @Render() fornecido pelo NestJS para associar um método de controller a uma engine de views (EJS, Handlebars, Pug...) -- Esse mecanismo exige um controller NestJS tradicional com uma rota por view, o que é incompatível com o controller front-end único deste servidor. ejs.renderFile(...) é, portanto, chamado diretamente, de forma manual, dentro de HtmlViewRendererService, e o HTML resultante é então enviado como texto simples via @Res() (veja acima): uma alternativa perfeitamente válida para renderizar views com o NestJS, mas sem passar por esse decorador específico.

9.12. Construção das páginas HTML

Vamos examinar mais de perto o modo type=html , cujo mecanismo se divide em três arquivos distintos: a seleção e a renderização da view (src/views/html-view-renderer.service.ts), a construção do “template de exibição” específico de cada view (src/views/view-models.ts) e os templates propriamente ditos (views/*.ejs e views/partials/*.ejs, na raiz do projeto — não confundir com a src/views/ pasta, que contém apenas TypeScript).

Trecho de src/views/html-view-renderer.service.ts:

@Injectable()
export class HtmlViewRendererService {
  constructor(private readonly configService: ConfigService) {}

  async render(content: Record<string, unknown>, request: Request): Promise<string> {
    const { views, errorsView, viewsDir } = this.configService.config;
    const status = content['status'] as number;

    const viewName = Object.keys(views).find((view) => views[view].includes(status)) ?? errorsView;

    const logo = buildLogoPath(request);

    let model: unknown;
    switch (viewName) {
      case 'view-authentication':
        model = buildAuthenticationModel(status, request);
        break;
      case 'view-tax-calculation':
        model = buildTaxCalculationModel(status, request, content);
        break;
      case 'view-simulations-list':
        model = buildSimulationsListModel(content);
        break;
      case 'view-errors':
      default:
        model = buildErrorsModel(content);
        break;
    }

    const templateFile = path.join(viewsDir, `${viewName}.ejs`);
    return ejs.renderFile(templateFile, { model, logo }, { views: [viewsDir, path.join(viewsDir, 'partials')] });
  }
}

Vamos comentar este código:

  • const viewName = Object.keys(views).find((view) => views[view].includes(status)) ?? errorsView; — a linha-chave de todo o mecanismo: procuramos na tabela config.views (veja acima) o nome da view cuja lista de status contém o status atual da resposta; se nenhuma corresponder — inclusive, como o README ressalta, um sucesso status sem view dedicada, como get-admindata/1000 — recorremos a errorsView (view-errors), o que segue exatamente a mesma lógica de HtmlResponse::send() no lado PHP;
  • const logo = buildLogoPath(request); — o caminho do logo é recalculado a cada requisição com base na URL solicitada (veja view-models.ts abaixo), para garantir que continue correto mesmo que a aplicação seja implantada em um subdiretório;
  • switch (viewName) { case 'view-authentication': model = buildAuthenticationModel(...); ... } — uma vez selecionada a view, é chamada a função de construção de template correspondente (detalhada abaixo); é esse modelo, e somente ele, que o template EJS exibirá;
  • return ejs.renderFile(templateFile, { model, logo }, { views: [viewsDir, path.join(viewsDir, 'partials')] }); — a chamada real ao EJS: ejs.renderFile(...) lê o arquivo .ejs correspondente, executa-o com as variáveis model e logo em seu contexto e retorna o HTML resultante como uma string — a opção views informa ao EJS os dois diretórios em que deve procurar um template incluído pelo nome (a pasta views e sua partials/ subpasta).

src/views/view-models.ts define uma função de construção de template por view — o equivalente em TypeScript da função getModelForThisView(...) presente em cada uma das views PHP originais (Views/view-*.php). Eis um trecho da mais simples das quatro, buildAuthenticationModel:

export function buildAuthenticationModel(
  status: number,
  request: Request,
): AuthenticationModel {
  const model: AuthenticationModel = { login: '', error: false, errors: [] };
  switch (status) {
    case 700:
    case 400:
      model.login = '';
      model.error = false;
      break;
    case 221:
      model.login = String(request.body?.user ?? '');
      model.error = true;
      model.errors = ["Authentication failed"];
      break;
  }
  return model;
}

e da mais complexa, buildTaxCalculationModel, que precisa tratar três casos distintos:

export function buildTaxCalculationModel(
  status: number,
  request: Request,
  content: Record<string, unknown>,
): TaxCalculationModel {
  const model: TaxCalculationModel = {
    success: false, error: false, checkedYes: false, checkedNo: false,
    children: '', salary: '', errors: [],
    optionsMenu: {
      'List of simulations': 'main.php?action=list-simulations',
      'End of session': 'main.php?action=end-session',
    },
  };
  switch (status) {
    case 200:
    case 800:
      model.success = false;
      model.error = false;
      model.checkedNo = true;
      model.checkedYes = false;
      model.children = '';
      model.salary = '';
      break;
    case 300: {
      const response = content.response as Record<string, unknown>;
      model.success = true;
      model.error = false;
      model.tax = `Tax amount: ${response.tax} euros`;
      model.discount = `Discount: ${response.discount} euros`;
      model.reduction = `Reduction: ${response.reduction} euros`;
      model.surcharge = `Surcharge: ${response.surcharge} euros`;
      model.rate = `Tax rate: ${(response.rate as number) * 100} %`;
      const married = request.body?.['married'];
      model.checkedYes = married === 'yes';
      model.checkedNo = married !== 'yes';
      model.children = String(request.body?.children ?? '');
      model.salary = String(request.body?.salary ?? '');
      break;
    }
    case 341:
    case 350: {
      const married = request.body?.['married'];
      model.checkedYes = married === 'yes';
      model.checkedNo = married !== 'yes';
      model.children = String(request.body?.children ?? '');
      model.salary = String(request.body?.salary ?? '');
      model.success = false;
      model.error = true;
      model.errors = [String(content.response)];
      break;
    }
  }
  return model;
}

Vamos comentar este código:

  • códigos de status 200 e 800 (formulário vazio, chegada à view ou retorno de display-tax-calculation) — todos os campos do modelo são zerados, como se o formulário nunca tivesse sido preenchido;
  • status 300 (cálculo bem-sucedido) — const response = content.response as Record<string, unknown>; recupera o resultado retornado por CalculateTaxController (imposto, desconto, redução, acréscimo, alíquota) e constrói as cinco frases exibidas no banner de sucesso; o formulário é preenchido novamente com os valores enviados (request.body), para que o usuário possa revisar o que digitou junto ao resultado;
  • status 341 e 350 (banco de dados — ou Redis — indisponível) — mesma reexibição do formulário enviado, mas com model.error = true e a mensagem de erro retornada pela [DAO] camada colocada em model.errors;
  • optionsMenu: { ... } — o menu lateral (parte de menu.ejs, veja abaixo) é independente do estado: está sempre presente, com as mesmas duas opções, qualquer que seja o resultado do cálculo.

As duas funções restantes seguem o mesmo princípio:

  • buildSimulationsListModel(content) — a mais curta das quatro: simulations: (content.response as SimulationRow[]) ?? [], complementada pelo mesmo menu lateral de buildTaxCalculationModel (desta vez com “Tax calculation” e “End of session”);
  • buildErrorsModel(content) — constrói a lista de mensagens exibidas pela view genérica "view-errors" ; trata um caso muito específico herdado do PHP original: else if (response !== null && typeof response === 'object') { errors = [JSON.stringify(response)]; }, no caso de um sucesso status sem view dedicada (como get-admindata/1000) ainda assim recair nessa view de erro — o PHP original exibiria então o objeto por meio de seu método __toString(); JSON.stringify é o equivalente em TypeScript.
  • buildLogoPath(request) — const root = pathname.replace(/\/[^/]*$/, ''); return ${root}/Resources/logo.jpg; : reconstrói o caminho do logo a partir do diretório da URL atual (sem o nome do script), para que o banner continue correto mesmo que a aplicação seja implantada em um subdiretório — portado diretamente de Views/v-banner.php.

Os quatro templates views/*.ejs são traduções diretas dos arquivos PHP originais (Views/view-*.php), com o mesmo layout Bootstrap 4.1.3. O trecho mais completo, view-tax-calculation.ejs:

<%# equivalent of Views/view-tax-calculation.php %>
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" ...>
    <title>Tax application</title>
  </head>
  <body>
    <div class="container">
      <%- include('partials/banner', { logo: logo }) %>
      <div class="row">
        <div class="col-md-3">
          <%- include('partials/menu', { model: model }) %>
        </div>
        <div class="col-md-9">
          <%- include('partials/tax-calculation-form', { model: model }) %>
        </div>
      </div>
      <% if (model.success) { %>
      <div class="row">
        <div class="col-md-9">
          <div class="alert alert-success" role="alert">
            <%= model.tax %><br>
            <%= model.discount %><br>
            ...
          </div>
        </div>
      </div>
      <% } %>
      <% if (model.error) { %>
        ... (same principle, alert-danger, loop over model.errors)
      <% } %>
    </div>
  </body>
</html>

Vamos comentar este template:

  • linha 1: <%# ... %> — um comentário EJS, nunca enviado ao navegador;
  • <%- include('partials/banner', { logo: logo }) %> — inclui um template parcial, com as variáveis que queremos passar explicitamente a ele (aqui, logo); nota: <%- %> exibe o resultado sem escapá-lo — usado aqui unicamente para inserir HTML já construído por include(...), nunca para dados digitados pelo usuário;
  • <% if (model.success) { %> ... <% } %> — bloco de controle EJS (<% %>, sem hífen): JavaScript executado durante a renderização, que por si só não produz saída; aqui, a seção de “resultado” só aparece no HTML final se model.success for verdadeiro;
  • <%= model.tax %> — exibição com escape (<%= %>, com o sinal de igual): é a forma usada para qualquer dado que possa conter entrada do usuário (resultados de cálculo, login reexibido, mensagens de erro) — o EJS escapa automaticamente os caracteres especiais, ao contrário de <?= ?> no PHP original, que não o fazia.

As outras três views e os cinco parciais (views/partials/) seguem os mesmos princípios:

  • view-authentication.ejs — o formulário de login; inclui partials/banner e partials/authentication-form, e então exibe a lista model.errors if model.error;
  • view-simulations-list.ejs — inclui partials/banner, partials/menu, e partials/simulations-list-table;
  • view-errors.ejs — a view de contingência: partials/banner, partials/menu, seguidos de um laço simples <% model.errors.forEach(function(error) { %><li><%= error %></li><% }) %>;
  • partials/banner.ejs — o logo e o “Calculate your tax” título, comuns a todas as views, exceto a view de autenticação, que também os inclui;
  • partials/menu.ejs — <% Object.keys(model.optionsMenu).forEach(function(text) { %><a href="<%= model.optionsMenu[text] %>"><%= text %></a><% }) %>: o menu lateral, inteiramente controlado pela optionsMenu tabela criada em view-models.ts— de modo que adicionar uma opção de menu exige apenas alterar o modelo, nunca este template;
  • partials/authentication-form.ejs — o formulário de login do Bootstrap, com value="<%= model.login %>" para reexibir o último login digitado em caso de falha;
  • partials/tax-calculation-form.ejs — o formulário de cálculo; observe <%- model.checkedYes ? 'checked="checked"' : '' %>: um uso deliberado e seguro de <%- %>, já que a string inserida (checked="checked" ou vazia) é definida no lado do servidor e nunca é construída a partir de entrada do usuário;
  • partials/simulations-list-table.ejs — a tabela de simulações, uma linha por item em model.simulations, com um link “Delete” para main.php?action=delete-simulation&number=... em cada linha.
Nota: Diferentemente do PHP original, que reinjetava certos valores sem escapá-los por meio de <?= ?> (uma vulnerabilidade de XSS refletido, explorável principalmente pelo formulário de autenticação), os templates EJS deste projeto usam sistematicamente <%= %> para todos os dados fornecidos pelo usuário (login, filhos, salário, mensagens de erro). As poucas ocorrências de <%- %> neste projeto servem apenas para incluir um parcial ou para inserir um atributo construído no lado do servidor a partir de um valor fixo — nunca entrada do usuário: esse comportamento é funcionalmente idêntico ao do servidor PHP, sem replicar sua vulnerabilidade.

9.13. Execução

Na raiz da pasta [nestjs-case-study]:

npm install
cp .env.example .env
npm run start:dev

O servidor passa então a escutar em http://localhost:3000. O modo JSON, usado pelo cliente TypeScript, é testado com:

http://localhost:3000/main.php?action=init-session&type=json

e o modo HTML, diretamente no navegador, com:

http://localhost:3000/main.php?action=init-session&type=html

Em ambos os casos, o mesmo parâmetro action determina o processamento realizado (neste caso, init-session, que deve ser a primeira ação chamada, pois inicializa a sessão), e o parâmetro type determina o formato da resposta — as outras ações são testadas da mesma forma, bastando alterar o valor de action (por exemplo, &action=calculate-tax, por POST, enviando os parâmetros “married”, “children” e “salary” ).

Abra um navegador e solicite a URL [http://localhost:3000/main.php?action=init-session&type=html]

Image

As credenciais de login são admin / admin. Envie o formulário.

Image

Preencha o formulário e envie-o:

Image

Execute várias simulações e depois solicite a [List of simulations]:

Image

Exclua as duas simulações:

Image

Encerre a sessão:

Image