Questa pagina è stata tradotta dall'API Cloud Translation.

Estensione di Firestore con Cloud Functions

Con Cloud Functions puoi eseguire il deployment del codice Node.js per gestire gli eventi attivati da modifiche nel database Firestore. In questo modo, puoi aggiungere facilmente funzionalità lato server nella tua app senza utilizzare 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 delle funzioni Firestore

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

Tipo di evento	Trigger
`onCreate`	Si attiva quando un documento viene scritto per la prima volta.
`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`.

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

Scrittura di funzioni attivate da Firestore

Definisci un trigger di funzione

Per definire un trigger 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 con caratteri jolly.

Specifica un singolo documento

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

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

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 valore {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 un campo qualsiasi di un documento in users, corrisponde a un carattere jolly denominato userId.

Se un documento in users contiene raccolte secondarie e un campo in uno di questi documenti 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 sostituire con 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

Trigger di eventi

Attiva una funzione quando viene creato un nuovo documento

Puoi attivare una funzione in modo che venga attivato 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 ...
    });index.js

Attiva una funzione quando un documento viene aggiornato

Puoi anche attivare una funzione 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:

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

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:

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 attivato, puoi ascoltare tutte le modifiche in un documento 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 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 Admin Firebase per accedere ad altre parti del tuo database.

Dati 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. Puoi 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 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();
    });index.js

Puoi accedere alle proprietà come faresti per 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');index.js

Scrittura dei dati

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

Questo valore DocumentReference proviene dall'SDK Firestore Node.js 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});
    });index.js

Dati esterni all'evento di trigger

Le funzioni Cloud Functions vengono eseguite in un ambiente attendibile, il che significa che sono autorizzate come account di servizio nel progetto. Puoi eseguire letture e scritture utilizzando 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({ ... });
  });

Limitazioni

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

Cloud Functions (1ª generazione.) prepara un database "(predefinito)" esistente in modalità nativa Firestore. Non supporta i database denominati Firestore o la modalità Datastore. In questi casi, usa Cloud Functions (2ª generazione.) per configurare gli eventi.
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ò generare più chiamate di funzione. Evita di dipendere dalla meccanica "exactly-once" e scrivi funzioni idempotenti.
Firestore in modalità Datastore richiede Cloud Functions (2nd gen). Cloud Functions (1ª generazione.) non supporta la modalità Datastore.
Un trigger è associato a un singolo database. Non puoi creare un trigger che corrisponde a più database.
L'eliminazione di un database non elimina automaticamente alcun trigger per quel database. L'attivatore interrompe la pubblicazione degli eventi, ma continua a esistere finché non elimini l'attivatore.
Se un evento corrispondente supera le dimensioni massime della richiesta, l'evento potrebbe non essere pubblicato in Cloud Functions (1ª generazione.).
- Gli eventi non consegnati 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 "Impossibile consegnare l'evento alla funzione Cloud Functions a causa del superamento del limite per la 1ª generazione..." con gravità error. Puoi trovare il nome della funzione sotto il campo functionName. Se il campo receiveTimestamp è ancora a 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 frequenza, puoi:
  - Esegui la migrazione e l'upgrade a Cloud Functions (2nd gen)
  - Ridimensiona il documento
  - Elimina le funzioni Cloud Functions in questione
- Puoi disattivare il logging utilizzando le esclusioni, ma tieni presente che gli eventi offensivi non verranno comunque recapitati.