Skip to content

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]:

1
2
3
4
5
6
7
8
9
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]:

1
2
3
4
5
6
<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>

Image

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:

1
2
3
4
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