@react-native-firebase/firestore 20.1.0 → 20.2.0

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [20.2.0](https://github.com/invertase/react-native-firebase/compare/v20.1.0...v20.2.0) (2024-07-15)
+
+### Features
+
+- **other:** Add Firestore support ([#7882](https://github.com/invertase/react-native-firebase/issues/7882)) ([0ebd1dd](https://github.com/invertase/react-native-firebase/commit/0ebd1ddd221c50dde489bce30ad5ed64037d8439))
+
+### Bug Fixes
+
+- **firestore:** expose modular `Filter` and it's proper types ([#7884](https://github.com/invertase/react-native-firebase/issues/7884)) ([272efe5](https://github.com/invertase/react-native-firebase/commit/272efe56acdd46b8c994789f751d2c097cb8d025))
+- **firestore:** remove exception throw on inequality queries on different fields ([da24246](https://github.com/invertase/react-native-firebase/commit/da242466d80609f61420feb56d72ad2ee20b2410))
+
 ## [20.1.0](https://github.com/invertase/react-native-firebase/compare/v20.0.0...v20.1.0) (2024-06-04)
 
 **Note:** Version bump only for package @react-native-firebase/firestore

package/__tests__/firestore.test.ts

@@ -1,10 +1,10 @@
 import { describe, expect, it } from '@jest/globals';
 
-import firestore, { firebase } from '../lib';
+import firestore, { firebase, Filter } from '../lib';
 
 const COLLECTION = 'firestore';
 
-describe('Storage', function () {
+describe('Firestore', function () {
   describe('namespace', function () {
     it('accessible from firebase.app()', function () {
       const app = firebase.app();
@@ -372,5 +372,17 @@ describe('Storage', function () {
         return expect(e.message).toContain("'queryName' must be a non-empty string");
       }
     });
+
+    it('`Filter` is properly exposed to end user', async function () {
+      const filter1 = Filter('name', '==', 'Tim');
+      const filter2 = Filter('age', '>', 21);
+
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const query = Filter.and(filter1, filter2);
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      const query2 = Filter.or(filter1, filter2);
+    });
   });
 });

package/lib/FirestoreQueryModifiers.js

@@ -269,15 +269,6 @@ export default class FirestoreQueryModifiers {
         this.hasInequality = filter;
         continue;
       }
-
-      // Check the set value is the same as the new one
-      if (INEQUALITY[filter.operator] && this.hasInequality) {
-        if (this.hasInequality.fieldPath._toPath() !== filter.fieldPath._toPath()) {
-          throw new Error(
-            `Invalid query. All where filters with an inequality (<, <=, >, != or >=) must be on the same field. But you have inequality filters on '${this.hasInequality.fieldPath._toPath()}' and '${filter.fieldPath._toPath()}'`,
-          );
-        }
-      }
     }
 
     for (let i = 0; i < filters.length; i++) {

package/lib/FirestoreStatics.js

@@ -15,7 +15,7 @@
  *
  */
 
-import { NativeModules } from 'react-native';
+import { getReactNativeModule } from '@react-native-firebase/app/lib/internal/nativeModule';
 import FirestoreBlob from './FirestoreBlob';
 import FirestoreFieldPath from './FirestoreFieldPath';
 import FirestoreFieldValue from './FirestoreFieldValue';
@@ -39,7 +39,7 @@ export default {
       );
     }
 
-    const native = NativeModules.RNFBFirestoreModule;
+    const native = getReactNativeModule('RNFBFirestoreModule');
     native.setLogLevel(logLevel);
   },
 };

package/lib/index.d.ts

@@ -2342,7 +2342,7 @@ export const firebase: ReactNativeFirebase.Module & {
 
 export * from './modular';
 
-export const Filter: FilterFunction;
+export const Filter: FirebaseFirestoreTypes.FilterFunction;
 
 export default defaultExport;
 

package/lib/index.js

@@ -24,6 +24,7 @@ import {
   isUndefined,
   isAndroid,
 } from '@react-native-firebase/app/lib/common';
+import { setReactNativeModule } from '@react-native-firebase/app/lib/internal/nativeModule';
 import {
   createModuleNamespace,
   FirebaseModule,
@@ -38,6 +39,7 @@ import FirestoreStatics from './FirestoreStatics';
 import FirestoreTransactionHandler from './FirestoreTransactionHandler';
 import FirestoreWriteBatch from './FirestoreWriteBatch';
 import version from './version';
+import fallBackModule from './web/RNFBFirestoreModule';
 
 const namespace = 'firestore';
 
@@ -378,3 +380,8 @@ export default createModuleNamespace({
 // firestore().X(...);
 // firebase.firestore().X(...);
 export const firebase = getFirebaseRoot();
+
+// Register the interop module for non-native platforms.
+for (let i = 0; i < nativeModuleName.length; i++) {
+  setReactNativeModule(nativeModuleName[i], fallBackModule);
+}

package/lib/modular/index.js

@@ -216,3 +216,4 @@ export * from './FieldPath';
 export * from './FieldValue';
 export * from './GeoPoint';
 export * from './Timestamp';
+export { Filter } from '../FirestoreFilter';

package/lib/version.js

@@ -1,2 +1,2 @@
 // Generated by genversion.
-module.exports = '20.1.0';
+module.exports = '20.2.0';

package/lib/web/RNFBFirestoreModule.android.js

@@ -0,0 +1,2 @@
+// No-op for android.
+export default {};

package/lib/web/RNFBFirestoreModule.ios.js

@@ -0,0 +1,2 @@
+// No-op for ios.
+export default {};

package/lib/web/RNFBFirestoreModule.js

@@ -0,0 +1,483 @@
+import {
+  setLogLevel,
+  connectFirestoreEmulator,
+  initializeFirestore,
+  runTransaction,
+  getApp,
+  getFirestore,
+  collection,
+  collectionGroup,
+  doc,
+  getDoc,
+  getDocs,
+  getCount,
+  deleteDoc,
+  setDoc,
+  updateDoc,
+  writeBatch,
+  terminate,
+} from '@react-native-firebase/app/lib/internal/web/firebaseFirestore';
+import { guard, getWebError, emitEvent } from '@react-native-firebase/app/lib/internal/web/utils';
+import { objectToWriteable, readableToObject, parseDocumentBatches } from './convert';
+import { buildQuery } from './query';
+
+function rejectWithCodeAndMessage(code, message) {
+  return Promise.reject(
+    getWebError({
+      code,
+      message,
+    }),
+  );
+}
+
+// Converts a Firestore document snapshot to a plain object.
+function documentSnapshotToObject(snapshot) {
+  const exists = snapshot.exists();
+
+  const out = {
+    metadata: [false, false], // lite SDK doesn't return metadata
+    path: snapshot.ref.path,
+    exists,
+  };
+
+  if (exists) {
+    out.data = objectToWriteable(snapshot.data() || {});
+  }
+
+  return out;
+}
+
+// Converts a Firestore query snapshot to a plain object.
+function querySnapshotToObject(snapshot) {
+  return {
+    source: 'get',
+    excludesMetadataChanges: true, // lite SDK doesn't return metadata changes
+    changes: [],
+    metadata: [false, false], // lite SDK doesn't return metadata
+    documents: snapshot.docs.map(documentSnapshotToObject),
+  };
+}
+
+const emulatorForApp = {};
+const firestoreInstances = {};
+const appInstances = {};
+const transactionHandler = {};
+const transactionBuffer = {};
+
+function getCachedAppInstance(appName) {
+  return (appInstances[appName] ??= getApp(appName));
+}
+
+// Returns a cached Firestore instance.
+function getCachedFirestoreInstance(appName) {
+  let instance = firestoreInstances[appName];
+  if (!instance) {
+    instance = getFirestore(getCachedAppInstance(appName));
+    if (emulatorForApp[appName]) {
+      connectFirestoreEmulator(
+        instance,
+        emulatorForApp[appName].host,
+        emulatorForApp[appName].port,
+      );
+    }
+    firestoreInstances[appName] = instance;
+  }
+  return instance;
+}
+
+export default {
+  /**
+   * Sets the log level for Firestore.
+   * @param {string} logLevel - The log level.
+   */
+  async setLogLevel(logLevel) {
+    if (logLevel === 'debug' || logLevel === 'error') {
+      setLogLevel(logLevel);
+    } else {
+      setLogLevel('silent');
+    }
+  },
+
+  loadBundle() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  clearPersistence() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  /**
+   * Waits for all pending writes to be acknowledged by the backend.
+   * Noop in the lite SDK.
+   * @returns {Promise<null>} An empty promise.
+   */
+  async waitForPendingWrites() {
+    return null;
+  },
+
+  disableNetwork() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  enableNetwork() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  /**
+   * Use the Firestore emulator.
+   * @param {string} appName - The app name.
+   * @param {string} host - The emulator host.
+   * @param {number} port - The emulator port.
+   * @returns {Promise<null>} An empty promise.
+   */
+  useEmulator(appName, host, port) {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+      connectFirestoreEmulator(firestore, host, port);
+      emulatorForApp[appName] = { host, port };
+    });
+  },
+
+  /**
+   * Initializes a Firestore instance with settings.
+   * @param {string} appName - The app name.
+   * @param {object} settings - The Firestore settings.
+   * @returns {Promise<null>} An empty promise.
+   */
+  settings(appName, settings) {
+    return guard(() => {
+      const instance = initializeFirestore(getCachedAppInstance(appName), settings);
+      firestoreInstances[appName] = instance;
+    });
+  },
+
+  /**
+   * Terminates a Firestore instance.
+   * @param {string} appName - The app name.
+   * @returns {Promise<null>} An empty promise.
+   */
+  terminate(appName) {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+      await terminate(firestore);
+      return null;
+    });
+  },
+
+  // Collection
+  namedQueryOnSnapshot() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  collectionOnSnapshot() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  collectionOffSnapshot() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  namedQueryGet() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  /**
+   * Get a collection count from Firestore.
+   * @param {string} appName - The app name.
+   * @param {string} path - The collection path.
+   * @param {string} type - The collection type (e.g. collectionGroup).
+   * @param {object[]} filters - The collection filters.
+   * @param {object[]} orders - The collection orders.
+   * @param {object} options - The collection options.
+   * @returns {Promise<object>} The collection count object.
+   */
+  collectionCount(appName, path, type, filters, orders, options) {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+      const queryRef =
+        type === 'collectionGroup' ? collectionGroup(firestore, path) : collection(firestore, path);
+      const query = buildQuery(queryRef, filters, orders, options);
+      const snapshot = await getCount(query);
+
+      return {
+        count: snapshot.data().count,
+      };
+    });
+  },
+
+  /**
+   * Get a collection from Firestore.
+   * @param {string} appName - The app name.
+   * @param {string} path - The collection path.
+   * @param {string} type - The collection type (e.g. collectionGroup).
+   * @param {object[]} filters - The collection filters.
+   * @param {object[]} orders - The collection orders.
+   * @param {object} options - The collection options.
+   * @param {object} getOptions - The get options.
+   * @returns {Promise<object>} The collection object.
+   */
+  collectionGet(appName, path, type, filters, orders, options, getOptions) {
+    if (getOptions && getOptions.source === 'cache') {
+      return rejectWithCodeAndMessage(
+        'unsupported',
+        'The source cache is not supported in the lite SDK.',
+      );
+    }
+
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+      const queryRef =
+        type === 'collectionGroup' ? collectionGroup(firestore, path) : collection(firestore, path);
+      const query = buildQuery(queryRef, filters, orders, options);
+      const snapshot = await getDocs(query);
+      return querySnapshotToObject(snapshot);
+    });
+  },
+
+  // Document
+  documentOnSnapshot() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  documentOffSnapshot() {
+    return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
+  },
+
+  /**
+   * Get a document from Firestore.
+   * @param {string} appName - The app name.
+   * @param {string} path - The document path.
+   * @param {object} getOptions - The get options.
+   * @returns {Promise<object>} The document object.
+   */
+  documentGet(appName, path, getOptions) {
+    return guard(async () => {
+      if (getOptions && getOptions.source === 'cache') {
+        return rejectWithCodeAndMessage(
+          'unsupported',
+          'The source cache is not supported in the lite SDK.',
+        );
+      }
+
+      const firestore = getCachedFirestoreInstance(appName);
+      const ref = doc(firestore, path);
+      const snapshot = await getDoc(ref);
+      return documentSnapshotToObject(snapshot);
+    });
+  },
+
+  /**
+   * Delete a document from Firestore.
+   * @param {string} appName - The app name.
+   * @param {string} path - The document path.
+   * @returns {Promise<null>} An empty promise.
+   */
+  documentDelete(appName, path) {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+      const ref = doc(firestore, path);
+      await deleteDoc(ref);
+      return null;
+    });
+  },
+
+  /**
+   * Set a document in Firestore.
+   * @param {string} appName - The app name.
+   * @param {string} path - The document path.
+   * @param {object} data - The document data.
+   * @param {object} options - The set options.
+   * @returns {Promise<null>} An empty promise.
+   */
+  documentSet(appName, path, data, options) {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+      const ref = doc(firestore, path);
+      const setOptions = {};
+      if ('merge' in options) {
+        setOptions.merge = options.merge;
+      } else if ('mergeFields' in options) {
+        setOptions.mergeFields = options.mergeFields;
+      }
+      await setDoc(ref, readableToObject(firestore, data), setOptions);
+    });
+  },
+
+  /**
+   * Update a document in Firestore.
+   * @param {string} appName - The app name.
+   * @param {string} path - The document path.
+   * @param {object} data - The document data.
+   * @returns {Promise<null>} An empty promise.
+   */
+  documentUpdate(appName, path, data) {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+      const ref = doc(firestore, path);
+      await updateDoc(ref, readableToObject(firestore, data));
+    });
+  },
+
+  /**
+   * Batch write documents in Firestore.
+   * @param {string} appName - The app name.
+   * @param {object[]} writes - The document writes in write batches format.
+   */
+  documentBatch(appName, writes) {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+      const batch = writeBatch(firestore);
+      const writesArray = parseDocumentBatches(firestore, writes);
+
+      for (const parsed of writesArray) {
+        const { type, path } = parsed;
+        const ref = doc(firestore, path);
+
+        switch (type) {
+          case 'DELETE':
+            batch.delete(ref);
+            break;
+          case 'UPDATE':
+            batch.update(ref, parsed.data);
+            break;
+          case 'SET':
+            const options = parsed.options;
+            const setOptions = {};
+            if ('merge' in options) {
+              setOptions.merge = options.merge;
+            } else if ('mergeFields' in options) {
+              setOptions.mergeFields = options.mergeFields;
+            }
+            batch.set(ref, parsed.data, setOptions);
+            break;
+        }
+      }
+
+      await batch.commit();
+    });
+  },
+
+  /**
+   * Get a document from a Firestore transaction.
+   * @param {string} appName - The app name.
+   * @param {string} transactionId - The transaction id.
+   * @param {string} path - The document path.
+   * @returns {Promise<object>} The document object.
+   */
+  transactionGetDocument(appName, transactionId, path) {
+    if (!transactionHandler[transactionId]) {
+      return rejectWithCodeAndMessage(
+        'internal-error',
+        'An internal error occurred whilst attempting to find a native transaction by id.',
+      );
+    }
+
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+      const docRef = doc(firestore, path);
+      const tsx = transactionHandler[transactionId];
+      const snapshot = await tsx.get(docRef);
+      return documentSnapshotToObject(snapshot);
+    });
+  },
+
+  /**
+   * Dispose a transaction instance.
+   * @param {string} appName - The app name.
+   * @param {string} transactionId - The transaction id.
+   */
+  transactionDispose(appName, transactionId) {
+    // There's no abort method in the JS SDK, so we just remove the transaction handler.
+    delete transactionHandler[transactionId];
+  },
+
+  /**
+   * Applies a buffer of commands to a Firestore transaction.
+   * @param {string} appName - The app name.
+   * @param {string} transactionId - The transaction id.
+   * @param {object[]} commandBuffer - The readable array of buffer commands.
+   */
+  transactionApplyBuffer(appName, transactionId, commandBuffer) {
+    if (transactionHandler[transactionId]) {
+      transactionBuffer[transactionId] = commandBuffer;
+    }
+  },
+
+  /**
+   * Begins a Firestore transaction.
+   * @param {string} appName - The app name.
+   * @param {string} transactionId - The transaction id.
+   * @returns {Promise<null>} An empty promise.
+   */
+  transactionBegin(appName, transactionId) {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName);
+
+      try {
+        await runTransaction(firestore, async tsx => {
+          transactionHandler[transactionId] = tsx;
+
+          emitEvent('firestore_transaction_event', {
+            eventName: 'firestore_transaction_event',
+            body: { type: 'update' },
+            appName,
+            listenerId: transactionId,
+          });
+
+          function getBuffer() {
+            return transactionBuffer[transactionId];
+          }
+
+          // Wait for and get the stored buffer array for the transaction.
+          const buffer = await new Promise(resolve => {
+            const interval = setInterval(() => {
+              const buffer = getBuffer();
+              if (buffer) {
+                clearInterval(interval);
+                resolve(buffer);
+              }
+            }, 100);
+          });
+
+          for (const serialized of buffer) {
+            const { path, type, data } = serialized;
+            const docRef = doc(firestore, path);
+
+            switch (type) {
+              case 'DELETE':
+                tsx.delete(docRef);
+                break;
+              case 'UPDATE':
+                tsx.update(docRef, readableToObject(firestore, data));
+                break;
+              case 'SET':
+                const options = serialized.options;
+                const setOptions = {};
+                if ('merge' in options) {
+                  setOptions.merge = options.merge;
+                } else if ('mergeFields' in options) {
+                  setOptions.mergeFields = options.mergeFields;
+                }
+                tsx.set(docRef, readableToObject(firestore, data), setOptions);
+                break;
+            }
+          }
+        });
+
+        emitEvent('firestore_transaction_event', {
+          eventName: 'firestore_transaction_event',
+          body: { type: 'complete' },
+          appName,
+          listenerId: transactionId,
+        });
+      } catch (e) {
+        emitEvent('firestore_transaction_event', {
+          eventName: 'firestore_transaction_event',
+          body: { type: 'error', error: getWebError(e) },
+          appName,
+          listenerId: transactionId,
+        });
+      }
+    });
+  },
+};

package/lib/web/convert.js

@@ -0,0 +1,260 @@
+import {
+  DocumentReference,
+  Timestamp,
+  GeoPoint,
+  Bytes,
+  doc,
+  documentId,
+  serverTimestamp,
+  increment,
+  deleteField,
+  arrayUnion,
+  arrayRemove,
+} from '@react-native-firebase/app/lib/internal/web/firebaseFirestore';
+
+const INT_NAN = 0;
+const INT_NEGATIVE_INFINITY = 1;
+const INT_POSITIVE_INFINITY = 2;
+const INT_NULL = 3;
+const INT_DOCUMENTID = 4;
+const INT_BOOLEAN_TRUE = 5;
+const INT_BOOLEAN_FALSE = 6;
+const INT_DOUBLE = 7;
+const INT_STRING = 8;
+const INT_STRING_EMPTY = 9;
+const INT_ARRAY = 10;
+const INT_REFERENCE = 11;
+const INT_GEOPOINT = 12;
+const INT_TIMESTAMP = 13;
+const INT_BLOB = 14;
+const INT_FIELDVALUE = 15;
+const INT_OBJECT = 16;
+const INT_INTEGER = 17;
+const INT_NEGATIVE_ZERO = 18;
+const INT_UNKNOWN = -999;
+
+const TYPE = 'type';
+const KEY_PATH = 'path';
+const KEY_DATA = 'data';
+const KEY_OPTIONS = 'options';
+
+// Converts an object to a writeable object.
+export function objectToWriteable(object) {
+  const out = {};
+  for (const [key, value] of Object.entries(object)) {
+    out[key] = buildTypeMap(value);
+  }
+  return out;
+}
+
+// Converts an array of values to a writeable array.
+export function arrayToWriteable(array) {
+  return array.map(buildTypeMap);
+}
+
+// Converts a readable object into a plain js object.
+export function readableToObject(firestore, readableMap) {
+  const out = {};
+
+  for (const [key, value] of Object.entries(readableMap)) {
+    out[key] = parseTypeMap(firestore, value);
+  }
+
+  return out;
+}
+
+// Converts a readable array into a plain js array.
+export function readableToArray(firestore, readableArray) {
+  return readableArray.map(value => parseTypeMap(firestore, value));
+}
+
+// Converts a readable array of document batch data into a plain js array.
+export function parseDocumentBatches(firestore, readableArray) {
+  const out = [];
+
+  for (const map of readableArray) {
+    const write = {
+      [TYPE]: map[TYPE],
+      [KEY_PATH]: map[KEY_PATH],
+    };
+
+    if (KEY_DATA in map) {
+      write[KEY_DATA] = readableToObject(firestore, map[KEY_DATA]);
+    }
+
+    if (KEY_OPTIONS in map) {
+      write[KEY_OPTIONS] = map[KEY_OPTIONS];
+    }
+
+    out.push(write);
+  }
+
+  return out;
+}
+
+// Returns a typed array of a value.
+export function buildTypeMap(value) {
+  const out = [];
+  if (value === null) {
+    out.push(INT_NULL);
+    return out;
+  }
+
+  if (typeof value === 'boolean') {
+    if (value) out.push(INT_BOOLEAN_TRUE);
+    else out.push(INT_BOOLEAN_FALSE);
+    return out;
+  }
+
+  // Double
+  if (typeof value === 'number' && !Number.isInteger(value)) {
+    out.push(INT_DOUBLE);
+    out.push(value);
+    return out;
+  }
+
+  // Integer
+  if (typeof value === 'number' && Number.isInteger(value)) {
+    if (value == Number.NEGATIVE_INFINITY) {
+      out.push(INT_NEGATIVE_INFINITY);
+      return out;
+    }
+
+    if (value == Number.POSITIVE_INFINITY) {
+      out.push(INT_POSITIVE_INFINITY);
+      return out;
+    }
+
+    if (isNaN(value)) {
+      out.push(INT_NAN);
+      return out;
+    }
+
+    out.push(INT_DOUBLE);
+    out.push(value);
+    return out;
+  }
+
+  if (typeof value === 'string') {
+    if (value === '') {
+      out.push(INT_STRING_EMPTY);
+    } else {
+      out.push(INT_STRING);
+      out.push(value);
+    }
+    return out;
+  }
+
+  if (Array.isArray(value)) {
+    out.push(INT_ARRAY);
+    out.push(arrayToWriteable(value));
+    return out;
+  }
+
+  if (value instanceof DocumentReference) {
+    out.push(INT_REFERENCE);
+    out.push(value.path);
+    return out;
+  }
+
+  if (value instanceof Timestamp) {
+    out.push(INT_TIMESTAMP);
+    out.push([value.seconds, value.nanoseconds]);
+    return out;
+  }
+
+  if (value instanceof GeoPoint) {
+    out.push(INT_GEOPOINT);
+    out.push([value.latitude, value.longitude]);
+    return out;
+  }
+
+  if (value instanceof Bytes) {
+    out.push(INT_BLOB);
+    out.push(value.toBase64());
+    return out;
+  }
+
+  if (typeof value === 'object') {
+    out.push(INT_OBJECT);
+    out.push(objectToWriteable(value));
+    return out;
+  }
+
+  out.push(INT_UNKNOWN);
+  return out;
+}
+
+// Parses a typed array into a value.
+export function parseTypeMap(firestore, typedArray) {
+  const value = typedArray[0];
+
+  switch (value) {
+    case INT_NAN:
+      return NaN;
+    case INT_NEGATIVE_INFINITY:
+      return Number.NEGATIVE_INFINITY;
+    case INT_POSITIVE_INFINITY:
+      return Number.POSITIVE_INFINITY;
+    case INT_NULL:
+      return null;
+    case INT_DOCUMENTID:
+      return documentId();
+    case INT_BOOLEAN_TRUE:
+      return true;
+    case INT_BOOLEAN_FALSE:
+      return false;
+    case INT_NEGATIVE_ZERO:
+      return -0;
+    case INT_INTEGER:
+      return Number(typedArray[1]);
+    case INT_DOUBLE:
+      return Number(typedArray[1]);
+    case INT_STRING:
+      return String(typedArray[1]);
+    case INT_STRING_EMPTY:
+      return '';
+    case INT_ARRAY:
+      return readableToArray(firestore, typedArray[1]);
+    case INT_REFERENCE:
+      return doc(firestore, typedArray[1]);
+    case INT_GEOPOINT:
+      const [latitude, longitude] = typedArray[1];
+      return new GeoPoint(latitude, longitude);
+    case INT_TIMESTAMP:
+      const [seconds, nanoseconds] = typedArray[1];
+      return new Timestamp(seconds, nanoseconds);
+    case INT_BLOB:
+      return Bytes.fromBase64String(typedArray[1]);
+    case INT_FIELDVALUE:
+      const fieldValueArray = typedArray[1];
+      const fieldValueType = fieldValueArray[0];
+
+      if (fieldValueType === 'timestamp') {
+        return serverTimestamp();
+      }
+
+      if (fieldValueType === 'increment') {
+        return increment(fieldValueArray[1]);
+      }
+
+      if (fieldValueType === 'delete') {
+        return deleteField();
+      }
+
+      if (fieldValueType === 'array_union') {
+        const elements = readableToArray(firestore, fieldValueArray[1]);
+        return arrayUnion(...elements);
+      }
+
+      if (fieldValueType === 'array_remove') {
+        const elements = readableToArray(firestore, fieldValueArray[1]);
+        return arrayRemove(...elements);
+      }
+    case INT_OBJECT:
+      return readableToObject(firestore, typedArray[1]);
+    case INT_UNKNOWN:
+    default:
+      return null;
+  }
+}

package/lib/web/query.js

@@ -0,0 +1,112 @@
+import {
+  FieldPath,
+  query,
+  where,
+  orderBy,
+  limit,
+  limitToLast,
+  startAt,
+  startAfter,
+  endAt,
+  endBefore,
+  and,
+  or,
+} from '@react-native-firebase/app/lib/internal/web/firebaseFirestore';
+import { parseTypeMap, readableToArray } from './convert';
+
+export function buildQuery(queryInstance, filters, orders, options) {
+  // Apply filters
+  for (const filter of filters) {
+    queryInstance = query(queryInstance, getFilterConstraint(filter));
+  }
+
+  // Apply orders
+  for (const order of orders) {
+    const fieldPath =
+      typeof order.fieldPath === 'string' ? order.fieldPath : new FieldPath(...order.fieldPath);
+    const direction = order.direction === 'ASCENDING' ? 'asc' : 'desc';
+    queryInstance = query(queryInstance, orderBy(fieldPath, direction));
+  }
+
+  // Apply options
+  if ('limit' in options) {
+    queryInstance = query(queryInstance, limit(options.limit));
+  }
+
+  if ('limitToLast' in options) {
+    queryInstance = query(queryInstance, limitToLast(options.limitToLast));
+  }
+
+  if ('startAt' in options) {
+    const fieldList = readableToArray(queryInstance.firestore, options.startAt);
+    queryInstance = query(queryInstance, startAt(...fieldList));
+  }
+
+  if ('startAfter' in options) {
+    const fieldList = readableToArray(queryInstance.firestore, options.startAfter);
+    queryInstance = query(queryInstance, startAfter(...fieldList));
+  }
+
+  if ('endAt' in options) {
+    const fieldList = readableToArray(queryInstance.firestore, options.endAt);
+    queryInstance = query(queryInstance, endAt(...fieldList));
+  }
+
+  if ('endBefore' in options) {
+    const fieldList = readableToArray(queryInstance.firestore, options.endBefore);
+    queryInstance = query(queryInstance, endBefore(...fieldList));
+  }
+
+  return queryInstance;
+}
+
+function getFilterConstraint(filter) {
+  if ('fieldPath' in filter && filter.fieldPath) {
+    const fieldPath = Array.isArray(filter.fieldPath)
+      ? new FieldPath(...filter.fieldPath)
+      : new FieldPath(...filter.fieldPath._segments);
+    const operator = filter.operator;
+    const value = parseTypeMap(query.firestore, filter.value);
+
+    switch (operator) {
+      case 'EQUAL':
+        return where(fieldPath, '==', value);
+      case 'NOT_EQUAL':
+        return where(fieldPath, '!=', value);
+      case 'GREATER_THAN':
+        return where(fieldPath, '>', value);
+      case 'GREATER_THAN_OR_EQUAL':
+        return where(fieldPath, '>=', value);
+      case 'LESS_THAN':
+        return where(fieldPath, '<', value);
+      case 'LESS_THAN_OR_EQUAL':
+        return where(fieldPath, '<=', value);
+      case 'ARRAY_CONTAINS':
+        return where(fieldPath, 'array-contains', value);
+      case 'ARRAY_CONTAINS_ANY':
+        return where(fieldPath, 'array-contains-any', value);
+      case 'IN':
+        return where(fieldPath, 'in', value);
+      case 'NOT_IN':
+        return where(fieldPath, 'not-in', value);
+    }
+  } else if ('operator' in filter && 'queries' in filter) {
+    const constraints = [];
+
+    for (const constraint of filter.queries) {
+      constraints.push(getFilterConstraint(constraint));
+    }
+
+    if (filter.operator === 'AND') {
+      return and(...constraints);
+    }
+
+    if (filter.operator === 'OR') {
+      return or(...constraints);
+    }
+
+    throw new Error('Invalid filter operator');
+  }
+
+  throw new Error('Invaldi filter.');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-native-firebase/firestore",
-  "version": "20.1.0",
+  "version": "20.2.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - Cloud Firestore is a NoSQL cloud database to store and sync data between your React Native application and Firebase's database. The API matches the Firebase Web SDK whilst taking advantage of the native SDKs performance and offline capabilities.",
   "main": "lib/index.js",
@@ -27,10 +27,10 @@
     "firestore"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "20.1.0"
+    "@react-native-firebase/app": "20.2.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "99819b9cef23ac46080cbffe50cc85083305d04c"
+  "gitHead": "82c50138d07e673213cd8dee5ce9a2f9b5656649"
 }