Firestore-Dokumente lesen und schreiben

Cloud Firestore is a NoSQL document database. Data is organized in collections (like folders) that contain documents (like JSON files). Each document has a unique ID and a set of key-value fields. Documents can contain sub-collections for nested data.

For example, a posts collection contains many post documents, each with fields like title, content, and userId. A post document can have a nested comments sub-collection for its replies. This model scales differently from SQL — think about access patterns first, then model data accordingly.

Access a Firestore collection using firestore().collection('collection-name'). This returns a CollectionReference that you use to read documents, add new ones, or listen for changes. Collection references are lightweight and do not trigger any network calls on their own.

To reference a specific document within a collection, chain .doc('document-id'). If you want Firestore to generate a random ID, omit the argument when creating a new document with .add().

Use .add(data) on a collection reference to create a new document with a Firestore-generated ID. Use .doc(id).set(data) to create or overwrite a document with a specific ID.

The firestore.FieldValue.serverTimestamp() utility sets a timestamp on the server side, ensuring all clients see the same creation time regardless of device clock differences. Always use server timestamps for createdAt and updatedAt fields.

Call .get() on a DocumentReference to fetch it once. The result is a DocumentSnapshot. Check snapshot.exists before reading data — if the document was never created, exists is false and snapshot.data() returns undefined.

The snapshot.data() method returns a plain JavaScript object with all the document's fields. The document ID is accessed via snapshot.id, not via the data object.

Use .where(field, operator, value) to filter documents, .orderBy(field, 'desc') to sort, and .limit(n) to cap results. Chain multiple .where calls for AND logic. Call .get() to execute the query and receive a QuerySnapshot.

Iterate the results with snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() })). Firestore requires composite indexes for queries that filter and order by different fields — Firestore will print a link in the logs to create the required index if one is missing.

Use .update() to modify specific fields without overwriting the entire document. Only the fields you specify are changed — all other fields remain intact. This is different from .set(), which replaces the whole document by default.

Use firestore.FieldValue.increment(n) to atomically increment a numeric field without reading it first. Use firestore.FieldValue.arrayUnion(item) and arrayRemove(item) to add or remove items from array fields atomically.

Call .delete() on a DocumentReference to remove the document. This only deletes the document itself, not any sub-collections it may contain. To delete sub-collections, you must recursively delete each document in them — Firestore does not cascade deletes automatically.

To delete a single field from a document without deleting the document itself, use firestore.FieldValue.delete() in an .update() call with the field name as the key.

A batch write lets you execute multiple create, update, and delete operations as a single atomic transaction. Either all operations succeed or none of them do. This is essential for operations that must stay consistent, like transferring credits between users.

Create a batch with firestore().batch(), add operations with batch.set(), batch.update(), and batch.delete(), then commit with batch.commit(). Batches support up to 500 operations at once.

Firestore Security Rules control who can read and write documents. Rules are defined in the Firebase console under Firestore > Rules using a declarative DSL. The request.auth object gives you access to the authenticated user's UID inside rule expressions.

Always start with deny all as the default and explicitly allow only what is needed. A rule that allows a user to write only to their own user document looks like: allow write: if request.auth.uid == userId;

By default, .set(data) overwrites the entire document. To merge new data with existing fields instead of overwriting, pass { merge: true } as the second argument.

This is useful when you want to create a document if it does not exist, or update it if it does — without knowing all its current fields. It is a more flexible alternative to .update(), which throws an error if the document does not exist.

Firestore has a built-in local cache and queues writes when the device is offline. When connectivity returns, Firestore automatically sends the queued writes to the server in order. From the app's perspective, writes succeed immediately — the UI updates without waiting for the server.

This means your React Native app can remain fully functional with no internet connection for reads and writes, and Firestore handles syncing transparently. You can detect the online/offline state using a NetInfo listener if you need to show connectivity status in the UI.

Test your understanding of React Native Mobile Development concepts from this lesson.

In this lesson you learned: the Firestore collection/document data model, how to add, read, update, and delete documents using the React Native Firebase SDK, and how batch writes ensure atomic multi-document operations. Next up we add real-time listeners to receive live Firestore updates and configure offline persistence.