or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

data-types.mddatabase-operations.mdindex.mdmodular-api.mdoffline-network.mdquerying-filtering.mdrealtime-sync.mdtransactions-batches.md
tile.json

tessl/npm-react-native-firebase--firestore

React Native Firebase Cloud Firestore provides a NoSQL document database with real-time synchronization capabilities.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@react-native-firebase/firestore@23.3.x

To install, run

npx @tessl/cli install tessl/npm-react-native-firebase--firestore@23.3.0

index.mddocs/

React Native Firebase - Cloud Firestore

React Native Firebase Cloud Firestore provides a complete NoSQL document database with real-time synchronization capabilities. It offers comprehensive APIs that mirror the Firebase Web SDK while leveraging native mobile SDKs for enhanced performance and offline capabilities. The library supports advanced querying with real-time listeners, batch operations, transaction support, and automatic data caching with offline persistence.

Package Information

  • Package Name: @react-native-firebase/firestore
  • Package Type: npm
  • Language: JavaScript/TypeScript
  • Installation: npm install @react-native-firebase/firestore
  • Dependencies: Requires @react-native-firebase/app to be installed

Core Imports

import firestore from '@react-native-firebase/firestore';

Alternative imports:

import { firebase } from '@react-native-firebase/firestore';
// firebase.firestore().X

For modular API (recommended):

import { 
  getFirestore, 
  collection, 
  doc, 
  getDoc, 
  setDoc, 
  addDoc, 
  updateDoc, 
  deleteDoc,
  onSnapshot,
  query,
  where,
  orderBy,
  limit
} from '@react-native-firebase/firestore';

Basic Usage

import firestore from '@react-native-firebase/firestore';

// Get a reference to the users collection
const usersCollection = firestore().collection('users');

// Add a new user
await usersCollection.add({
  name: 'John Doe', 
  email: 'john@example.com',
  createdAt: firestore.FieldValue.serverTimestamp()
});

// Get a specific user document
const userDoc = await firestore().collection('users').doc('userId').get();
if (userDoc.exists) {
  console.log('User data:', userDoc.data());
}

// Listen to real-time updates
const unsubscribe = firestore()
  .collection('users')
  .onSnapshot(snapshot => {
    snapshot.forEach(doc => {
      console.log(doc.id, '=>', doc.data());
    });
  });

// Query with filters
const activeUsers = await firestore()
  .collection('users')
  .where('active', '==', true)
  .orderBy('createdAt', 'desc')
  .limit(10)
  .get();

Architecture

React Native Firebase Firestore is built around several key components:

  • Firestore Module: Main entry point providing database operations and configuration
  • References: DocumentReference and CollectionReference for accessing and manipulating data
  • Queries: Advanced filtering, ordering, and pagination capabilities with real-time listeners
  • Transactions & Batches: Atomic operations for data consistency
  • Data Types: Rich data model with Timestamps, GeoPoints, Blobs, and FieldValues
  • Offline Support: Automatic caching with configurable persistence settings
  • Modular API: Modern Firebase v9+ style functional API alongside traditional namespace API

Capabilities

Database Operations

Core database functionality for accessing collections and documents, with full CRUD operations and real-time synchronization.

// Main Firestore instance
firestore(): FirebaseFirestoreTypes.Module;

// Collection and document references
collection(collectionPath: string): FirebaseFirestoreTypes.CollectionReference;
doc(documentPath: string): FirebaseFirestoreTypes.DocumentReference;
collectionGroup(collectionId: string): FirebaseFirestoreTypes.Query;

Database Operations

Querying & Filtering

Advanced query capabilities with filtering, ordering, pagination, and aggregation. Supports both simple field queries and complex composite filters.

// Query methods
where(fieldPath: string | FirebaseFirestoreTypes.FieldPath, opStr: FirebaseFirestoreTypes.WhereFilterOp, value: any): FirebaseFirestoreTypes.Query;
orderBy(fieldPath: string | FirebaseFirestoreTypes.FieldPath, directionStr?: 'asc' | 'desc'): FirebaseFirestoreTypes.Query;
limit(limit: number): FirebaseFirestoreTypes.Query;
startAt(...fieldValues: any[]): FirebaseFirestoreTypes.Query;
endAt(...fieldValues: any[]): FirebaseFirestoreTypes.Query;

// Filter API
Filter(fieldPath: string | FirebaseFirestoreTypes.FieldPath, operator: FirebaseFirestoreTypes.WhereFilterOp, value: any): FirebaseFirestoreTypes.QueryFieldFilterConstraint;
Filter.and(...queries: FirebaseFirestoreTypes.QueryFilterConstraint[]): FirebaseFirestoreTypes.QueryCompositeFilterConstraint;
Filter.or(...queries: FirebaseFirestoreTypes.QueryFilterConstraint[]): FirebaseFirestoreTypes.QueryCompositeFilterConstraint;

Querying & Filtering

Real-time Data Synchronization

Real-time listeners for documents and collections with configurable options for metadata changes and error handling.

// Document snapshots
onSnapshot(
  observer: {
    next?: (snapshot: FirebaseFirestoreTypes.DocumentSnapshot) => void;
    error?: (error: Error) => void;
    complete?: () => void;
  }
): () => void;

// Query snapshots
onSnapshot(
  observer: {
    next?: (snapshot: FirebaseFirestoreTypes.QuerySnapshot) => void;
    error?: (error: Error) => void;
    complete?: () => void;
  }
): () => void;

Real-time Data Synchronization

Transactions & Batches

Atomic operations for ensuring data consistency across multiple operations. Supports both read-write transactions and write-only batches.

// Transactions
runTransaction(updateFunction: (transaction: FirebaseFirestoreTypes.Transaction) => Promise<any>): Promise<any>;

// Write batches
batch(): FirebaseFirestoreTypes.WriteBatch;

interface Transaction {
  get<T>(documentRef: FirebaseFirestoreTypes.DocumentReference<T>): Promise<FirebaseFirestoreTypes.DocumentSnapshot<T>>;
  set<T>(documentRef: FirebaseFirestoreTypes.DocumentReference<T>, data: T, options?: FirebaseFirestoreTypes.SetOptions): FirebaseFirestoreTypes.Transaction;
  update<T>(documentRef: FirebaseFirestoreTypes.DocumentReference<T>, data: Partial<T>): FirebaseFirestoreTypes.Transaction;
  delete(documentRef: FirebaseFirestoreTypes.DocumentReference): FirebaseFirestoreTypes.Transaction;
}

interface WriteBatch {
  set<T>(documentRef: FirebaseFirestoreTypes.DocumentReference<T>, data: T, options?: FirebaseFirestoreTypes.SetOptions): FirebaseFirestoreTypes.WriteBatch;
  update<T>(documentRef: FirebaseFirestoreTypes.DocumentReference<T>, data: Partial<T>): FirebaseFirestoreTypes.WriteBatch;
  delete(documentRef: FirebaseFirestoreTypes.DocumentReference): FirebaseFirestoreTypes.WriteBatch;
  commit(): Promise<void>;
}

Transactions & Batches

Data Types & Field Values

Rich data model supporting various data types including custom Firestore types and special field operations.

// Core data types
class Timestamp {
  static now(): FirebaseFirestoreTypes.Timestamp;
  static fromDate(date: Date): FirebaseFirestoreTypes.Timestamp;
  static fromMillis(milliseconds: number): FirebaseFirestoreTypes.Timestamp;
  toDate(): Date;
  toMillis(): number;
}

class GeoPoint {
  constructor(latitude: number, longitude: number);
  readonly latitude: number;
  readonly longitude: number;
}

class FieldValue {
  static serverTimestamp(): FirebaseFirestoreTypes.FieldValue;
  static delete(): FirebaseFirestoreTypes.FieldValue;
  static increment(n: number): FirebaseFirestoreTypes.FieldValue;
  static arrayUnion(...elements: any[]): FirebaseFirestoreTypes.FieldValue;
  static arrayRemove(...elements: any[]): FirebaseFirestoreTypes.FieldValue;
}

class Blob {
  static fromBase64String(base64: string): FirebaseFirestoreTypes.Blob;
  static fromUint8Array(array: Uint8Array): FirebaseFirestoreTypes.Blob;
  toBase64(): string;
  toUint8Array(): Uint8Array;
}

Data Types & Field Values

Offline & Network Management

Comprehensive offline support with configurable persistence, network management, cache control, and data bundle operations.

// Network control
enableNetwork(): Promise<void>;
disableNetwork(): Promise<void>;

// Persistence management
clearPersistence(): Promise<void>;
waitForPendingWrites(): Promise<void>;
terminate(): Promise<void>;

// Bundle operations
loadBundle(bundle: string): Promise<FirebaseFirestoreTypes.LoadBundleTaskProgress>;
namedQuery(queryName: string): FirebaseFirestoreTypes.Query | null;

// Settings configuration
settings(settings: FirebaseFirestoreTypes.Settings): Promise<void>;

// Emulator support
useEmulator(host: string, port: number): void;

interface Settings {
  persistence?: boolean;
  cacheSizeBytes?: number;
  host?: string;
  ssl?: boolean;
  ignoreUndefinedProperties?: boolean;
  serverTimestampBehavior?: 'estimate' | 'previous' | 'none';
}

Offline & Network Management

Modular API

Modern Firebase v9+ style functional API providing tree-shakable imports and improved developer experience.

// Core functions
function getFirestore(app?: FirebaseAppTypes.Module, databaseId?: string): FirebaseFirestoreTypes.Firestore;
function doc(firestore: FirebaseFirestoreTypes.Firestore, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.DocumentReference;
function collection(firestore: FirebaseFirestoreTypes.Firestore, path: string, ...pathSegments: string[]): FirebaseFirestoreTypes.CollectionReference;

// Document operations
function getDoc<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>): Promise<FirebaseFirestoreTypes.DocumentSnapshot<T>>;
function setDoc<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>, data: T): Promise<void>;
function updateDoc<T>(reference: FirebaseFirestoreTypes.DocumentReference<T>, data: Partial<T>): Promise<void>;
function deleteDoc(reference: FirebaseFirestoreTypes.DocumentReference): Promise<void>;
function addDoc<T>(reference: FirebaseFirestoreTypes.CollectionReference<T>, data: T): Promise<FirebaseFirestoreTypes.DocumentReference<T>>;

Modular API

Types

Core Interfaces

interface DocumentData {
  [field: string]: any;
}

interface GetOptions {
  source: 'default' | 'server' | 'cache';
}

interface SetOptions {
  merge?: boolean;
  mergeFields?: (string | FirebaseFirestoreTypes.FieldPath)[];
}

interface SnapshotListenOptions {
  includeMetadataChanges: boolean;
}

interface SnapshotMetadata {
  fromCache: boolean;
  hasPendingWrites: boolean;
}

Type Definitions

type WhereFilterOp = '<' | '<=' | '==' | '>' | '>=' | '!=' | 'array-contains' | 'array-contains-any' | 'in' | 'not-in';
type DocumentChangeType = 'added' | 'removed' | 'modified';
type OrderByDirection = 'desc' | 'asc';
type LogLevel = 'debug' | 'error' | 'silent';

interface DocumentSnapshot<T = DocumentData> {
  data(options?: SnapshotOptions): T | undefined;
  get(fieldPath: keyof T | FirebaseFirestoreTypes.FieldPath, options?: SnapshotOptions): any;
  exists: boolean;
  id: string;
  metadata: FirebaseFirestoreTypes.SnapshotMetadata;
  ref: FirebaseFirestoreTypes.DocumentReference<T>;
}

interface QuerySnapshot<T = DocumentData> {
  docs: FirebaseFirestoreTypes.QueryDocumentSnapshot<T>[];
  empty: boolean;
  metadata: FirebaseFirestoreTypes.SnapshotMetadata;
  query: FirebaseFirestoreTypes.Query<T>;
  size: number;
  docChanges(options?: SnapshotListenOptions): FirebaseFirestoreTypes.DocumentChange<T>[];
}