Estensione di Firestore con Cloud Functions
Con Cloud Functions, puoi eseguire il deployment del codice Node.js per gestire gli eventi attivati in base alle modifiche apportate al tuo database Firestore. In questo modo puoi aggiungere facilmente nella tua app senza eseguire i tuoi server.
Per esempi di casi d'uso, vedi Cosa posso fare con di Cloud Functions? oppure Repository GitHub di esempi di funzioni.
Trigger delle funzioni Firestore
L'SDK Cloud Functions for Firebase esporta un file functions.firestore
che consente di creare gestori legati a eventi Firestore specifici.
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 Per iniziare: 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 un pattern con caratteri jolly.
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 });
Specifica un gruppo di documenti utilizzando caratteri jolly
Se vuoi allegare un attivatore a un gruppo di documenti, ad esempio qualsiasi documento in
una determinata raccolta, quindi usa un valore {wildcard}
al posto di
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 qualsiasi campo di qualsiasi documento in users
, viene restituito
un carattere jolly denominato userId
.
Se un documento in users
contiene sottoraccolte e un campo in una di queste sottoraccolte
documenti vengono modificati, 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 quanti caratteri jolly vuoi sostituire la raccolta esplicita
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 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 ... });
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 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 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 ... });
Attiva una funzione per tutte le modifiche a un documento
Se non ti interessa il tipo di evento che viene attivato, puoi ascoltare tutti
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 ... });
Lettura e scrittura dei dati
Quando viene attivata una funzione, fornisce un'istantanea dei dati relativi . 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(); });
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');
Scrittura dei dati
Ogni chiamata di funzione è associata a un documento specifico nel
un database Firestore. Puoi accedere a quel documento come
DocumentReference
nella proprietà ref
dello snapshot restituito alla funzione.
Questo DocumentReference
proviene da
SDK Firestore Node.js
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}); });
Dati esterni all'evento di trigger
Le funzioni Cloud Functions vengono eseguite in un ambiente affidabile, il che significa che 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({ ... });
});
Limitazioni
Tieni presente le seguenti limitazioni per i trigger Firestore per Cloud Functions:
- Cloud Functions (1ª generazione.) prepara un prerequisito "(predefinito)" esistente in modalità nativa Firestore. Non supportare i database denominati Firestore o la modalità Datastore. Utilizza Cloud Functions (2ª generazione) 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:
- Firestore in modalità Datastore richiede Cloud Functions (2nd gen). Cloud Functions (1ª generazione) non supportare 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. La interrompe la pubblicazione degli eventi, ma continua a esistere finché non elimini l'attivatore.
- Se un evento con corrispondenza supera le dimensioni massime della richiesta, il valore
potrebbe non essere stato consegnato a Cloud Functions (1ª generazione.).
- Gli eventi non consegnati a causa delle dimensioni della richiesta vengono registrati nei log della piattaforma e vengono conteggiate ai fini dell'utilizzo dei log da parte del 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 sotto il campofunctionName
. Se Se il camporeceiveTimestamp
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 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 pubblicati.