Estendere Cloud Firestore con Cloud Functions (1ª gen.)

Con Cloud Functions, puoi eseguire il deployment del codice Node.js per gestire gli eventi attivati dalle modifiche nel database Cloud Firestore. In questo modo puoi aggiungere facilmente funzionalità lato server alla tua app senza eseguire i tuoi server.

Per esempi di casi d'uso, consulta Cosa posso fare con Cloud Functions? o il repository GitHub di esempi di funzioni.

Trigger di funzioni Cloud Firestore

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

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

Scrittura di funzioni attivate da Cloud Firestore

Definisci un trigger di funzione

Per definire un Cloud Firestore trigger, 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 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 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

Specifica un gruppo di documenti utilizzando i caratteri jolly

Se vuoi collegare un trigger a un gruppo di documenti, ad esempio a qualsiasi documento in 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 viene modificato un campo di un documento in users, viene trovata una corrispondenza con un carattere jolly chiamato userId.

Se un documento in users ha raccolte secondarie e un campo in uno dei documenti 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 evento

Attiva una funzione quando viene creato un nuovo documento

Puoi attivare una funzione da eseguire 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 eseguire quando un documento viene aggiornato utilizzando la onUpdate() funzione con un carattere 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

Attiva una funzione quando un documento viene eliminato

Puoi anche attivare una funzione quando un documento viene eliminato utilizzando la onDelete() funzione 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 attivato, puoi ascoltare tutte le modifiche in un Cloud Firestore documento 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 dei dati

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

Dati sugli eventi

Lettura dei dati

Quando viene attivata una funzione, potresti voler recuperare i dati da un documento aggiornato o recuperare i dati prima dell'aggiornamento. Puoi recuperare 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 dei dati

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

Questo DocumentReference proviene dall' Cloud Firestore SDK Node.js e include metodi come update(), set() e remove() per 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 di attivazione

Cloud Functions viene eseguito in un ambiente attendibile, il che significa che è autorizzato come service account nel tuo progetto. Puoi eseguire operazioni di lettura e scrittura 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 presenti le seguenti limitazioni per i Cloud Firestore trigger per Cloud Functions:

• Cloud Functions (1ª gen.) richiede come prerequisito un database "(default)" esistente in modalità nativa Firestore. Non supporta i database denominati Cloud Firestore o la modalità Datastore. In questi casi, utilizza Cloud Functions (2ª gen.) per configurare gli eventi.
• La configurazione tra progetti con Cloud Functions e trigger Cloud Firestore è una limitazione. Per configurare i trigger Cloud Firestore Cloud Functions deve trovarsi nello stesso progetto.
• L'ordinamento non è garantito. Le modifiche rapide possono attivare le chiamate di funzioni in un ordine imprevisto.
• Gli eventi vengono inviati almeno una volta, ma un singolo evento può comportare più chiamate di funzione. Evita di fare affidamento sulla meccanica di esecuzione "esattamente una volta" e scrivi funzioni idempotenti.
• Cloud Firestore in modalità Datastore richiede Cloud Functions (2ª gen.). Cloud Functions (1ª gen.) non supporta la modalità Datastore.
• Un trigger è associato a un singolo database. Non puoi creare un trigger che corrisponda a più database.
• L'eliminazione di un database non comporta l'eliminazione automatica di eventuali trigger per quel database. Il trigger smette di inviare eventi, ma continua a esistere finché non lo elimini.
• Se un evento corrispondente supera le dimensioni massime della richiesta, l' evento potrebbe non essere recapitato a Cloud Functions (1ª gen.).
  • Gli eventi non recapitati a causa delle dimensioni della richiesta vengono registrati nei log della piattaforma e vengono conteggiati nell'utilizzo dei log per il progetto.
  • Puoi trovare questi log in Esplora log con il messaggio "Event cannot deliver to Cloud function due to size exceeding the limit for 1st gen…" (L'evento non può essere inviato alla funzione Cloud Functions perché le dimensioni superano il limite per la 1ª gen…) di gravità error. Puoi trovare il nome della funzione nel campo functionName. Se il campo receiveTimestamp rientra entro un'ora da questo momento, puoi dedurre i contenuti effettivi dell'evento leggendo il documento in questione con uno snapshot prima e dopo il timestamp.
  • Per evitare questa cadenza, puoi:
    • Eseguire la migrazione e l'upgrade a Cloud Functions (2ª gen.)
    • Ridurre le dimensioni del documento
    • Eliminare le Cloud Functions in questione
  • Puoi disattivare il logging utilizzando le esclusioni ma tieni presente che gli eventi incriminati non verranno comunque recapitati.