6. Ámbitos de los datos
Una aplicación web atiende a muchos usuarios a la vez, y cada usuario realiza numerosas solicitudes. Por lo tanto, los datos pueden compartirse en tres niveles, conocidos como su ámbito (scope):
- ámbito de aplicación: los datos son compartidos por todos los usuarios durante toda la vida del servidor (por ejemplo, la lista de médicos);
- ámbito de solicitud: los datos existen solo mientras dura una solicitud (el modelo de una vista);
- ámbito de cliente: los datos son específicos de un usuario y deben persistir de una solicitud a la siguiente (el idioma seleccionado, el usuario conectado).
El curso original utilizaba la [ASP.NET] sesión para este último ámbito: un espacio de almacenamiento del lado del servidor propio de cada navegador. Este documento, al igual que el caso de estudio, prescinde de ella: los datos del ámbito de cliente se almacenan en el navegador mediante cookies. El servidor no guarda nada entre dos solicitudes de un mismo usuario: se dice que no tiene estado ([stateless]). Esto es lo que permite, por ejemplo, ejecutar varios servidores idénticos detrás de un balanceador de carga. La contrapartida: una cookie está bajo el control del usuario, que puede leerla y modificarla. El capítulo 8 mostrará cómo un token firmado permite confiar en la cookie a pesar de ello.
6.1. Ejemplo 23: tres ámbitos
El archivo [src/counter.service.ts]:
| import { Injectable } from '@nestjs/common';
// ámbito de APLICACIÓN (el predeterminado): una sola instancia, creada al inicio y
// compartida por TODAS las solicitudes de TODOS los usuarios
@Injectable()
export class CounterService {
private total = 0;
increment(): number {
return ++this.total;
}
}
|
Líneas 5–6: por defecto, un servicio de [NestJS] es un singleton: una única instancia, creada al iniciar, compartida por todas las solicitudes. Por lo tanto, su campo [total] tiene ámbito de aplicación.
El archivo [src/request.service.ts]:
| import { Injectable, Scope } from '@nestjs/common';
let createdInstances = 0;
// ámbito de SOLICITUD: una instancia NUEVA por cada solicitud HTTP
@Injectable({ scope: Scope.REQUEST })
export class RequestService {
readonly number = ++createdInstances;
}
|
Línea 6: la opción [scope: Scope.REQUEST] solicita una nueva instancia por cada solicitud. El número de instancia lo indica. Esta opción se usa poco: tiene un costo (creación de objetos en cada solicitud) y se propaga: un controlador que depende de un servicio de ámbito de solicitud pasa a tener él mismo ese ámbito. [res.locals] suele ser suficiente.
El archivo [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 {
// ámbito de CLIENTE: un dato conservado por el NAVEGADOR (cookie),
// devuelto al servidor con cada solicitud
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,
});
}
}
|
- líneas 8–11: se inyectan ambos servicios;
- líneas 17–18: el ámbito de cliente: un contador almacenado en una cookie. El navegador la devuelve con cada solicitud; la acción lo incrementa y lo vuelve a guardar;
- líneas 19–23: los tres valores se pasan a la vista.
El archivo [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());
// ámbito de SOLICITUD: res.locals nace y muere con la solicitud
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();
|
líneas 15–18: el ámbito de solicitud con [res.locals]: la hora en que se recibió la solicitud.
El archivo [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>
|

Simulemos dos navegadores con [curl] y dos archivos de cookies, [a.txt] y [b.txt]. El navegador A hace dos solicitudes, luego el navegador B hace una y, por último, A hace una más:
| 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
|
- El contador de aplicación cuenta todas las visitas: 1, 2, 3, 4;
- cada solicitud tiene su propia instancia de [RequestService]: 1, 2, 3, 4;
- El contador de cliente es específico de cada navegador: A tiene 3 visitas, B tiene 1.
En el caso de estudio:
Ámbito | Datos | ¿Dónde? |
Aplicación | Listas de médicos y clientes, diccionarios, CAPTCHA pendientes | Servicios singleton ([ApplicationModelService], [CaptchaService]...) |
Solicitud | idioma, ruta, mensaje flash, usuario conectado | [res.locals] |
Cliente | token de autenticación, idioma, mensaje flash | cookies |