Attivatori di Cloud Firestore

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

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

1. Attende le modifiche a un particolare documento.
2. Si attiva quando si verifica un evento ed esegue le sue attività (vedi Cosa posso fare con Cloud Functions? per esempi di casi d'uso).
3. Riceve un oggetto dati che contiene un'istantanea dei dati archiviati nel documento specificato. Per gli eventi onWrite o onUpdate , l'oggetto dati contiene due snapshot che rappresentano lo stato dei dati prima e dopo l'evento di attivazione.

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

Attivazioni della funzione Cloud Firestore

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

Se non hai ancora un progetto abilitato per Cloud Functions for Firebase, leggi Introduzione: Scrivi e distribuisci le tue prime funzioni per configurare e configurare il tuo progetto Cloud Functions for Firebase.

Scrittura di funzioni attivate da Cloud Firestore

Definire un trigger di funzione

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

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

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

I percorsi del documento possono fare riferimento a un documento specifico oa un modello di caratteri jolly .

Specificare un unico documento

Se desideri attivare un evento per qualsiasi modifica a un documento specifico, puoi utilizzare la seguente funzione.

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

Specificare un gruppo di documenti utilizzando i caratteri jolly

Se desideri 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 qualsiasi documento in users viene modificato, corrisponde a un carattere jolly chiamato userId .

Se un documento negli users ha sottoraccolte e un campo in uno dei documenti di tali sottoraccolte 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 desideri per sostituire la raccolta esplicita o gli ID documento, 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

È possibile attivare una funzione per l'attivazione 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

Attiva una funzione quando un documento viene aggiornato

Puoi anche attivare una funzione da attivare quando un documento viene aggiornato utilizzando la funzione onUpdate() con un carattere jolly . Questa funzione di esempio chiama updateUser se un utente cambia 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

Attiva una funzione quando un documento viene eliminato

Puoi anche attivare una funzione quando un documento viene eliminato utilizzando la funzione onDelete() con un carattere 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 non ti interessa il tipo di evento che viene attivato, puoi ascoltare tutte le modifiche in un documento Cloud Firestore utilizzando la funzione onWrite() con un carattere 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 una funzione viene attivata, fornisce un'istantanea dei dati relativi all'evento. Puoi utilizzare questo snapshot per leggere o scrivere nel documento che ha attivato l'evento oppure utilizzare Firebase Admin SDK per accedere ad altre parti del database.

Dati dell'evento

Lettura dei dati

Quando viene attivata una funzione, potresti voler ottenere i dati da un documento che è stato aggiornato o ottenere i dati prima dell'aggiornamento. È possibile ottenere i dati precedenti utilizzando change.before.data() , che contiene lo snapshot del documento prima dell'aggiornamento. Allo stesso modo, change.after.data() contiene lo stato dello snapshot del 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 in 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 di dati

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

Questo DocumentReference proviene dall'SDK di Cloud Firestore Node.js e include metodi come update() , set() e remove() in modo da poter 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 al di fuori dell'evento trigger

Le funzioni cloud vengono eseguite in un ambiente affidabile, il che significa che sono autorizzate come account di servizio sul tuo progetto. Puoi eseguire letture e scritture utilizzando Firebase Admin SDK :

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

Nota le seguenti limitazioni per i trigger di Cloud Firestore per Cloud Functions:

• L'ordine non è garantito. Modifiche rapide possono attivare chiamate di funzione in un ordine imprevisto.
• Gli eventi vengono consegnati almeno una volta, ma un singolo evento può comportare più chiamate di funzione. Evita di dipendere da meccaniche esattamente una tantum e scrivi funzioni idempotenti .
• I trigger di Cloud Firestore per Cloud Functions sono disponibili solo per Cloud Firestore in modalità nativa . Non è disponibile per Cloud Firestore in modalità Datastore.