Trigger di Cloud Firestore

Con Cloud Functions puoi gestire eventi in Cloud Firestore senza dover aggiornare il codice client. Puoi apportare modifiche a Cloud Firestore tramite l'interfaccia dello snapshot del documento o tramite SDK Admin.

In un tipico ciclo di vita, una funzione di Cloud Firestore svolge le seguenti operazioni:

1. Attende le modifiche a un documento specifico.
2. Si attiva quando si verifica un evento e ne esegue le attività.
3. Riceve un oggetto dati che contiene uno snapshot dei dati archiviati nel documento specificato. Per gli eventi di scrittura o aggiornamento, l'oggetto dati contiene due snapshot che rappresentano lo stato dei dati prima e dopo l'evento di attivazione.

La distanza tra la località dell'istanza Firestore e quella della funzione può creare una latenza di rete significativa. Per ottimizzare le prestazioni, valuta la possibilità di specificare la località della funzione, ove applicabile.

Trigger delle funzioni di Cloud Firestore

L'SDK di Cloud Functions for Firebase esporta un oggetto functions.firestore che consente di creare gestori collegati a specifici eventi Cloud Firestore.

Se ancora non hai un progetto abilitato per Cloud Functions for Firebase, leggi l'articolo Inizia: scrivere ed eseguire il deployment delle tue prime funzioni per configurare e impostare il tuo progetto Cloud Functions for Firebase.

Scrittura delle funzioni attivate da Cloud Firestore

Definisci un attivatore di funzione

Per definire un trigger di Cloud Firestore, specifica un percorso documento e un tipo di evento:

const functions = require('firebase-functions');

exports.myFunction = functions.firestore
  .document('my-collection/{docId}')
  .onWrite((change, context) => { /* ... */ });

I percorsi dei documenti possono fare riferimento a un documento specifico o a un pattern con caratteri jolly.

Specifica un singolo documento

Se vuoi attivare un evento per qualsiasi modifica a un documento specifico, puoi utilizzare la funzione riportata di seguito.

// Listen for any change on document `marie` in collection `users`
exports.myFunctionName = functions.firestore
    .document('users/marie').onWrite((change, context) => {
      // ... Your code here
    });
index.js

Specifica un gruppo di documenti utilizzando caratteri jolly

Se vuoi allegare un attivatore a un gruppo di documenti, ad esempio qualsiasi documento di una determinata raccolta, utilizza un {wildcard} al posto dell'ID documento:

// Listen for changes in all documents in the 'users' collection
exports.useWildcard = functions.firestore
    .document('users/{userId}')
    .onWrite((change, context) => {
      // If we set `/users/marie` to {name: "Marie"} then
      // context.params.userId == "marie"
      // ... and ...
      // change.after.data() == {name: "Marie"}
    });
index.js

In questo esempio, quando un campo di un documento in users viene modificato, corrisponde a un carattere jolly chiamato userId.

Se un documento in users contiene sottoraccolte e un campo in una di queste raccolte secondarie viene modificato, il carattere jolly userId non viene attivato.

Le corrispondenze con caratteri jolly vengono estratte dal percorso del documento e archiviate in context.params. Puoi definire tutti i caratteri jolly che vuoi per sostituire gli ID raccolta o documento espliciti, ad esempio:

// Listen for changes in all documents in the 'users' collection and all subcollections
exports.useMultipleWildcards = functions.firestore
    .document('users/{userId}/{messageCollectionId}/{messageId}')
    .onWrite((change, context) => {
      // If we set `/users/marie/incoming_messages/134` to {body: "Hello"} then
      // context.params.userId == "marie";
      // context.params.messageCollectionId == "incoming_messages";
      // context.params.messageId == "134";
      // ... and ...
      // change.after.data() == {body: "Hello"}
    });
index.js

Trigger di eventi

Attiva una funzione quando viene creato un nuovo documento

Puoi attivare una funzione ogni volta che viene creato un nuovo documento in una raccolta utilizzando un gestore onCreate() con un carattere jolly. Questa funzione di esempio chiama createUser ogni volta che viene aggiunto un nuovo profilo utente:

exports.createUser = functions.firestore
    .document('users/{userId}')
    .onCreate((snap, context) => {
      // Get an object representing the document
      // e.g. {'name': 'Marie', 'age': 66}
      const newValue = snap.data();

      // access a particular field as you would any JS property
      const name = newValue.name;

      // perform desired operations ...
    });
index.js

Attivare una funzione quando un documento viene aggiornato

Puoi anche attivare una funzione quando un documento viene aggiornato utilizzando la funzione onUpdate() con un caratteri jolly. Questa funzione di esempio chiama updateUser se un utente modifica il proprio profilo:

exports.updateUser = functions.firestore
    .document('users/{userId}')
    .onUpdate((change, context) => {
      // Get an object representing the document
      // e.g. {'name': 'Marie', 'age': 66}
      const newValue = change.after.data();

      // ...or the previous value before this update
      const previousValue = change.before.data();

      // access a particular field as you would any JS property
      const name = newValue.name;

      // perform desired operations ...
    });
index.js

Attivare una funzione quando viene eliminato un documento

Puoi attivare una funzione anche quando un documento viene eliminato utilizzando la funzione onDelete() con un caratteri jolly. Questa funzione di esempio chiama deleteUser quando un utente elimina il proprio profilo utente:

exports.deleteUser = functions.firestore
    .document('users/{userID}')
    .onDelete((snap, context) => {
      // Get an object representing the document prior to deletion
      // e.g. {'name': 'Marie', 'age': 66}
      const deletedValue = snap.data();

      // perform desired operations ...
    });
index.js

Attiva una funzione per tutte le modifiche a un documento

Se il tipo di evento attivato non è interessato, puoi ascoltare tutte le modifiche apportate a un documento Cloud Firestore utilizzando la funzione onWrite() con un caratteri jolly. Questa funzione di esempio chiama modifyUser se un utente viene creato, aggiornato o eliminato:

exports.modifyUser = functions.firestore
    .document('users/{userID}')
    .onWrite((change, context) => {
      // Get an object with the current document value.
      // If the document does not exist, it has been deleted.
      const document = change.after.exists ? change.after.data() : null;

      // Get an object with the previous document value (for update or delete)
      const oldDocument = change.before.data();

      // perform desired operations ...
    });
index.js

Lettura e scrittura di dati

Quando viene attivata, una funzione fornisce uno snapshot dei dati relativi all'evento. Puoi utilizzare questo snapshot per leggere o scrivere sul documento che ha attivato l'evento oppure utilizzare l'SDK Firebase Admin per accedere ad altre parti del database.

Dati evento

Lettura dei dati

Quando viene attivata una funzione, è possibile che tu voglia recuperare i dati da un documento che è stato aggiornato o ottenere i dati prima dell'aggiornamento. Puoi ottenere i dati precedenti utilizzando change.before.data(), che contiene l'istantanea del documento prima dell'aggiornamento. Analogamente, change.after.data() contiene lo stato dell'istantanea documento dopo l'aggiornamento.

exports.updateUser2 = functions.firestore
    .document('users/{userId}')
    .onUpdate((change, context) => {
      // Get an object representing the current document
      const newValue = change.after.data();

      // ...or the previous value before this update
      const previousValue = change.before.data();
    });
index.js

Puoi accedere alle proprietà come faresti con qualsiasi altro oggetto. In alternativa, puoi utilizzare la funzione get per accedere a campi specifici:

// Fetch data using standard accessors
const age = snap.data().age;
const name = snap.data()['name'];

// Fetch data using built in accessor
const experience = snap.get('experience');
index.js

Scrittura dati

Ogni chiamata di funzione è associata a un documento specifico nel tuo database Cloud Firestore. Puoi accedere al documento come DocumentReference nella proprietà ref dello snapshot restituito alla funzione.

Questo DocumentReference proviene dall' SDK Node.js di Cloud Firestore e include metodi come update(), set() e remove() per consentirti di modificare facilmente il documento che ha attivato la funzione.

// Listen for updates to any `user` document.
exports.countNameChanges = functions.firestore
    .document('users/{userId}')
    .onUpdate((change, context) => {
      // Retrieve the current and previous value
      const data = change.after.data();
      const previousData = change.before.data();

      // We'll only update if the name has changed.
      // This is crucial to prevent infinite loops.
      if (data.name == previousData.name) {
        return null;
      }

      // Retrieve the current count of name changes
      let count = data.name_change_count;
      if (!count) {
        count = 0;
      }

      // Then return a promise of a set operation to update the count
      return change.after.ref.set({
        name_change_count: count + 1
      }, {merge: true});
    });
index.js

Dati esterni all'evento di trigger

Le funzioni Cloud Functions vengono eseguite in un ambiente affidabile, il che significa che sono autorizzate come account di servizio nel progetto. Puoi eseguire letture e scritture utilizzando l'SDK Firebase Admin:

const admin = require('firebase-admin');
admin.initializeApp();

const db = admin.firestore();

exports.writeToFirestore = functions.firestore
  .document('some/doc')
  .onWrite((change, context) => {
    db.doc('some/otherdoc').set({ ... });
  });

Limitazioni

Tieni presente le seguenti limitazioni per i trigger di Cloud Firestore per Cloud Functions:

• L'ordine non è garantito. Le modifiche rapide possono attivare chiamate di funzioni in modo imprevisto.
• Gli eventi vengono recapitati almeno una volta, ma un singolo evento potrebbe comportare più chiamate di funzioni. Evita di dipendere dalla meccanica "exactly-once" e scrivi funzioni idempotenti.
• Cloud Firestore in modalità Datastore richiede Cloud Functions (2a generazione). Cloud Functions (1a gen.) non supporta la modalità Datastore.
• Cloud Functions (1a gen.) funziona solo con il database "(default)" e non supporta i database denominati Cloud Firestore. Utilizza Cloud Functions (2a generazione) per configurare gli eventi per i database denominati.
• Un trigger è associato a un singolo database. Non puoi creare un trigger corrispondente a più database.
• L'eliminazione di un database non elimina automaticamente i trigger per quel database. L'attivatore smette di pubblicare eventi, ma continua a esistere finché non lo elimini.
• Se un evento con corrispondenza supera la dimensione massima della richiesta, l'evento potrebbe non essere consegnato a Cloud Functions (1a generazione).
  • Gli eventi non recapitati a causa delle dimensioni della richiesta vengono registrati nei log della piattaforma e vengono conteggiati ai fini dell'utilizzo dei log per il progetto.
  • Puoi trovare questi log in Esplora log con il messaggio "L'evento non può essere recapitato alla funzione Cloud Functions a causa del superamento del limite per la 1a generazione..." con gravità error. Puoi trovare il nome della funzione sotto il campo functionName. Se il campo receiveTimestamp è ancora entro un'ora da adesso, puoi dedurre i contenuti effettivi dell'evento leggendo il documento in questione con un'istantanea prima e dopo il timestamp.
  • Per evitare questo ritmo, puoi:
    • Migrazione a Cloud Functions (2a generazione) ed upgrade
    • Ridimensiona il documento
    • Elimina la funzione Cloud Functions in questione
  • Puoi disattivare il logging stesso utilizzando le esclusioni, ma tieni presente che gli eventi offensivi non verranno comunque recapitati.