Vai al contenuto
← Tutti gli articoli

Pubblicato il 6 min di lettura

Doppie prenotazioni: lock transazionale e test di concorrenza

Come evitare due prenotazioni sullo stesso slot: perché SELECT seguito da INSERT non basta, il lock pg_advisory_xact_lock in Prisma e i test con Testcontainers.

Progetto collegato: App di prenotazione per saloni

Due clienti aprono l'app dello stesso salone e tappano lo stesso slot delle 10:00 nello stesso istante. Entrambe le app mostrano lo slot libero, entrambe inviano la richiesta. Se il server controlla che lo slot sia libero e poi lo scrive, le due richieste passano il controllo insieme e il salone si ritrova con due appuntamenti sullo stesso orario con lo stesso collaboratore. Sto sviluppando un'app di prenotazione per saloni, con un'API NestJS multi-tenant e un client Expo, e questo è uno dei problemi che ho dovuto risolvere con più cura.

Perché SELECT seguito da INSERT non basta

Il codice ingenuo è questo: cerco un appuntamento in conflitto; se non lo trovo, creo quello nuovo. Sembra corretto, ma PostgreSQL usa di default il livello di isolamento READ COMMITTED. La transazione A legge «nessun conflitto», la transazione B legge «nessun conflitto» prima che A faccia commit, e le due inseriscono. Il controllo e la scrittura sono due istruzioni separate, e nulla le lega.

Si potrebbe usare SERIALIZABLE con retry. Ho preferito un lock esplicito sul collaboratore, perché il punto da proteggere è un solo collaboratore in un solo intervallo, e il lock si ragiona con meno sorprese di un retry generalizzato.

Il lock sul collaboratore, dentro la transazione

Il lock è un advisory lock a livello di transazione: pg_advisory_xact_lock viene rilasciato al commit o al rollback. La chiave è l'hash dell'ID del collaboratore. Il codice, semplificato, è questo:

return await this.prisma.$transaction(async (tx) => {
  let chosen: string | null = null;
  for (const staffId of eligible) {
    await tx.$executeRaw`SELECT pg_advisory_xact_lock(hashtext(${staffId}))`;
    const conflict = await tx.appointment.findFirst({
      where: { salonId, staffId, status: 'CONFIRMED', start: { lt: end }, end: { gt: start } },
      select: { id: true },
    });
    if (!conflict) { chosen = staffId; break; }
  }
  if (!chosen) {
    throw new ConflictException({ code: 'SLOT_TAKEN', message: 'Questo orario è stato appena preso.' });
  }
  return tx.appointment.create({ data: { salonId, staffId: chosen, start, end /* ... */ } });
});

Il punto sottile è l'ordine. Il lock va preso prima del controllo e nella stessa transazione. La seconda richiesta resta ferma sul lock finché la prima non ha fatto commit. Poi esegue il suo SELECT, che è una nuova istruzione: in READ COMMITTED vede i dati già confermati e trova il conflitto. Se il lock fosse preso dopo il SELECT, la seconda richiesta vedrebbe lo stesso «nessun conflitto» di prima.

Dove viene preso il lock

Il lock compare in tre percorsi: la prenotazione del cliente, la creazione di un appuntamento dal calendario dell'admin, e lo spostamento di un appuntamento esistente. Non serve nelle disdette, che liberano uno slot. Le transizioni di stato non possono riconfermare un appuntamento annullato: il codice rifiuta CONFIRMED come stato di arrivo. Nel database non c'è un vincolo di esclusione sugli intervalli: ho controllato le migrazioni, e non ne trovo. Quindi la garanzia sta nel codice, e ogni nuovo percorso che scrive appuntamenti deve prendere lo stesso lock. È la regola che mi interessa di più far rispettare.

Quando il cliente non sceglie un collaboratore (ANY), il sistema prova in sequenza i collaboratori idonei e prende il primo libero, bloccandoli uno alla volta. Qui c'è una cosa che rivedrei, e la dico nell'ultima sezione.

Richieste ripetute: l'idempotenza

Un doppio tap o un retry di rete non deve creare due prenotazioni. L'app genera una Idempotency-Key per ogni tentativo e la riusa in tutti i retry. Il backend ha un indice unico su (salonId, idempotencyKey), e se la chiave esiste già restituisce l'appuntamento esistente. Il caso più sottile è la corsa: due richieste con la stessa chiave arrivano insieme, la seconda aspetta il lock e trova lo slot occupato dalla prima, e nel catch cerca la chiave: se trova l'appuntamento della vincitrice, restituisce quello invece di un errore. Lo stesso vale se la perdente incontra l'errore P2002 dell'indice unico. Dal lato del client, il test che copre questo caso verifica che i retry riusino la stessa chiave e che un SLOT_TAKEN riporti l'utente alla scelta dell'orario.

Test di concorrenza con un Postgres vero

I test di integrazione avviano un container PostgreSQL 18 con Testcontainers e applicano le migrazioni con prisma migrate deploy, quindi il test gira sullo stesso schema di produzione. Un caso manda due richieste in parallelo sullo stesso slot:

const results = await Promise.all(
  Array.from({ length: 8 }, (_, i) =>
    http().post('/v1/appointments').set(bearer(tokens[i % 2])).send({
      serviceIds: [seed.serviceTaglio], staffId: seed.staffA, start,
    }),
  ),
);
expect(results.filter((r) => r.status === 201)).toHaveLength(1);
expect(results.filter((r) => r.status === 409 && r.body.code === 'SLOT_TAKEN')).toHaveLength(7);

Dopo le risposte il test conta le righe confermate su quello slot nel database: devono essere una. Un test parallelo non dimostra l'assenza di race condition: prova solo quell'interleaving. Il suo valore è di regressione: se qualcuno toglie il lock, il test fallisce, perché le richieste si sovrappongono davvero.

Il client tipizzato dalla specifica

L'app mobile non scrive i tipi a mano. Il backend espone la sua specifica OpenAPI tramite SwaggerModule, e il client usa openapi-typescript per generare schema.d.ts, con un piccolo helper che collega path, metodo, body e risposta. Un path rinominato sul server diventa un errore di compilazione nell'app. Ci sono però limiti che non nascondo. Un DTO senza @ApiProperty finisce come Record<string, unknown>, e una risposta senza schema diventa unknown. Nel wrapper della prenotazione il body è castato a never, quindi il controllo sul payload è spento proprio nel punto più delicato. Il tipo copre il percorso e il metodo, non ancora ogni campo.

Cosa farei diversamente

Primo: ordinerei gli ID dei collaboratori prima di bloccarli. L'elenco dei candidati nasce da una findMany senza orderBy, quindi l'ordine non è garantito. Due transazioni che bloccano gli stessi collaboratori in ordine diverso possono andare in deadlock: Postgres ne annulla una, e il cliente non riceve un 409 corretto. Non ho un test che lo riproduca, ma l'ordine deterministico costa una riga.

Secondo: aggiungerei un vincolo di esclusione in Postgres, con l'estensione btree_gist, sugli appuntamenti confermati. È una difesa di profondità: anche un percorso futuro che dimentica il lock non potrebbe sovrapporre due appuntamenti.

Terzo: eliminerei il cast a never nel body della creazione, aggiungendo @ApiProperty ai DTO che oggi degradano. Il client diventerebbe davvero tipizzato anche sul payload.

Il progetto è in sviluppo e non ha ancora una versione pubblica da provare.

  • PostgreSQL
  • concorrenza
  • Prisma
  • NestJS
  • Testcontainers

Hai un progetto simile? Parliamone

Se stai affrontando una sfida simile, scrivimi: ti dico come la affronterei.

Parliamone