6. Escopos de dados
Uma aplicação web atende muitos usuários ao mesmo tempo, e cada usuário faz numerosas requisições. Os dados podem, portanto, ser compartilhados em três níveis, conhecidos como seu escopo:
- aplicação: os dados são compartilhados por todos os usuários durante toda a vida do servidor (a lista de médicos, por exemplo);
- requisição: os dados existem apenas durante uma requisição (o modelo de uma view);
- cliente: os dados são específicos de um usuário e devem persistir de uma requisição para a seguinte (o idioma selecionado, o usuário logado).
O curso original usava a [ASP.NET] sessão para este último escopo: um espaço de armazenamento no servidor, exclusivo de cada navegador. Este documento, assim como o estudo de caso, dispensa a sessão: os dados do escopo de cliente são guardados pelo navegador em cookies. O servidor não guarda nada entre duas requisições de um mesmo usuário: diz-se que ele é stateless ([stateless], sem estado). Isso é o que permite, por exemplo, executar vários servidores idênticos atrás de um balanceador de carga. A contrapartida: um cookie está sob o controle do usuário, que pode lê-lo e modificá-lo. O Capítulo 8 mostrará como um token assinado permite confiar no cookie apesar disso.
6.1. Exemplo 23: três escopos
O arquivo [src/counter.service.ts]:
| import { Injectable } from '@nestjs/common';
// escopo de APLICAÇÃO (o padrão): uma única instância, criada na inicialização e
// compartilhada por TODAS as requisições de TODOS os usuários
@Injectable()
export class CounterService {
private total = 0;
increment(): number {
return ++this.total;
}
}
|
Linhas 5–6: por padrão, um serviço [NestJS] é um singleton: uma única instância, criada na inicialização e compartilhada por todas as requisições. Seu campo [total] tem, portanto, escopo de aplicação.
O arquivo [src/request.service.ts]:
| import { Injectable, Scope } from '@nestjs/common';
let createdInstances = 0;
// escopo de REQUISIÇÃO: uma NOVA instância a cada requisição HTTP
@Injectable({ scope: Scope.REQUEST })
export class RequestService {
readonly number = ++createdInstances;
}
|
Linha 6: a opção [scope: Scope.REQUEST] solicita uma nova instância para cada requisição. O número da instância indica isso. Essa opção raramente é usada: ela tem um custo (criação de objetos a cada requisição) e se propaga: um controller que depende de um serviço com escopo de requisição passa a ter ele mesmo escopo de requisição. [res.locals] geralmente é suficiente.
O arquivo [src/scopes.controller.ts]:
| import { Controller, Get, Req, Res } from '@nestjs/common';
import { Request, Response } from 'express';
import { CounterService } from './counter.service';
import { RequestService } from './request.service';
@Controller()
export class ScopesController {
constructor(
private readonly counter: CounterService,
private readonly request: RequestService,
) {}
@Get()
scopes(@Req() req: Request, @Res() res: Response): void {
// escopo de CLIENTE: um dado mantido pelo NAVEGADOR (cookie),
// reenviado ao servidor a cada requisição
const myVisits = Number(req.cookies?.myVisits ?? 0) + 1;
res.cookie('myVisits', String(myVisits), { httpOnly: true, sameSite: 'lax' });
res.render('scopes', {
total: this.counter.increment(),
instance: this.request.number,
myVisits,
});
}
}
|
- linhas 8–11: os dois serviços são injetados;
- linhas 17–18: o escopo de cliente: um contador guardado em um cookie. O navegador o reenvia a cada requisição; a action o incrementa e o guarda de volta;
- linhas 19–23: os três valores são passados para a view.
O arquivo [src/main.ts]:
| import { NestFactory } from '@nestjs/core';
import { NestExpressApplication } from '@nestjs/platform-express';
import * as cookieParser from 'cookie-parser';
import { NextFunction, Request, Response } from 'express';
import { dirname, join } from 'path';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create<NestExpressApplication>(AppModule);
app.useStaticAssets(join(dirname(require.resolve('bootstrap/package.json')), 'dist'), { prefix: '/bootstrap/' });
app.setBaseViewsDir(join(__dirname, '..', 'views'));
app.setViewEngine('hbs');
app.use(cookieParser());
// escopo de REQUISIÇÃO: res.locals nasce e morre com a requisição
app.use((req: Request, res: Response, next: NextFunction) => {
res.locals.start = new Date().toISOString().slice(11, 23);
next();
});
await app.listen(3000);
console.log('Server started on http://localhost:3000');
}
bootstrap();
|
linhas 15–18: o escopo de requisição com [res.locals]: o momento em que a requisição foi recebida.
O arquivo [views/scopes.hbs]:
| <h1 class="h3">The scopes of data</h1>
<ul>
<li>application: {{total}} visit(s) of the site, all browsers combined</li>
<li>request: instance no. {{instance}} of RequestService, request received at {{start}}</li>
<li>client: {{myVisits}} visit(s) from this browser</li>
</ul>
|

Vamos simular dois navegadores com [curl] e dois arquivos de cookies, [a.txt] e [b.txt]. O navegador A faz duas requisições, depois o navegador B faz uma e, por fim, A faz mais uma:
| curl -c a.txt -b a.txt http://localhost:3000/
curl -c a.txt -b a.txt http://localhost:3000/
curl -c b.txt -b b.txt http://localhost:3000/
curl -c a.txt -b a.txt http://localhost:3000/
|
| browser A:
application: 1 visit(s) of the site, all browsers combined
request: instance no. 1 of RequestService, request received at 14:16:07.195
client: 1 visit(s) from this browser
browser A:
application: 2 visit(s) of the site, all browsers combined
request: instance no. 2 of RequestService, request received at 14:16:07.237
client: 2 visit(s) from this browser
browser B:
application: 3 visit(s) of the site, all browsers combined
request: instance no. 3 of RequestService, request received at 14:16:07.251
client: 1 visit(s) from this browser
browser A:
application: 4 visit(s) of the site, all browsers combined
request: instance no. 4 of RequestService, request received at 14:16:07.263
client: 3 visit(s) from this browser
|
- O contador de aplicação conta todas as visitas: 1, 2, 3, 4;
- cada requisição tem sua própria instância de [RequestService]: 1, 2, 3, 4;
- O contador de cliente é específico de cada navegador: A tem 3 visitas, B tem 1.
No estudo de caso:
Escopo | Dados | Onde? |
Aplicação | Listas de médicos e clientes, dicionários, CAPTCHAs pendentes | Serviços singleton ([ApplicationModelService], [CaptchaService]...) |
Requisição | idioma, caminho, mensagem flash, usuário logado | [res.locals] |
cliente | token de autenticação, idioma, mensagem flash | cookies |