Con Cloud Functions, puoi distribuire il codice Node.js per gestire gli eventi attivati dalle modifiche nel database Cloud Firestore. Ciò ti consente di 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 degli esempi di funzioni .
Si attiva la funzione Cloud Firestore
L'SDK Cloud Functions for Firebase esporta un oggetto functions.firestore
che consente di creare gestori legati a specifici eventi Cloud Firestore.
Tipo di evento | Grilletto |
---|---|
onCreate | Si attiva quando si scrive su un documento per la prima volta. |
onUpdate | Attivato quando un documento esiste già e ha un valore modificato. |
onDelete | Si attiva quando un documento con dati viene eliminato. |
onWrite | Attivato quando viene attivato onCreate , onUpdate o onDelete . |
Se non hai ancora un progetto abilitato per Cloud Functions for Firebase, leggi Per iniziare: scrivi e distribuisci le tue prime funzioni per configurare e impostare il tuo progetto Cloud Functions for Firebase.
Scrittura di funzioni attivate da Cloud Firestore
Definire un trigger di funzione
Per definire un trigger 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 a 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.
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 });
Specificare un gruppo di documenti utilizzando i caratteri jolly
Se desideri allegare un trigger a un gruppo di documenti, ad esempio qualsiasi documento in una determinata raccolta, utilizza un {wildcard}
al posto dell'ID del 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 qualsiasi campo su qualsiasi documento in users
, corrisponde a un carattere jolly denominato userId
.
Se un documento in users
dispone di 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 raccolte esplicite o ID documento, 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 l'attivazione di una funzione 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 ... });
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 modifica 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 ... });
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 ... });
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 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 ... });
Lettura e scrittura dei 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 dell'istantanea 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 con 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 invocazione di funzione è associata a un documento specifico nel tuo database Cloud Firestore. Puoi accedere a quel documento come DocumentReference
nella proprietà ref
dello snapshot restituito alla tua funzione.
Questo DocumentReference
proviene dall'SDK 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.
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 trigger
Le funzioni Cloud vengono eseguite in un ambiente affidabile, il che significa che sono autorizzate come account di servizio nel tuo progetto. Puoi eseguire letture e scritture utilizzando Firebase Admin SDK :
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 presenti le seguenti limitazioni per i trigger Cloud Firestore per Cloud Functions:
- L'ordine non è garantito. Cambiamenti rapidi possono attivare invocazioni di funzioni in un ordine imprevisto.
- Gli eventi vengono consegnati almeno una volta, ma un singolo evento può comportare più chiamate di funzioni. Evita di dipendere dalla meccanica esattamente una volta e scrivi funzioni idempotenti .
- Cloud Firestore in modalità Datastore richiede Cloud Functions (2a generazione). Cloud Functions (1a generazione) non supporta la modalità Datastore.
- Cloud Functions (1a generazione) funziona solo con il database "(predefinito)" e non supporta i database denominati Cloud Firestore. Utilizza Cloud Functions (2ª generazione) per configurare gli eventi per i database denominati.
- Un trigger è associato a un singolo database. Non è possibile creare un trigger che corrisponda a più database.
- L'eliminazione di un database non elimina automaticamente alcun trigger per quel database. Il trigger smette di fornire eventi ma continua a esistere finché non lo elimini .
- Se un evento corrispondente supera la dimensione massima della richiesta , l'evento potrebbe non essere recapitato a Cloud Functions (1a generazione).
- Gli eventi non consegnati a causa delle dimensioni della richiesta vengono registrati nei log della piattaforma e vengono conteggiati nell'utilizzo del log per il progetto.
- Puoi trovare questi log in Esplora log con il messaggio "L'evento non può essere consegnato alla funzione Cloud a causa delle dimensioni che superano il limite per la prima generazione..." di gravità
error
. Puoi trovare il nome della funzione nel campofunctionName
. Se il camporeceiveTimestamp
è ancora entro un'ora da adesso, puoi dedurre il contenuto effettivo dell'evento leggendo il documento in questione con un'istantanea prima e dopo il timestamp. - Per evitare tale cadenza, puoi:
- Migrazione e upgrade a Cloud Functions (2a generazione)
- Ridimensionare il documento
- Elimina le Cloud Functions in questione
- Puoi disattivare la registrazione stessa utilizzando le esclusioni , ma tieni presente che gli eventi offensivi non verranno comunque recapitati.