Trigger di Cloud Firestore

2a generazione 1a gen.

Con Cloud Functions, puoi gestire eventi in Cloud Firestore senza la necessità di aggiornare il codice client. Puoi apportare modifiche a Cloud Firestore tramite dell'istantanea documento o tramite SDK Admin.

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

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

Distanza tra la località dell'istanza Firestore e la località della funzione può creare una latenza di rete significativa. Per ottimizzare il rendimento, valuta la possibilità di specificare la funzione di località applicabile.

Trigger delle funzioni Cloud Firestore

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

Tipo di evento	Trigger
onCreate	Si attiva quando viene scritto per la prima volta in un documento.
onUpdate	Si attiva quando un documento esiste già e presenta un valore modificato.
onDelete	Si attiva quando un documento con dati viene eliminato.
onWrite	Si attiva quando vengono attivati onCreate, onUpdate o onDelete.

Nota: gli eventi Cloud Firestore vengono attivati solo in seguito alle modifiche ai documenti. Un aggiornamento a un documento Cloud Firestore, in cui i dati non viene modificato (una scrittura autonoma), non genererà un evento di aggiornamento o scrittura. Non è possibile aggiungere eventi a campi specifici.

Se non hai ancora abilitato un progetto per Cloud Functions for Firebase, leggi Per iniziare: scrivi ed esegui il deployment delle tue prime funzioni per configurare e impostare il progetto Cloud Functions for Firebase.

Scrittura di funzioni attivate da Cloud Firestore

Definisci un trigger di funzione

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

Node.js

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 un pattern con caratteri jolly.

Importante: i percorsi dei documenti non devono contenere barre finali.

Specifica un singolo documento

Se vuoi attivare un evento per qualsiasi modifica a un documento specifico, puoi usare la funzione che segue.

Node.js

// 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 vuoi associare un attivatore a un gruppo di documenti, ad esempio un documento di una determinata raccolta, utilizza un {wildcard} al posto dell'ID documento:

Node.js

// 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 viene modificato qualsiasi campo di qualsiasi documento in users, viene restituito un carattere jolly denominato userId.

Se un documento in users ha sottocollezioni e un campo in uno dei documenti di queste sottocollezioni viene modificato, il carattere jolly userId non viene attivato.

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

Node.js

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

Nota: l'attivatore deve sempre puntare a un documento, anche se utilizzi un carattere jolly. Ad esempio, users/{userId}/{messageCollectionId} non è valido perché {messageCollectionId} è una raccolta. Tuttavia, users/{userId}/{messageCollectionId}/{messageId} è valida perché {messageId} rimanderà sempre a un documento.

Trigger di eventi

Attiva una funzione quando viene creato un nuovo documento

Puoi attivare una funzione in modo che si attivi 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:

Node.js

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 quando un documento viene aggiornato utilizzando il metodo Funzione onUpdate() con un carattere jolly. Questa funzione di esempio chiama updateUser se un utente cambia il proprio profilo:

Node.js

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 anche attivare una funzione quando un documento viene eliminato utilizzando il metodo Funzione onDelete() con un carattere jolly. Questo esempio La funzione chiama deleteUser quando un utente elimina il proprio profilo utente:

Node.js

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

Node.js

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 dei dati

Quando viene attivata, una funzione fornisce un'istantanea dei dati relativi all'evento. Puoi utilizzare questa istantanea per leggere o scrivere nel documento hanno attivato l'evento o utilizzare l'SDK Admin Firebase per accedere ad altre parti del tuo database.

Dati evento

Lettura dei dati

Quando viene attivata una funzione, potrebbe essere utile ottenere dati da un documento o recuperare i dati prima di eseguire l'aggiornamento. Puoi ottenere i dati precedenti utilizzando change.before.data(), che contiene l'istantanea documento prima dell'aggiornamento. Analogamente, change.after.data() contiene lo stato dell'istantanea documento dopo il parametro aggiornamento.

Node.js

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 per qualsiasi altro oggetto. In alternativa, puoi usare la funzione get per accedere a campi specifici:

Node.js

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

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

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

Node.js

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

Nota: ogni volta che scrivi nello stesso documento che ha attivato una funzione, rischiano di creare un ciclo infinito. Fai attenzione e assicurati di uscire in sicurezza dalla funzione quando non è necessaria alcuna modifica.

Dati esterni all'evento di trigger

I Cloud Functions vengono eseguiti in un ambiente attendibile, il che significa che vengono autorizzato come account di servizio nel tuo progetto. Puoi eseguire operazioni di lettura e scrittura Con l'SDK Admin Firebase:

Node.js

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({ ... });
  });

Nota: le letture e le scritture eseguite in Cloud Functions non sono controllate dalle tue regole di sicurezza, possono accedere a qualsiasi parte del tuo database.

Limitazioni

Tieni presente le seguenti limitazioni per gli attivatori Cloud Firestore per Cloud Functions:

• Cloud Functions (1a gen.) prepara un prerequisito "(predefinito)" esistente in modalità nativa Firestore. Non supportare i database denominati Cloud Firestore o la modalità Datastore. Utilizza Cloud Functions (2ª gen.) per configurare gli eventi in questi casi.
• L'ordine non è garantito. Modifiche rapide possono attivare chiamate di funzione in un ordine inaspettato.
• Gli eventi vengono pubblicati almeno una volta, ma un singolo evento può comportare più chiamate di funzione. Da evitare in base a la meccanica "exactly-once" e scrivere funzioni idempotenti:
• Cloud Firestore in modalità Datastore richiede Cloud Functions (2a generazione). Cloud Functions (1a generazione) non supportare la modalità Datastore.
• Un trigger è associato a un singolo database. Non puoi creare un attivatore che corrisponda a più database.
• L'eliminazione di un database non elimina automaticamente alcun trigger per quel database. La interrompe la pubblicazione degli eventi, ma continua a esistere finché non elimini l'attivatore.
• Se un evento corrispondente supera le dimensioni massime della richiesta, il valore l'evento potrebbe non essere consegnato a Cloud Functions (1a gen.).
  • Gli eventi non inviati a causa delle dimensioni della richiesta vengono registrati nei log della piattaforma e conteggiati ai fini dell'utilizzo dei log per il progetto.
  • Puoi trovare questi log in Esplora log con il messaggio "L'evento non può recapitare a Funzione Cloud Functions a causa del superamento del limite per le dimensioni di 1ª generazione..." di error gravità. Puoi trovare il nome della funzione nel campo functionName. Se Se il campo receiveTimestamp si trova ancora a meno di un'ora da adesso, puoi dedurre i contenuti dell'evento effettivo leggendo il documento in questione con una uno snapshot prima e dopo il timestamp.
  • Per evitare questa frequenza, puoi:
    • Esegui la migrazione ed esegui l'upgrade a Cloud Functions (2a generazione)
    • Riduci le dimensioni del documento
    • Eliminare l'Cloud Functions in questione
  • Puoi disattivare il logging utilizzando le esclusioni ma tieni presente che gli eventi offensivi non verranno comunque pubblicati.