Skip to content

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

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

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

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:

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
  • 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