SyncEngine | Sync between iCloud and Realm | Storage library

What you're seeing is the default stringified representation of a DocumentSnapshot type object. It doesn't really make a whole lot of sense to examine its contents this way, because it's an internally complex object that itself contains many references to other objects that are also being stringified here. If you want to see the document data inside that snapshot, you should simply call data() on it to get a simple JavaScript object that will log easily.

The problem is that your code is catching an error that doesn't come directly from the invocation of a Firestore API. You're catching an error that comes from Tasks.await(), which is not a Firestore API. The Firestore error is embedded as the cause of the ExecutionException, and you can find it by looking at the cause property (getCause() method) of the ExecutionException that you caught.

To be honest, you should consider abandoning using the Task API like this. Tasks.await() isn't really meant to be used as you are doing now. Instead, it's better to use the kotlinx-coroutines-play-services library to add an extension function that lets you more easily work with Task objects in a coroutine, as I describe in this answer: How To Use Async/Await/Coroutines In OnCompleteListener Firebase

Posting as Community Wiki, as in the comments was confirmed that the issue was solved.

The issue was with the different collection names used on the security rules and in the class code. In the security rules the name was Donors, while in the class it was Donor. Once this mistype in the names was fixed, the issue was fixed from the creation of documents.

Try to run flutter pub cache repair at command line and sync your gradle files from Android Studio.

You could take Android X error after that. Simply could migrate to Android X if you takes

Migration to Android X: https://flutter.dev/docs/development/androidx-migration

A couple things stand out to me in your addDocument() method:

1. You are first adding the document, then immediately performing a get() on the document. This will needlessly trigger a database read to pull down the same information you just provided.
2. That get() returns a DocumentSnapshot which is a container object for a Firestore document value. Printing out its raw contents probably includes all kinds of things you don't want.

Your test isn't really testing any of your own logic, it's essentially testing the Firestore SDK (which is already quite well tested!). What you might want is to return a data object with the Firestore Document ID inserted into it. That might look something like this:

Frustrated man,

Generally, you will want to save your changes AND your events within the same database transaction. In this way, you guarantee that your events are only written when your changes are written.

Next, you should consider triggering email alerts only after the database has been written. Consider a distributed process where you pick up new events from the database and publish them to a queue. You can then have disparate processes that pick them up and process them (e.g. emailing the user).

Generally speaking, trying to do all of your work in one process with no transactional guarantees is a recipe for inconsistent state. Break your work into small units of work that you can guarantee and don't be afraid to offload the work to queues where you can similarly make guarantees about whether the work will be completed.

Regarding your other questions,

• You should ideally wrap your Root entities in Aggregates and maintain your logic there
• You should only have repositories for Root entities. They should load any dependent child entities. Child entities do not need to be loaded independently so they don't require repositories
• If you are dealing with hundreds of columns, can you vertically partition these tables and entities and turn them into many Roots? That is, do all of the columns get updated at the same time/use case? Having an entity of that size is inefficient from a read perspective, but also when writing if the fields are written from different use cases and will become a bottleneck under heavy writing scenarios.

Hope that helps.

You're discarding the observation as you create it. To solve this, you need to retain the NotificationToken returned by observe.

How about change it to"

You have to put all you changes on a single observable and then you can do debouncing and etc.

You can do something like this: