Aktywatory bazy danych czasu rzeczywistego

.

Za pomocą Cloud Functions możesz obsługiwać zdarzenia w Firebase Realtime Database bez konieczności aktualizowania kodu klienta. Cloud Functions umożliwia uruchamianie Realtime Database operacji z pełnym dostępem administracyjnym i zapewnia przetwarzanie każdej zmiany w Realtime Database poszczególne osoby. Firebase Realtime Database zmian możesz wprowadzić w DataSnapshot. lub za pomocą pakietu Admin SDK.

W typowym cyklu życia funkcja Firebase Realtime Database wykonuje te czynności:

  1. Oczekiwanie na zmiany w określonej lokalizacji Realtime Database.
  2. Jest wywoływane, gdy zdarzenie występuje i wykonuje swoje zadania (zobacz sekcję Co mogę zrobić z użytkownikiem Cloud Functions? Aby zobaczyć przykłady przypadków użycia).
  3. Odbiera obiekt danych zawierający zrzut zapisanych danych w określonym dokumencie.

Aktywowanie funkcji Realtime Database

Utwórz nowe funkcje dla Realtime Database zdarzeń dzięki functions.database. Do kontrolować, kiedy funkcja ma się uruchamiać, określić jeden z modułów obsługi zdarzeń. określ ścieżkę Realtime Database, w której będzie nasłuchiwać zdarzeń.

Ustawianie modułu obsługi zdarzeń

Funkcje umożliwiają obsługę zdarzeń Realtime Database na 2 poziomach dokładności: możesz nasłuchiwać wyłącznie tworzenia, aktualizowania i zdarzeń usuwania. Możesz też nasłuchiwać dowolnej zmiany ścieżki. Cloud Functions obsługuje te moduły obsługi zdarzeń Realtime Database:

  • onWrite(), który uruchamia się, gdy dane są tworzone, aktualizowane lub usuwane w Realtime Database.
  • onCreate(), który jest wyzwalany po utworzeniu nowych danych w usłudze Realtime Database.
  • onUpdate(), które uruchamia się, gdy dane są aktualizowane w: Realtime Database .
  • onDelete(), które uruchamia się, gdy dane z Realtime Database zostają usunięte .

Podaj instancję i ścieżkę

Aby kontrolować, kiedy i gdzie ma być uruchamiana Twoja funkcja, wywołaj ref(path) , by podać ścieżkę i opcjonalnie wskazać instancję Realtime Database dzięki instance('INSTANCE_NAME'). Jeśli nie chcesz i wskaż instancję, funkcja zostanie wdrożona w domyślnej instancji Realtime Database w projekt Firebase. Na przykład:

  • Domyślna instancja Realtime Database: functions.database.ref('/foo/bar')
  • Instancja o nazwie „my-app-db-2”: functions.database.instance('my-app-db-2').ref('/foo/bar')

Te metody kierują funkcję do obsługi zapisów na określonej ścieżce w obrębie instancję Realtime Database. specyfikacje ścieżki pasują do wszystkich zapisów, które dotykają ścieżki, w tym zapisy które dzieje się w dowolnym miejscu pod nią. Jeśli ustawisz ścieżkę dla Twojej funkcji jako /foo/bar, pasuje do zdarzeń w obu tych lokalizacjach:

 /foo/bar
 /foo/bar/baz/really/deep/path

W obu tych przypadkach Firebase interpretuje, że zdarzenie ma miejsce /foo/bar, a dane zdarzenia zawierają stare i nowe dane są dostępne na stronie /foo/bar. Jeśli dane zdarzenia są duże, rozważ użycie wielu funkcji na głębszych ścieżkach zamiast jednej w pobliżu rdzenia bazy danych. Aby uzyskać najlepszą skuteczność, wyślij tylko żądanie dane na najgłębszym możliwym poziomie.

Komponent ścieżki możesz określić jako symbol wieloznaczny, umieszczając w komponencie klamrowym. nawiasy; Wyrażenie ref('foo/{bar}') odpowiada dowolnemu elementowi podrzędnemu z /foo. Wartości tych komponenty ścieżki z symbolem wieloznacznym są dostępne w EventContext.params obiektu funkcji. W tym przykładzie wartość jest dostępna jako context.params.bar

Ścieżki z symbolami wieloznacznymi mogą pasować do wielu zdarzeń z jednego zapisu. Wstawienie

{
  "foo": {
    "hello": "world",
    "firebase": "functions"
  }
}

dwukrotnie pasuje do ścieżki "/foo/{bar}": raz z "hello": "world" i jeszcze raz w grupie "firebase": "functions".

Obsługa danych zdarzenia

Podczas obsługi zdarzenia Realtime Database zwracany obiekt danych to DataSnapshot W przypadku zdarzeń onWrite i onUpdate wartość Pierwszy parametr to obiekt Change, który zawiera 2 zrzuty reprezentujących stan danych przed oraz po zdarzeniu aktywującym. W przypadku zdarzeń onCreate i onDelete: zwracany obiekt danych to zrzut utworzonych lub usuniętych danych.

W tym przykładzie funkcja pobiera zrzut dysku dla: w podanej ścieżce, zamienia ciąg znaków w tej lokalizacji na wielkie litery, i zapisuje zmodyfikowany ciąg w bazie danych:

// Listens for new messages added to /messages/:pushId/original and creates an
// uppercase version of the message to /messages/:pushId/uppercase
exports.makeUppercase = functions.database.ref('/messages/{pushId}/original')
    .onCreate((snapshot, context) => {
      // Grab the current value of what was written to the Realtime Database.
      const original = snapshot.val();
      functions.logger.log('Uppercasing', context.params.pushId, original);
      const uppercase = original.toUpperCase();
      // You must return a Promise when performing asynchronous tasks inside a Functions such as
      // writing to the Firebase Realtime Database.
      // Setting an "uppercase" sibling in the Realtime Database returns a Promise.
      return snapshot.ref.parent.child('uppercase').set(uppercase);
    });
index.js

Uzyskiwanie dostępu do informacji uwierzytelniających użytkowników

Źródło: EventContext.auth i EventContext.authType, masz dostęp informacje o użytkowniku, w tym o jego uprawnieniach, funkcji. Jest to pomocne przy egzekwowaniu reguł zabezpieczeń, co pozwala funkcji wykonywać różne operacje w zależności od poziom uprawnień:

const functions = require('firebase-functions/v1');
const admin = require('firebase-admin');

exports.simpleDbFunction = functions.database.ref('/path')
    .onCreate((snap, context) => {
      if (context.authType === 'ADMIN') {
        // do something
      } else if (context.authType === 'USER') {
        console.log(snap.val(), 'written by', context.auth.uid);
      }
    });

Możesz też wykorzystać informacje uwierzytelniające użytkownika do „podszywania się pod inne osoby”. użytkownik i wykonywać operacje zapisu w imieniu użytkownika. Pamiętaj, aby usunąć instancji aplikacji, jak pokazano poniżej, aby uniknąć problemów z równoczesnością:

exports.impersonateMakeUpperCase = functions.database.ref('/messages/{pushId}/original')
    .onCreate((snap, context) => {
      const appOptions = JSON.parse(process.env.FIREBASE_CONFIG);
      appOptions.databaseAuthVariableOverride = context.auth;
      const app = admin.initializeApp(appOptions, 'app');
      const uppercase = snap.val().toUpperCase();
      const ref = snap.ref.parent.child('uppercase');

      const deleteApp = () => app.delete().catch(() => null);

      return app.database().ref(ref).set(uppercase).then(res => {
        // Deleting the app is necessary for preventing concurrency leaks
        return deleteApp().then(() => res);
      }).catch(err => {
        return deleteApp().then(() => Promise.reject(err));
      });
    });

Odczyt poprzedniej wartości

Obiekt Change ma before. pozwalającą sprawdzić, co zostało zapisane w Realtime Database przed . Właściwość before zwraca wartość DataSnapshot, gdzie wszystkie (na przykład val() i exists()). odwołują się do poprzedniej wartości. Możesz ponownie odczytać nową wartość, używając zarówno argumentu oryginalny DataSnapshot lub czytając after. usłudze. Ta usługa w dowolnym miejscu Change to inna usługa DataSnapshot reprezentująca wartość stan danych po wystąpieniu zdarzenia.

Na przykład przy użyciu właściwości before można upewnić się, że funkcja pisany jest wielkimi literami w chwili jego utworzenia:

exports.makeUppercase = functions.database.ref('/messages/{pushId}/original')
    .onWrite((change, context) => {
      // Only edit data when it is first created.
      if (change.before.exists()) {
        return null;
      }
      // Exit when the data is deleted.
      if (!change.after.exists()) {
        return null;
      }
      // Grab the current value of what was written to the Realtime Database.
      const original = change.after.val();
      console.log('Uppercasing', context.params.pushId, original);
      const uppercase = original.toUpperCase();
      // You must return a Promise when performing asynchronous tasks inside a Functions such as
      // writing to the Firebase Realtime Database.
      // Setting an "uppercase" sibling in the Realtime Database returns a Promise.
      return change.after.ref.parent.child('uppercase').set(uppercase);
    });