Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Estendere Firestore con Cloud Functions

Con Cloud Functions, puoi eseguire il deployment del codice Node.js per gestire gli eventi attivati dalle modifiche nel database Firestore. Questo consente di aggiungere facilmente funzionalità lato server all'app senza eseguire i propri server.

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

Trigger di funzione Firestore

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

Tipo di evento Attivazione
onCreate Si attiva quando un documento è scritto per la prima volta.
onUpdate Attivato quando esiste già un documento e viene modificato il valore.
onDelete Si attiva quando un documento con dati viene eliminato.
onWrite Si attiva quando onCreate, onUpdate o onDelete sono attivati.

Se non disponi ancora di un progetto per Cloud Functions for Firebase, leggi Iniziare: scrivere ed eseguire il deployment delle prime funzioni per configurare e configurare il progetto Cloud Functions for Firebase.

Scrittura delle funzioni attivate da Firestore

Definisci un trigger di funzione

Per definire un trigger di 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 a un pattern jolly.

Specifica un singolo documento

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

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
    });

Specifica un gruppo di documenti utilizzando caratteri jolly

Se vuoi collegare un trigger a un gruppo di documenti, ad esempio qualsiasi documento in 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"}
    });

In questo esempio, quando viene modificato un campo di qualsiasi documento di users, viene restituito un carattere jolly denominato userId.

Se un documento in users ha sottoraccolte e un campo in una di queste raccolte secondarie è 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 sostituire con gli ID documento o raccolta 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"}
    });

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

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

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:

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

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 documento Firestore utilizzando la funzione onWrite() con il 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 ...
    });

Lettura e scrittura di dati

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

Dati evento

Lettura dei dati

Quando viene attivata una funzione, può essere opportuno recuperare i dati di un documento aggiornato o prima dell'aggiornamento. Per ottenere i dati precedenti, utilizza change.before.data(), che contiene l'istantanea del documento prima dell'aggiornamento. Allo stesso modo, change.after.data() contiene lo stato dello snapshot del documento dopo l'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();
    });

Puoi accedere alle proprietà come faresti in qualsiasi altro oggetto. In alternativa, puoi utilizzare 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');

Scrittura dei dati

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

Questo elemento DocumentReference proviene dall'SDK Node.js di Firestore e include metodi come update(), set() e remove() per consentirti di modificare facilmente 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});
    });

Dati esterni all'evento di attivazione

Le funzioni Cloud Functions vengono eseguite in un ambiente attendibile, ovvero sono autorizzate come account di servizio nel progetto. Puoi eseguire operazioni di lettura e scrittura utilizzando l'SDK Firebase Admin:

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

Limitazioni

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

  • Non è possibile effettuare ordini. I cambiamenti rapidi possono attivare le chiamate di funzione in un ordine imprevisto.
  • Gli eventi vengono pubblicati almeno una volta, ma un singolo evento può comportare più chiamate di funzione. Evita di farlo a seconda delle meccaniche esattamente una volta e scrivi funzioni idempotenti.
  • I trigger Firestore per Cloud Functions sono disponibili solo per Firestore in modalità Native. Non è disponibile per Firestore in modalità Datastore.