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

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.
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):
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:
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:
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
returnnã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.
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:
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 projetoActionResult(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:
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:
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:
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.sessionaponta para uma nova instância de sessão; a antiga session referência, capturada nos parâmetros deexecute()antes da chamada, agora está órfã — e é por isso que o tipo é reatribuído arequest.sessionem vez de asession; 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:
Trecho de src/model/server-dao.service.ts, a única implementação desse contrato neste projeto:
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:
- 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:
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:
Trecho de tax-admin-data.entity.ts— as faixas do imposto e as constantes de cálculo lidas pela [DAO] camada:
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):
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):
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:
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:
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
contentem 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.
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:
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
modelelogoem seu contexto e retorna o HTML resultante como uma string — a opçãoviewsinforma ao EJS os dois diretórios em que deve procurar um template incluído pelo nome (a pasta views e suapartials/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:
e da mais complexa, buildTaxCalculationModel, que precisa tratar três casos distintos:
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:
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.
9.13. Execução
Na raiz da pasta [nestjs-case-study]:
O servidor passa então a escutar em http://localhost:3000. O modo JSON, usado pelo cliente TypeScript, é testado com:
e o modo HTML, diretamente no navegador, com:
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]

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

Preencha o formulário e envie-o:

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

Exclua as duas simulações:

Encerre a sessão:
