@react-native-firebase/firestore 23.8.6 → 24.0.0

package/lib/web/{RNFBFirestoreModule.js → RNFBFirestoreModule.ts}

@@ -1,3 +1,20 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
 import {
   setLogLevel,
   connectFirestoreEmulator,
@@ -21,6 +38,11 @@ import {
   writeBatch,
   terminate,
 } from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestore';
+
+import type {
+  Firestore,
+  Transaction,
+} from '@react-native-firebase/app/dist/module/internal/web/firebaseFirestore';
 import {
   guard,
   getWebError,
@@ -28,60 +50,85 @@ import {
 } from '@react-native-firebase/app/dist/module/internal/web/utils';
 import { objectToWriteable, readableToObject, parseDocumentBatches } from './convert';
 import { buildQuery } from './query';
-
-function rejectWithCodeAndMessage(code, message) {
-  return Promise.reject(
-    getWebError({
-      code,
-      message,
-    }),
-  );
+import type { FilterSpec, OrderSpec, QueryOptions } from './query';
+import type {
+  FirestorePipelineExecuteOptionsInternal,
+  FirestorePipelineSnapshotInternal,
+  FirestorePipelineSerializedInternal,
+} from '../types/internal';
+import { executeWebSdkPipeline } from './pipelines/pipeline';
+
+function rejectWithCodeAndMessage(code: string, message: string): Promise<never> {
+  return Promise.reject(getWebError({ code, message } as Error & { code: string }));
 }
 
-// Converts a Firestore document snapshot to a plain object.
-function documentSnapshotToObject(snapshot) {
-  const exists = snapshot.exists();
+type DocumentSnapshotLike = {
+  exists(): boolean;
+  ref: { path: string };
+  data(): Record<string, unknown> | undefined;
+};
 
-  const out = {
-    metadata: [false, false], // lite SDK doesn't return metadata
+function documentSnapshotToObject(snapshot: DocumentSnapshotLike): {
+  path: string;
+  exists: boolean;
+  data?: unknown;
+  metadata: [boolean, boolean];
+} {
+  const exists = snapshot.exists();
+  const out: {
+    path: string;
+    exists: boolean;
+    data?: unknown;
+    metadata: [boolean, boolean];
+  } = {
+    metadata: [false, false],
     path: snapshot.ref.path,
     exists,
   };
-
   if (exists) {
-    out.data = objectToWriteable(snapshot.data() || {});
+    out.data = objectToWriteable(snapshot.data() ?? {});
   }
-
   return out;
 }
 
-// Converts a Firestore query snapshot to a plain object.
-function querySnapshotToObject(snapshot) {
+function querySnapshotToObject(snapshot: { docs: DocumentSnapshotLike[] }): {
+  source: string;
+  excludesMetadataChanges: boolean;
+  changes: unknown[];
+  metadata: [boolean, boolean];
+  documents: Array<ReturnType<typeof documentSnapshotToObject>>;
+} {
   return {
     source: 'get',
-    excludesMetadataChanges: true, // lite SDK doesn't return metadata changes
+    excludesMetadataChanges: true,
     changes: [],
-    metadata: [false, false], // lite SDK doesn't return metadata
+    metadata: [false, false],
     documents: snapshot.docs.map(documentSnapshotToObject),
   };
 }
 
-const emulatorForApp = {};
-const firestoreInstances = {};
-const appInstances = {};
-const transactionHandler = {};
-const transactionBuffer = {};
+const emulatorForApp: Record<string, { host: string; port: number }> = {};
+const firestoreInstances: Record<string, Firestore> = {};
+const appInstances: Record<string, ReturnType<typeof getApp>> = {};
+const transactionHandler: Record<number, Transaction> = {};
+const transactionBuffer: Record<number, TransactionCommand[]> = {};
+
+interface TransactionCommand {
+  path: string;
+  type: string;
+  data?: Record<string, unknown>;
+  options?: Record<string, unknown>;
+}
 
-function getCachedAppInstance(appName) {
+function getCachedAppInstance(appName: string): ReturnType<typeof getApp> {
   return (appInstances[appName] ??= getApp(appName));
 }
 
-function createFirestoreKey(appName, databaseId) {
+function createFirestoreKey(appName: string, databaseId: string): string {
   return `${appName}:${databaseId}`;
 }
 
-// Returns a cached Firestore instance.
-function getCachedFirestoreInstance(appName, databaseId) {
+function getCachedFirestoreInstance(appName: string, databaseId: string): Firestore {
   const firestoreKey = createFirestoreKey(appName, databaseId);
   let instance = firestoreInstances[firestoreKey];
   if (!instance) {
@@ -99,11 +146,7 @@ function getCachedFirestoreInstance(appName, databaseId) {
 }
 
 export default {
-  /**
-   * Sets the log level for Firestore.
-   * @param {string} logLevel - The log level.
-   */
-  async setLogLevel(logLevel) {
+  async setLogLevel(logLevel: string): Promise<void> {
     if (logLevel === 'debug' || logLevel === 'error') {
       setLogLevel(logLevel);
     } else {
@@ -111,77 +154,57 @@ export default {
     }
   },
 
-  loadBundle() {
+  loadBundle(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  clearPersistence() {
+  clearPersistence(): Promise<never> {
     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() {
+  async waitForPendingWrites(): Promise<null> {
     return null;
   },
 
-  disableNetwork() {
+  disableNetwork(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  enableNetwork() {
+  enableNetwork(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  addSnapshotsInSync() {
+  addSnapshotsInSync(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  removeSnapshotsInSync() {
+  removeSnapshotsInSync(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  /**
-   * Use the Firestore emulator.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @param {string} host - The emulator host.
-   * @param {number} port - The emulator port.
-   * @returns {Promise<null>} An empty promise.
-   */
-  useEmulator(appName, databaseId, host, port) {
-    return guard(async () => {
+  useEmulator(appName: string, databaseId: string, host: string, port: number): Promise<null> {
+    return guard(async (): Promise<null> => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       connectFirestoreEmulator(firestore, host, port);
       const firestoreKey = createFirestoreKey(appName, databaseId);
       emulatorForApp[firestoreKey] = { host, port };
+      return null;
     });
   },
 
-  /**
-   * Initializes a Firestore instance with settings.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @param {object} settings - The Firestore settings.
-   * @returns {Promise<null>} An empty promise.
-   */
-  settings(appName, databaseId, settings) {
-    return guard(() => {
-      const instance = initializeFirestore(getCachedAppInstance(appName), settings, databaseId);
+  settings(appName: string, databaseId: string, settings: object): Promise<null> {
+    return guard(async (): Promise<null> => {
+      const instance = initializeFirestore(
+        getCachedAppInstance(appName),
+        settings as Parameters<typeof initializeFirestore>[1],
+        databaseId,
+      );
       firestoreInstances[appName] = instance;
+      return null;
     });
   },
 
-  /**
-   * Terminates a Firestore instance.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @returns {Promise<null>} An empty promise.
-   */
-  terminate(appName, databaseId) {
+  terminate(appName: string, databaseId: string): Promise<null> {
     return guard(async () => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       await terminate(firestore);
@@ -189,146 +212,147 @@ export default {
     });
   },
 
-  // Collection
-  namedQueryOnSnapshot() {
+  namedQueryOnSnapshot(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  collectionOnSnapshot() {
+  collectionOnSnapshot(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  collectionOffSnapshot() {
+  collectionOffSnapshot(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  namedQueryGet() {
+  namedQueryGet(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  /**
-   * Get a collection count from Firestore.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @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, databaseId, path, type, filters, orders, options) {
+  collectionCount(
+    appName: string,
+    databaseId: string,
+    path: string,
+    type: string,
+    filters: FilterSpec[],
+    orders: OrderSpec[],
+    options: QueryOptions,
+  ): Promise<{ count: number }> {
     return guard(async () => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       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,
-      };
+      return { count: snapshot.data().count };
     });
   },
 
-  aggregateQuery(appName, databaseId, path, type, filters, orders, options, aggregateQueries) {
+  aggregateQuery(
+    appName: string,
+    databaseId: string,
+    path: string,
+    type: string,
+    filters: FilterSpec[],
+    orders: OrderSpec[],
+    options: QueryOptions,
+    aggregateQueries: Array<{ aggregateType: string; field?: unknown; key: string }>,
+  ): Promise<Record<string, unknown>> {
     return guard(async () => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       const queryRef =
         type === 'collectionGroup' ? collectionGroup(firestore, path) : collection(firestore, path);
       const query = buildQuery(queryRef, filters, orders, options);
-      const aggregateSpec = {};
+      const aggregateSpec: Record<string, unknown> = {};
 
       for (let i = 0; i < aggregateQueries.length; i++) {
-        const aggregateQuery = aggregateQueries[i];
+        const aggregateQuery = aggregateQueries[i]!;
         const { aggregateType, field, key } = aggregateQuery;
-
         switch (aggregateType) {
           case 'count':
             aggregateSpec[key] = count();
             break;
-          case 'average':
-            aggregateSpec[key] = average(field);
+          case 'avg':
+            aggregateSpec[key] = average(field as Parameters<typeof average>[0]);
             break;
           case 'sum':
-            aggregateSpec[key] = sum(field);
+            aggregateSpec[key] = sum(field as Parameters<typeof sum>[0]);
             break;
         }
       }
-      const result = await getAggregate(query, aggregateSpec);
-
+      const result = await getAggregate(query, aggregateSpec as Parameters<typeof getAggregate>[1]);
       const data = result.data();
-      const response = {};
+      const response: Record<string, unknown> = {};
       for (let i = 0; i < aggregateQueries.length; i++) {
-        const aggregateQuery = aggregateQueries[i];
-        const { key } = aggregateQuery;
-        response[key] = data[key];
+        const aggregateQuery = aggregateQueries[i]!;
+        response[aggregateQuery.key] = data[aggregateQuery.key];
       }
-
       return response;
     });
   },
 
-  /**
-   * Get a collection from Firestore.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @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, databaseId, path, type, filters, orders, options, getOptions) {
-    if (getOptions && getOptions.source === 'cache') {
+  pipelineExecute(
+    appName: string,
+    databaseId: string,
+    pipeline: FirestorePipelineSerializedInternal,
+    options?: FirestorePipelineExecuteOptionsInternal,
+  ): Promise<FirestorePipelineSnapshotInternal> {
+    return guard(async () => {
+      const firestore = getCachedFirestoreInstance(appName, databaseId);
+      return executeWebSdkPipeline(firestore, pipeline, options);
+    });
+  },
+
+  collectionGet(
+    appName: string,
+    databaseId: string,
+    path: string,
+    type: string,
+    filters: FilterSpec[],
+    orders: OrderSpec[],
+    options: QueryOptions,
+    getOptions?: { source?: string },
+  ): Promise<ReturnType<typeof querySnapshotToObject>> {
+    if (getOptions?.source === 'cache') {
       return rejectWithCodeAndMessage(
         'unsupported',
         'The source cache is not supported in the lite SDK.',
       );
     }
-
     return guard(async () => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       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);
+      return querySnapshotToObject(snapshot as { docs: DocumentSnapshotLike[] });
     });
   },
 
-  // Document
-  documentOnSnapshot() {
+  documentOnSnapshot(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  documentOffSnapshot() {
+  documentOffSnapshot(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  persistenceCacheIndexManager() {
+  persistenceCacheIndexManager(): Promise<never> {
     return rejectWithCodeAndMessage('unsupported', 'Not supported in the lite SDK.');
   },
 
-  /**
-   * Get a document from Firestore.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @param {string} path - The document path.
-   * @param {object} getOptions - The get options.
-   * @returns {Promise<object>} The document object.
-   */
-  documentGet(appName, databaseId, path, getOptions) {
+  documentGet(
+    appName: string,
+    databaseId: string,
+    path: string,
+    getOptions?: { source?: string },
+  ): Promise<ReturnType<typeof documentSnapshotToObject>> {
     return guard(async () => {
-      if (getOptions && getOptions.source === 'cache') {
+      if (getOptions?.source === 'cache') {
         return rejectWithCodeAndMessage(
           'unsupported',
           'The source cache is not supported in the lite SDK.',
         );
       }
-
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       const ref = doc(firestore, path);
       const snapshot = await getDoc(ref);
@@ -336,14 +360,7 @@ export default {
     });
   },
 
-  /**
-   * Delete a document from Firestore.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @param {string} path - The document path.
-   * @returns {Promise<null>} An empty promise.
-   */
-  documentDelete(appName, databaseId, path) {
+  documentDelete(appName: string, databaseId: string, path: string): Promise<null> {
     return guard(async () => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       const ref = doc(firestore, path);
@@ -352,38 +369,32 @@ export default {
     });
   },
 
-  /**
-   * Set a document in Firestore.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @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, databaseId, path, data, options) {
+  documentSet(
+    appName: string,
+    databaseId: string,
+    path: string,
+    data: Record<string, unknown>,
+    options: Record<string, unknown>,
+  ): Promise<void> {
     return guard(async () => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       const ref = doc(firestore, path);
-      const setOptions = {};
-      if ('merge' in options) {
+      const setOptions: Record<string, unknown> = {};
+      if (options && 'merge' in options) {
         setOptions.merge = options.merge;
-      } else if ('mergeFields' in options) {
+      } else if (options && '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} databaseId - The database ID.
-   * @param {string} path - The document path.
-   * @param {object} data - The document data.
-   * @returns {Promise<null>} An empty promise.
-   */
-  documentUpdate(appName, databaseId, path, data) {
+  documentUpdate(
+    appName: string,
+    databaseId: string,
+    path: string,
+    data: Record<string, unknown>,
+  ): Promise<void> {
     return guard(async () => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       const ref = doc(firestore, path);
@@ -391,13 +402,11 @@ export default {
     });
   },
 
-  /**
-   * Batch write documents in Firestore.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @param {object[]} writes - The document writes in write batches format.
-   */
-  documentBatch(appName, databaseId, writes) {
+  documentBatch(
+    appName: string,
+    databaseId: string,
+    writes: Array<Record<string, unknown>>,
+  ): Promise<void> {
     return guard(async () => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
       const batch = writeBatch(firestore);
@@ -412,87 +421,67 @@ export default {
             batch.delete(ref);
             break;
           case 'UPDATE':
-            batch.update(ref, parsed.data);
+            batch.update(ref, parsed.data!);
             break;
-          case 'SET':
-            const options = parsed.options;
-            const setOptions = {};
+          case 'SET': {
+            const options = parsed.options ?? {};
+            const setOptions: Record<string, unknown> = {};
             if ('merge' in options) {
               setOptions.merge = options.merge;
             } else if ('mergeFields' in options) {
               setOptions.mergeFields = options.mergeFields;
             }
-            batch.set(ref, parsed.data, setOptions);
+            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} databaseId - The database ID.
-   * @param {string} transactionId - The transaction id.
-   * @param {string} path - The document path.
-   * @returns {Promise<object>} The document object.
-   */
-  transactionGetDocument(appName, databaseId, transactionId, path) {
+  transactionGetDocument(
+    appName: string,
+    databaseId: string,
+    transactionId: number,
+    path: string,
+  ): Promise<ReturnType<typeof documentSnapshotToObject>> {
     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, databaseId);
       const docRef = doc(firestore, path);
-      const tsx = transactionHandler[transactionId];
+      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} databaseId - The database ID.
-   * @param {string} transactionId - The transaction id.
-   */
-  transactionDispose(_appName, _databaseId, transactionId) {
-    // There's no abort method in the JS SDK, so we just remove the transaction handler.
+  transactionDispose(_appName: string, _databaseId: string, transactionId: number): void {
     delete transactionHandler[transactionId];
   },
 
-  /**
-   * Applies a buffer of commands to a Firestore transaction.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @param {string} transactionId - The transaction id.
-   * @param {object[]} commandBuffer - The readable array of buffer commands.
-   */
-  transactionApplyBuffer(_appName, _databaseId, transactionId, commandBuffer) {
+  transactionApplyBuffer(
+    _appName: string,
+    _databaseId: string,
+    transactionId: number,
+    commandBuffer: TransactionCommand[],
+  ): void {
     if (transactionHandler[transactionId]) {
       transactionBuffer[transactionId] = commandBuffer;
     }
   },
 
-  /**
-   * Begins a Firestore transaction.
-   * @param {string} appName - The app name.
-   * @param {string} databaseId - The database ID.
-   * @param {string} transactionId - The transaction id.
-   * @returns {Promise<null>} An empty promise.
-   */
-  transactionBegin(appName, databaseId, transactionId) {
+  transactionBegin(appName: string, databaseId: string, transactionId: number): Promise<void> {
     return guard(async () => {
       const firestore = getCachedFirestoreInstance(appName, databaseId);
 
       try {
-        await runTransaction(firestore, async tsx => {
+        await runTransaction(firestore, async (tsx: Transaction) => {
           transactionHandler[transactionId] = tsx;
 
           emitEvent('firestore_transaction_event', {
@@ -503,42 +492,41 @@ export default {
             listenerId: transactionId,
           });
 
-          function getBuffer() {
-            return transactionBuffer[transactionId];
-          }
+          const getBuffer = (): TransactionCommand[] | undefined =>
+            transactionBuffer[transactionId];
 
-          // Wait for and get the stored buffer array for the transaction.
-          const buffer = await new Promise(resolve => {
+          const buffer = await new Promise<TransactionCommand[]>(resolve => {
             const interval = setInterval(() => {
-              const buffer = getBuffer();
-              if (buffer) {
+              const b = getBuffer();
+              if (b) {
                 clearInterval(interval);
-                resolve(buffer);
+                resolve(b);
               }
             }, 100);
           });
 
           for (const serialized of buffer) {
-            const { path, type, data } = serialized;
-            const docRef = doc(firestore, path);
+            const { path: docPath, type, data } = serialized;
+            const docRef = doc(firestore, docPath);
 
             switch (type) {
               case 'DELETE':
                 tsx.delete(docRef);
                 break;
               case 'UPDATE':
-                tsx.update(docRef, readableToObject(firestore, data));
+                tsx.update(docRef, readableToObject(firestore, data ?? {}));
                 break;
-              case 'SET':
-                const options = serialized.options;
-                const setOptions = {};
+              case 'SET': {
+                const options = serialized.options ?? {};
+                const setOptions: Record<string, unknown> = {};
                 if ('merge' in options) {
                   setOptions.merge = options.merge;
                 } else if ('mergeFields' in options) {
                   setOptions.mergeFields = options.mergeFields;
                 }
-                tsx.set(docRef, readableToObject(firestore, data), setOptions);
+                tsx.set(docRef, readableToObject(firestore, data ?? {}), setOptions);
                 break;
+              }
             }
           }
         });
@@ -553,7 +541,7 @@ export default {
       } catch (e) {
         emitEvent('firestore_transaction_event', {
           eventName: 'firestore_transaction_event',
-          body: { type: 'error', error: getWebError(e) },
+          body: { type: 'error', error: getWebError(e as Error) },
           appName,
           databaseId,
           listenerId: transactionId,