@react-native-firebase/firestore 23.8.8 → 24.0.0

package/lib/{index.js → namespaced.ts}

@@ -16,32 +16,39 @@
  */
 
 import {
+  createDeprecationProxy,
+  isAndroid,
   isBoolean,
   isFunction,
   isNumber,
   isObject,
   isString,
   isUndefined,
-  isAndroid,
-  createDeprecationProxy,
+  isOther,
 } from '@react-native-firebase/app/dist/module/common';
-import { setReactNativeModule } from '@react-native-firebase/app/dist/module/internal/nativeModule';
 import {
   createModuleNamespace,
   FirebaseModule,
   getFirebaseRoot,
+  type ModuleConfig,
 } from '@react-native-firebase/app/dist/module/internal';
-import FirestoreCollectionReference from './FirestoreCollectionReference';
-import FirestoreDocumentReference from './FirestoreDocumentReference';
+import { setReactNativeModule } from '@react-native-firebase/app/dist/module/internal/nativeModule';
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
+import CollectionReference from './FirestoreCollectionReference';
+import DocumentReference from './FirestoreDocumentReference';
 import FirestorePath from './FirestorePath';
-import FirestoreQuery from './FirestoreQuery';
-import FirestoreQueryModifiers from './FirestoreQueryModifiers';
+import FirestorePersistentCacheIndexManager from './FirestorePersistentCacheIndexManager';
+import Query from './FirestoreQuery';
+import QueryModifiers from './FirestoreQueryModifiers';
 import FirestoreStatics from './FirestoreStatics';
 import FirestoreTransactionHandler from './FirestoreTransactionHandler';
 import FirestoreWriteBatch from './FirestoreWriteBatch';
-import version from './version';
+import { LoadBundleTask } from './LoadBundleTask';
+import type { LoadBundleTaskProgress } from './types/firestore';
+import { version } from './version';
+import type { FirebaseFirestoreTypes } from './types/namespaced';
+import type { FirestoreInternal } from './types/internal';
 import fallBackModule from './web/RNFBFirestoreModule';
-import FirestorePersistentCacheIndexManager from './FirestorePersistentCacheIndexManager';
 
 // react-native at least through 0.77 does not correctly support URL.host, which
 // is needed by firebase-js-sdk. It appears that in 0.80+ it is supported, so this
@@ -51,49 +58,76 @@ import 'react-native-url-polyfill/auto';
 
 const namespace = 'firestore';
 
-const nativeModuleName = [
+const nativeModuleNames = [
   'RNFBFirestoreModule',
   'RNFBFirestoreCollectionModule',
   'RNFBFirestoreDocumentModule',
   'RNFBFirestoreTransactionModule',
-];
+] as const;
 
 const nativeEvents = [
   'firestore_collection_sync_event',
   'firestore_document_sync_event',
   'firestore_transaction_event',
   'firestore_snapshots_in_sync_event',
-];
-
-class FirebaseFirestoreModule extends FirebaseModule {
-  constructor(app, config, databaseId) {
+] as const;
+
+type FirestoreModuleSettingsState = {
+  ignoreUndefinedProperties: boolean;
+  persistence: boolean;
+};
+
+/** Sync event payload from emitter when fanning out collection/document/snapshots-in-sync events. */
+type FirestoreSyncEventWithListenerId = { listenerId: string | number };
+
+class FirebaseFirestoreModule extends FirebaseModule<'RNFBFirestoreModule'> {
+  type = 'firestore' as const;
+  _referencePath: FirestorePath;
+  _transactionHandler: FirestoreTransactionHandler;
+  _settings: FirestoreModuleSettingsState;
+  _databaseId: string | null;
+
+  constructor(
+    app: ReactNativeFirebase.FirebaseAppBase,
+    config: ModuleConfig,
+    databaseId?: string | null,
+  ) {
     super(app, config);
+
     if (isString(databaseId) || databaseId === undefined) {
-      this._customUrlOrRegion = databaseId || '(default)';
-    } else if (!isString(databaseId)) {
+      this._databaseId = databaseId || '(default)';
+      // Kept for backwards compatibility with the modular API
+      this._customUrlOrRegion = this._databaseId;
+    } else {
       throw new Error('firebase.app().firestore(*) database ID must be a string');
     }
+
     this._referencePath = new FirestorePath();
-    this._transactionHandler = new FirestoreTransactionHandler(this);
+    this._transactionHandler = new FirestoreTransactionHandler(
+      this as unknown as FirestoreInternal,
+    );
 
     // Fan out native events
     this.emitter.addListener(this.eventNameForApp('firestore_collection_sync_event'), event => {
+      const syncEvent = event as FirestoreSyncEventWithListenerId;
       this.emitter.emit(
-        this.eventNameForApp(`firestore_collection_sync_event:${event.listenerId}`),
+        this.eventNameForApp(`firestore_collection_sync_event:${syncEvent.listenerId}`),
         event,
       );
     });
 
     this.emitter.addListener(this.eventNameForApp('firestore_document_sync_event'), event => {
+      const syncEvent = event as FirestoreSyncEventWithListenerId;
       this.emitter.emit(
-        this.eventNameForApp(`firestore_document_sync_event:${event.listenerId}`),
+        this.eventNameForApp(`firestore_document_sync_event:${syncEvent.listenerId}`),
         event,
       );
     });
 
     this.emitter.addListener(this.eventNameForApp('firestore_snapshots_in_sync_event'), event => {
+      const syncEvent = event as FirestoreSyncEventWithListenerId;
       this.emitter.emit(
-        this.eventNameForApp(`firestore_snapshots_in_sync_event:${event.listenerId}`),
+        this.eventNameForApp(`firestore_snapshots_in_sync_event:${syncEvent.listenerId}`),
         event,
       );
     });
@@ -104,20 +138,28 @@ class FirebaseFirestoreModule extends FirebaseModule {
     };
   }
 
-  get customUrlOrRegion() {
-    return this._customUrlOrRegion;
+  toJSON(): object {
+    return {
+      app: this.app,
+      databaseId: this._databaseId,
+      settings: this._settings,
+    };
+  }
+  // Kept for backwards compatibility with the modular API
+  get customUrlOrRegion(): string {
+    return this._databaseId as string;
   }
 
-  // We override the FirebaseModule's `eventNameForApp()` method to include the customUrlOrRegion
-  eventNameForApp(...args) {
-    return `${this.app.name}-${this._customUrlOrRegion}-${args.join('-')}`;
+  // We override the FirebaseModule's eventNameForApp() method to include the customUrlOrRegion
+  eventNameForApp(...args: Array<string | number>): string {
+    return `${this.app.name}-${this._databaseId}-${args.join('-')}`;
   }
 
-  batch() {
-    return new FirestoreWriteBatch(this);
+  batch(): FirestoreWriteBatch {
+    return new FirestoreWriteBatch(this as unknown as FirestoreInternal);
   }
 
-  loadBundle(bundle) {
+  loadBundle(bundle: string): LoadBundleTask {
     if (!isString(bundle)) {
       throw new Error("firebase.firestore().loadBundle(*) 'bundle' must be a string value.");
     }
@@ -126,10 +168,15 @@ class FirebaseFirestoreModule extends FirebaseModule {
       throw new Error("firebase.firestore().loadBundle(*) 'bundle' must be a non-empty string.");
     }
 
-    return this.native.loadBundle(bundle);
+    const task = new LoadBundleTask();
+    this.native
+      .loadBundle(bundle)
+      .then((progress: LoadBundleTaskProgress) => task._completeWith(progress))
+      .catch((error: Error) => task._failWith(error));
+    return task;
   }
 
-  namedQuery(queryName) {
+  namedQuery(queryName: string): Query | null {
     if (!isString(queryName)) {
       throw new Error("firebase.firestore().namedQuery(*) 'queryName' must be a string value.");
     }
@@ -138,43 +185,52 @@ class FirebaseFirestoreModule extends FirebaseModule {
       throw new Error("firebase.firestore().namedQuery(*) 'queryName' must be a non-empty string.");
     }
 
-    return new FirestoreQuery(this, this._referencePath, new FirestoreQueryModifiers(), queryName);
+    return new Query(
+      this as unknown as FirestoreInternal,
+      this._referencePath,
+      new QueryModifiers(),
+      queryName,
+    );
   }
 
-  async clearPersistence() {
+  async clearPersistence(): Promise<void> {
     await this.native.clearPersistence();
   }
 
-  async waitForPendingWrites() {
+  async waitForPendingWrites(): Promise<void> {
     await this.native.waitForPendingWrites();
   }
 
-  async terminate() {
+  async terminate(): Promise<void> {
     await this.native.terminate();
   }
 
-  useEmulator(host, port) {
+  useEmulator(host: string, port: number): void {
     if (!host || !isString(host) || !port || !isNumber(port)) {
       throw new Error('firebase.firestore().useEmulator() takes a non-empty host and port');
     }
-    let _host = host;
+
+    let mappedHost = host;
     const androidBypassEmulatorUrlRemap =
       typeof this.firebaseJson.android_bypass_emulator_url_remap === 'boolean' &&
       this.firebaseJson.android_bypass_emulator_url_remap;
-    if (!androidBypassEmulatorUrlRemap && isAndroid && _host) {
-      if (_host === 'localhost' || _host === '127.0.0.1') {
-        _host = '10.0.2.2';
+
+    if (!androidBypassEmulatorUrlRemap && isAndroid && mappedHost) {
+      if (mappedHost === 'localhost' || mappedHost === '127.0.0.1') {
+        mappedHost = '10.0.2.2';
         // eslint-disable-next-line no-console
         console.log(
           'Mapping firestore host to "10.0.2.2" for android emulators. Use real IP on real devices. You can bypass this behaviour with "android_bypass_emulator_url_remap" flag.',
         );
       }
     }
-    this.native.useEmulator(_host, port);
-    return [_host, port]; // undocumented return, just used to unit test android host remapping
+
+    this.native.useEmulator(mappedHost, port);
+    // @ts-ignore - undocumented return, just used to unit test android host remapping
+    return [mappedHost, port];
   }
 
-  collection(collectionPath) {
+  collection(collectionPath: string): CollectionReference {
     if (!isString(collectionPath)) {
       throw new Error(
         "firebase.firestore().collection(*) 'collectionPath' must be a string value.",
@@ -195,10 +251,12 @@ class FirebaseFirestoreModule extends FirebaseModule {
       );
     }
 
-    return createDeprecationProxy(new FirestoreCollectionReference(this, path));
+    return createDeprecationProxy(
+      new CollectionReference(this as unknown as FirestoreInternal, path),
+    );
   }
 
-  collectionGroup(collectionId) {
+  collectionGroup(collectionId: string): Query {
     if (!isString(collectionId)) {
       throw new Error(
         "firebase.firestore().collectionGroup(*) 'collectionId' must be a string value.",
@@ -211,27 +269,27 @@ class FirebaseFirestoreModule extends FirebaseModule {
       );
     }
 
-    if (collectionId.indexOf('/') >= 0) {
+    if (collectionId.includes('/')) {
       throw new Error(
         "firebase.firestore().collectionGroup(*) 'collectionId' must not contain '/'.",
       );
     }
 
     return createDeprecationProxy(
-      new FirestoreQuery(
-        this,
+      new Query(
+        this as unknown as FirestoreInternal,
         this._referencePath.child(collectionId),
-        new FirestoreQueryModifiers().asCollectionGroupQuery(),
+        new QueryModifiers().asCollectionGroupQuery(),
         undefined,
       ),
     );
   }
 
-  async disableNetwork() {
+  async disableNetwork(): Promise<void> {
     await this.native.disableNetwork();
   }
 
-  doc(documentPath) {
+  doc(documentPath: string): DocumentReference {
     if (!isString(documentPath)) {
       throw new Error("firebase.firestore().doc(*) 'documentPath' must be a string value.");
     }
@@ -246,14 +304,16 @@ class FirebaseFirestoreModule extends FirebaseModule {
       throw new Error("firebase.firestore().doc(*) 'documentPath' must point to a document.");
     }
 
-    return createDeprecationProxy(new FirestoreDocumentReference(this, path));
+    return createDeprecationProxy(
+      new DocumentReference(this as unknown as FirestoreInternal, path),
+    );
   }
 
-  async enableNetwork() {
+  async enableNetwork(): Promise<void> {
     await this.native.enableNetwork();
   }
 
-  runTransaction(updateFunction) {
+  runTransaction(updateFunction: (transaction: unknown) => Promise<unknown>): Promise<unknown> {
     if (!isFunction(updateFunction)) {
       return Promise.reject(
         new Error("firebase.firestore().runTransaction(*) 'updateFunction' must be a function."),
@@ -263,7 +323,7 @@ class FirebaseFirestoreModule extends FirebaseModule {
     return this._transactionHandler._add(updateFunction);
   }
 
-  settings(settings) {
+  settings(settings: Record<string, unknown>): Promise<void> {
     if (!isObject(settings)) {
       return Promise.reject(
         new Error("firebase.firestore().settings(*) 'settings' must be an object."),
@@ -271,18 +331,20 @@ class FirebaseFirestoreModule extends FirebaseModule {
     }
 
     const keys = Object.keys(settings);
-
     const opts = [
       'cacheSizeBytes',
       'host',
+      'localCache',
       'persistence',
       'ssl',
       'ignoreUndefinedProperties',
       'serverTimestampBehavior',
+      'experimentalForceLongPolling',
+      'experimentalAutoDetectLongPolling',
+      'experimentalLongPollingOptions',
     ];
 
-    for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
+    for (const key of keys) {
       if (!opts.includes(key)) {
         return Promise.reject(
           new Error(
@@ -303,7 +365,7 @@ class FirebaseFirestoreModule extends FirebaseModule {
 
       if (
         settings.cacheSizeBytes !== FirestoreStatics.CACHE_SIZE_UNLIMITED &&
-        settings.cacheSizeBytes < 1048576 // 1MB
+        settings.cacheSizeBytes < 1048576
       ) {
         return Promise.reject(
           new Error(
@@ -329,15 +391,16 @@ class FirebaseFirestoreModule extends FirebaseModule {
       }
 
       if (isAndroid) {
-        if (settings.host.startsWith('localhost')) {
-          settings.host = settings.host.replace('localhost', '10.0.2.2');
+        const host = settings.host as string;
+        if (host.startsWith('localhost')) {
+          settings.host = host.replace('localhost', '10.0.2.2');
           // eslint-disable-next-line no-console
           console.log(
             'Mapping firestore host "localhost" to "10.0.2.2" for android emulators. Use real IP on real devices.',
           );
         }
-        if (settings.host.startsWith('127.0.0.1')) {
-          settings.host = settings.host.replace('127.0.0.1', '10.0.2.2');
+        if ((settings.host as string).startsWith('127.0.0.1')) {
+          settings.host = (settings.host as string).replace('127.0.0.1', '10.0.2.2');
           // eslint-disable-next-line no-console
           console.log(
             'Mapping firestore host "127.0.0.1" to "10.0.2.2" for android emulators. Use real IP on real devices.',
@@ -360,7 +423,7 @@ class FirebaseFirestoreModule extends FirebaseModule {
 
     if (
       !isUndefined(settings.serverTimestampBehavior) &&
-      !['estimate', 'previous', 'none'].includes(settings.serverTimestampBehavior)
+      !['estimate', 'previous', 'none'].includes(settings.serverTimestampBehavior as string)
     ) {
       return Promise.reject(
         new Error(
@@ -376,10 +439,8 @@ class FirebaseFirestoreModule extends FirebaseModule {
             "firebase.firestore().settings(*) 'settings.ignoreUndefinedProperties' must be a boolean value.",
           ),
         );
-      } else {
-        this._settings.ignoreUndefinedProperties = settings.ignoreUndefinedProperties;
       }
-
+      this._settings.ignoreUndefinedProperties = settings.ignoreUndefinedProperties;
       delete settings.ignoreUndefinedProperties;
     }
 
@@ -388,41 +449,70 @@ class FirebaseFirestoreModule extends FirebaseModule {
       this._settings.persistence = false;
     }
 
-    return this.native.settings(settings);
+    const settingsToApply = isOther ? settings : { ...settings };
+
+    if (!isOther) {
+      delete settingsToApply.localCache;
+      delete settingsToApply.experimentalForceLongPolling;
+      delete settingsToApply.experimentalAutoDetectLongPolling;
+      delete settingsToApply.experimentalLongPollingOptions;
+    }
+
+    return this.native.settings(settingsToApply);
   }
 
-  persistentCacheIndexManager() {
+  persistentCacheIndexManager(): FirestorePersistentCacheIndexManager | null {
     if (this._settings.persistence === false) {
       return null;
     }
-    return createDeprecationProxy(new FirestorePersistentCacheIndexManager(this));
+    return createDeprecationProxy(
+      new FirestorePersistentCacheIndexManager(this as unknown as FirestoreInternal),
+    );
   }
 }
 
 // import { SDK_VERSION } from '@react-native-firebase/firestore';
 export const SDK_VERSION = version;
 
-export * from './modular';
-
-// import firestore from '@react-native-firebase/firestore';
-// firestore().X(...);
-export default createModuleNamespace({
+const firestoreNamespace = createModuleNamespace({
   statics: FirestoreStatics,
   version,
   namespace,
-  nativeModuleName,
-  nativeEvents,
+  nativeModuleName: [...nativeModuleNames],
+  nativeEvents: [...nativeEvents],
   hasMultiAppSupport: true,
   hasCustomUrlOrRegionSupport: true,
   ModuleClass: FirebaseFirestoreModule,
 });
 
+type FirestoreNamespace = ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<
+  FirebaseFirestoreTypes.Module,
+  FirebaseFirestoreTypes.Statics
+> & {
+  firestore: ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<
+    FirebaseFirestoreTypes.Module,
+    FirebaseFirestoreTypes.Statics
+  >;
+  firebase: ReactNativeFirebase.Module;
+  app(name?: string): ReactNativeFirebase.FirebaseApp;
+};
+
+// import firestore from '@react-native-firebase/firestore';
+// firestore().X(...);
+export default firestoreNamespace as unknown as FirestoreNamespace;
+
 // import firestore, { firebase } from '@react-native-firebase/firestore';
 // firestore().X(...);
 // firebase.firestore().X(...);
-export const firebase = getFirebaseRoot();
+export const firebase =
+  getFirebaseRoot() as unknown as ReactNativeFirebase.FirebaseNamespacedExport<
+    'firestore',
+    FirebaseFirestoreTypes.Module,
+    FirebaseFirestoreTypes.Statics,
+    true
+  >;
 
 // Register the interop module for non-native platforms.
-for (let i = 0; i < nativeModuleName.length; i++) {
-  setReactNativeModule(nativeModuleName[i], fallBackModule);
+for (const moduleName of nativeModuleNames) {
+  setReactNativeModule(moduleName, fallBackModule);
 }