react-query-firebase 1.3.2 → 2.0.0-rc1

package/src/firestore/useCollectionReference.ts

@@ -1,10 +1,14 @@
-import { collection, CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+import { collection, FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 
 import { useMemo } from "react";
 import { useFirestore } from "./useFirestore";
 
-export type UseCollectionReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+export type UseCollectionReferenceOptions<
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+> = {
+    reference?:
+        | FirebaseFirestoreTypes.CollectionReference<AppModelType>
+        | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
     path: string;
     pathSegments?: string[];
 };
@@ -14,24 +18,24 @@ export type UseCollectionReferenceOptions<AppModelType, DbModelType extends Docu
  *
  * This hook utilizes useMemo for optimization, ensuring the collection reference is recalculated only when its dependencies change.
  *
- * @param {UseCollectionReferenceOptions<AppModelType, DbModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
+ * @param {UseCollectionReferenceOptions<AppModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
  * @param {string} options.path - The base path for the collection.
  * @param {FirestoreReference} options.reference - An optional Firestore reference object that should be of type "collection".
  * @param {string[]} options.pathSegments - Additional path segments to append to the base path.
  * @returns {CollectionReference} A Firestore collection reference constructed using the specified path, reference, and path segments.
  */
-export const useCollectionReference = <AppModelType, DbModelType extends DocumentData = DocumentData>({
+export const useCollectionReference = <
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+>({
     path,
     reference,
     pathSegments
-}: UseCollectionReferenceOptions<AppModelType, DbModelType>) => {
+}: UseCollectionReferenceOptions<AppModelType>) => {
     const db = useFirestore();
 
     return useMemo(() => {
         return !reference
             ? collection(db, path || "", ...(pathSegments || []))
-            : reference.type === "collection"
-              ? collection(reference, path, ...(pathSegments || []))
-              : collection(reference, path, ...(pathSegments || []));
+            : collection(reference, path, ...(pathSegments || []));
     }, [path, reference?.path, pathSegments]);
 };

package/src/firestore/useCompositeFilter.ts

@@ -1,27 +1,18 @@
-import {
-    DocumentData,
-    QueryCompositeFilterConstraint,
-    QueryFilterConstraint,
-    WhereFilterOp,
-    and,
-    documentId,
-    or,
-    where
-} from "firebase/firestore";
+import firebase, { FirebaseFirestoreTypes, and, or, where } from "@react-native-firebase/firestore";
 import { useMemo } from "react";
 
-type CompositeFilterDocumentData = DocumentData;
+type CompositeFilterDocumentData = FirebaseFirestoreTypes.DocumentData;
 
 export type QueryElement<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> =
-    Partial<QueryCompositeFilterConstraint> & {
+    Partial<FirebaseFirestoreTypes.QueryCompositeFilterConstraint> & {
         children?: QueryElement[];
         field?: keyof (DbModelType & { documentId?: string[] });
         value?: DbModelType[keyof DbModelType];
-        op?: WhereFilterOp;
+        op?: FirebaseFirestoreTypes.WhereFilterOp;
     };
 
 export type CompositeFilter<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> =
-    QueryCompositeFilterConstraint & {
+    FirebaseFirestoreTypes.QueryCompositeFilterConstraint & {
         children: QueryElement<DbModelType & { documentId?: string[] }>[];
     };
 
@@ -34,26 +25,31 @@ export type UseCompositeFilter<DbModelType extends CompositeFilterDocumentData =
  * It recursively builds query constraints using logical "or" or "and" operators.
  *
  * @param {QueryElement<DbModelType>} query - The query element or structure to be evaluated and transformed into filter constraints.
- * @returns {QueryFilterConstraint | null} A constructed query filter constraint based on the input query, or null if no valid constraints can be derived.
+ * @returns {QueryFieldFilterConstraint | null} A constructed query filter constraint based on the input query, or null if no valid constraints can be derived.
  */
 
 const buildCompositeQuery = <DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData>(
     query: QueryElement<DbModelType>
-): QueryFilterConstraint | null => {
+): FirebaseFirestoreTypes.QueryFieldFilterConstraint | FirebaseFirestoreTypes.QueryCompositeFilterConstraint | null => {
     if (query.children) {
         const queryConstraints = query.children
-            .map((subQuery) => buildCompositeQuery(subQuery))
-            .filter<QueryFilterConstraint>((constraint) => !!constraint);
+            .map((subQuery) => {
+                if (subQuery.field && subQuery.op) {
+                    return where(
+                        query.field === "documentId" ? firebase.FieldPath.documentId() : (query.field as string),
+                        subQuery.op,
+                        query.value
+                    );
+                }
+                return buildCompositeQuery(subQuery);
+            })
+            .filter((constraint) => !!constraint);
 
         if (queryConstraints.length <= 0) {
             return null;
         }
 
-        return (query as CompositeFilter).type === "or" ? or(...queryConstraints) : and(...queryConstraints);
-    }
-
-    if (query.field && query.op) {
-        return where(query.field === "documentId" ? documentId() : (query.field as string), query.op, query.value);
+        return (query as CompositeFilter).operator === "OR" ? or(...queryConstraints) : and(...queryConstraints);
     }
 
     return null;
@@ -74,13 +70,12 @@ export const useCompositeFilter = <DbModelType extends CompositeFilterDocumentDa
 }: UseCompositeFilter<DbModelType>) => {
     return useMemo(() => {
         const queryConstraints =
-            query?.children?.map?.((subQuery) => buildCompositeQuery(subQuery))?.filter<QueryFilterConstraint>?.(
-                (constraint) => !!constraint
-            ) ?? [];
+            query?.children?.map?.((subQuery) => buildCompositeQuery(subQuery))
+                ?.filter<FirebaseFirestoreTypes.QueryFilterConstraint>?.((constraint) => !!constraint) ?? [];
 
         if (queryConstraints.length <= 0) {
             return undefined;
         }
-        return query?.type === "or" ? or(...queryConstraints) : and(...queryConstraints);
+        return query?.operator === "OR" ? or(...queryConstraints) : and(...queryConstraints);
     }, [query]);
 };

package/src/firestore/useCountQuery.ts

@@ -1,12 +1,10 @@
 import {
-    DocumentData,
+    FirebaseFirestoreTypes,
     getCountFromServer,
-    Query,
     query,
-    QueryCompositeFilterConstraint,
     QueryConstraint,
     QueryNonFilterConstraint
-} from "firebase/firestore";
+} from "@react-native-firebase/firestore";
 
 import {
     UseQueryResult,
@@ -15,14 +13,13 @@ import {
 } from "@tanstack/react-query";
 
 type UseCountQueryOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
 > = {
     options: Omit<UseReactQueryOptions<number, Error, number>, "queryFn"> &
         Required<Pick<UseReactQueryOptions<number, Error, number>, "queryKey">>;
-    query: Query<AppModelType, DbModelType>;
+    query: FirebaseFirestoreTypes.Query<AppModelType>;
     queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: QueryCompositeFilterConstraint;
+    compositeFilter?: FirebaseFirestoreTypes.QueryCompositeFilterConstraint;
 };
 
 /**
@@ -31,8 +28,8 @@ type UseCountQueryOptions<
  * This function utilizes React Query to asynchronously fetch the count of documents from a server database
  * that match the provided query constraints and an optional composite filter.
  *
- * @param {UseCountQueryOptions<AppModelType, DbModelType>} options - Configuration options for the query.
- * @param {AppModelType extends DocumentData = DocumentData} [options.options] - Additional options for the React Query.
+ * @param {UseCountQueryOptions<AppModelType>} options - Configuration options for the query.
+ * @param {AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData} [options.options] - Additional options for the React Query.
  * @param {unknown} [options.query] - Reference to the query object to be executed.
  * @param {unknown[]} [options.queryConstraints=[]] - An array of constraints to apply to the query.
  * @param {unknown} [options.compositeFilter] - An optional composite filter to apply to the query.
@@ -40,14 +37,13 @@ type UseCountQueryOptions<
  */
 
 export const useCountQuery = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
 >({
     options,
     query: queryReference,
     queryConstraints = [],
     compositeFilter
-}: UseCountQueryOptions<AppModelType, DbModelType>): UseQueryResult<number> => {
+}: UseCountQueryOptions<AppModelType>): UseQueryResult<number> => {
     return useReactQuery({
         ...options,
         queryFn: async () => {

package/src/firestore/useDeleteDocMutation.ts

@@ -1,7 +1,7 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { DocumentData, deleteDoc, WithFieldValue, DocumentReference } from "firebase/firestore";
+import { FirebaseFirestoreTypes, deleteDoc, WithFieldValue } from "@react-native-firebase/firestore";
 
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { useMemo } from "react";
 
 export type UseDeleteDocMutationValues<AppModelType> = {
@@ -9,12 +9,14 @@ export type UseDeleteDocMutationValues<AppModelType> = {
 };
 
 export type UseDeleteDocMutationOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
     TContext = unknown
 > = {
-    reference: DocumentReference<AppModelType, DbModelType> | null;
-    options?: Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "mutationFn" | "mutationKey">;
+    reference: FirebaseFirestoreTypes.DocumentReference<AppModelType> | null;
+    options?: Omit<
+        UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, void, TContext>,
+        "mutationFn" | "mutationKey"
+    >;
 };
 
 /**
@@ -25,13 +27,12 @@ export type UseDeleteDocMutationOptions<
  * @returns {UseMutationResult} An object returned by the `useMutation` hook which includes properties and methods to control the mutation's execution and track its state.
  */
 export const useDeleteDocMutation = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
     TContext = unknown
 >({
     reference,
     options = {}
-}: UseDeleteDocMutationOptions<AppModelType, DbModelType, TContext>) => {
+}: UseDeleteDocMutationOptions<AppModelType, TContext>) => {
     const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
 
     return useMutation({
@@ -40,7 +41,7 @@ export const useDeleteDocMutation = <
             if (!reference) {
                 throw new Error("Reference is undefined");
             }
-            await deleteDoc<AppModelType, DbModelType>(reference);
+            await deleteDoc(reference);
         },
         mutationKey
     });

package/src/firestore/useDocReference.ts

@@ -1,10 +1,14 @@
-import { doc, CollectionReference, DocumentData, DocumentReference, Firestore } from "firebase/firestore";
+import { doc, FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 
 import { useEffect, useRef } from "react";
 import { useFirestore } from "./useFirestore";
 
-export type UseDocReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+export type UseDocReferenceOptions<
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+> = {
+    reference?:
+        | FirebaseFirestoreTypes.CollectionReference<AppModelType>
+        | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
     path?: string;
     pathSegments?: string[];
 };
@@ -14,28 +18,26 @@ export type UseDocReferenceOptions<AppModelType, DbModelType extends DocumentDat
  * If a reference is not provided, it constructs a document reference using the Firestore instance, path, and path segments.
  *
  * @param {Firestore} db - The Firestore database instance used to create the document reference.
- * @param {UseDocReferenceOptions<AppModelType, DbModelType>} options - An object containing the path, path segments, and optional reference.
+ * @param {UseDocReferenceOptions<AppModelType>} options - An object containing the path, path segments, and optional reference.
  * @param {string} options.path - The path to the document in the Firestore database.
  * @param {string[]} [options.pathSegments] - Optional additional segments to join with the path.
  * @param {DocumentReference | CollectionReference} [options.reference] - Optional Firestore reference object that influences how the document reference is constructed.
  *
- * @returns {DocumentReference<AppModelType, DbModelType> | null} A Firestore document reference if the path is specified; otherwise, returns null if path is not provided.
+ * @returns {DocumentReference<AppModelType> | null} A Firestore document reference if the path is specified; otherwise, returns null if path is not provided.
  */
-const getDocReference = <AppModelType, DbModelType extends DocumentData = DocumentData>(
-    db: Firestore,
-    { path, pathSegments, reference }: UseDocReferenceOptions<AppModelType, DbModelType>
+const getDocReference = <
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+>(
+    db: FirebaseFirestoreTypes.Module,
+    { path, pathSegments, reference }: UseDocReferenceOptions<AppModelType>
 ) => {
     if (!path) {
         return null;
     }
 
     return (
-        !reference
-            ? doc(db, path || "", ...(pathSegments || []))
-            : reference.type === "collection"
-              ? doc(reference, path, ...(pathSegments || []))
-              : doc(reference, path, ...(pathSegments || []))
-    ) as DocumentReference<AppModelType, DbModelType>;
+        !reference ? doc(db, path || "", ...(pathSegments || [])) : doc(reference, path, ...(pathSegments || []))
+    ) as FirebaseFirestoreTypes.DocumentReference<AppModelType>;
 };
 
 /**
@@ -43,20 +45,22 @@ const getDocReference = <AppModelType, DbModelType extends DocumentData = Docume
  * This hook facilitates the retrieval of a Firestore document reference based on given options such as path and reference data.
  * The reference is updated whenever the associated path, reference, or path segments change.
  *
- * @param {UseDocReferenceOptions<AppModelType, DbModelType>} options - Configuration options for setting up the document reference.
+ * @param {UseDocReferenceOptions<AppModelType>} options - Configuration options for setting up the document reference.
  * @param {string} options.path - The path to the Firestore document.
  * @param {DbModelType} options.reference - Reference data for the document, providing additional context or specifics.
  * @param {string[]} options.pathSegments - Parts of the path to construct the full document path dynamically.
  *
- * @returns {DocumentReference<AppModelType, DbModelType> | null} The Firestore document reference corresponding to the provided path and options, or null if not initialized.
+ * @returns {DocumentReference<AppModelType> | null} The Firestore document reference corresponding to the provided path and options, or null if not initialized.
  */
-export const useDocReference = <AppModelType, DbModelType extends DocumentData = DocumentData>({
+export const useDocReference = <
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+>({
     path,
     reference,
     pathSegments
-}: UseDocReferenceOptions<AppModelType, DbModelType>) => {
+}: UseDocReferenceOptions<AppModelType>) => {
     const db = useFirestore();
-    const ref = useRef<DocumentReference<AppModelType, DbModelType> | null>(
+    const ref = useRef<FirebaseFirestoreTypes.DocumentReference<AppModelType> | null>(
         getDocReference(db, { path, pathSegments, reference })
     );
 

package/src/firestore/useDocReferences.ts

@@ -1,10 +1,14 @@
-import { CollectionReference, doc, DocumentData, DocumentReference } from "firebase/firestore";
+import { doc, FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 
 import { useMemo } from "react";
 import { useFirestore } from "./useFirestore";
 
-export type UseDocReferencesOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+export type UseDocReferencesOptions<
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+> = {
+    reference?:
+        | FirebaseFirestoreTypes.CollectionReference<AppModelType>
+        | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
     path: string;
     pathSegments?: string[];
 };
@@ -19,14 +23,16 @@ export type UseDocReferencesOptions<AppModelType, DbModelType extends DocumentDa
  * to interact with the Firestore database documents. It uses memoization to optimize
  * reference generation.
  *
- * @param {UseDocReferencesOptions<AppModelType, DbModelType>[]} references - An array of options
+ * @param {UseDocReferencesOptions<AppModelType>[]} references - An array of options
  * specifying how to generate document references. Each option may include a `path`
  * as a string, a `reference` as a Firestore reference, and `pathSegments` as an array of strings.
- * @returns {DocumentReference<AppModelType, DbModelType>[]} An array of Firestore document references
+ * @returns {DocumentReference<AppModelType>[]} An array of Firestore document references
  * generated from the options provided.
  */
-export const useDocReferences = <AppModelType, DbModelType extends DocumentData = DocumentData>(
-    references: UseDocReferencesOptions<AppModelType, DbModelType>[]
+export const useDocReferences = <
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+>(
+    references: UseDocReferencesOptions<AppModelType>[]
 ) => {
     const db = useFirestore();
 
@@ -35,10 +41,8 @@ export const useDocReferences = <AppModelType, DbModelType extends DocumentData
             return (
                 !reference
                     ? doc(db, path || "", ...(pathSegments || []))
-                    : reference.type === "collection"
-                      ? doc(reference, path, ...(pathSegments || []))
-                      : doc(reference, path, ...(pathSegments || []))
-            ) as DocumentReference<AppModelType, DbModelType>;
+                    : doc(reference, path, ...(pathSegments || []))
+            ) as FirebaseFirestoreTypes.DocumentReference<AppModelType>;
         });
     }, [references]);
 };

package/src/firestore/useGetDocData.ts

@@ -1,19 +1,19 @@
-import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 
 import { useFirestore } from "./useFirestore";
 import { getDocData } from "./utils/getDocData";
 import { useQuery, UseQueryOptions } from "@tanstack/react-query";
 
-type UseGetDocOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
-> = {
-    options: Omit<UseQueryOptions<AppModelType | null, Error, AppModelType>, "queryFn"> &
-        Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
-    path?: string;
-    pathSegments?: string[];
-    reference: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
-};
+type UseGetDocOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData> =
+    {
+        options: Omit<UseQueryOptions<AppModelType | null | undefined, Error, AppModelType>, "queryFn"> &
+            Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
+        path?: string;
+        pathSegments?: string[];
+        reference:
+            | FirebaseFirestoreTypes.CollectionReference<AppModelType>
+            | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
+    };
 
 /**
  * Custom React Hook to retrieve document data from Firestore using specified parameters.
@@ -24,18 +24,17 @@ type UseGetDocOptions<
  * @returns {Object} Result of the query containing document data and query status.
  */
 export const useGetDocData = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
 >({
     options,
     reference,
     path,
     pathSegments
-}: UseGetDocOptions<AppModelType, DbModelType>) => {
+}: UseGetDocOptions<AppModelType>) => {
     const db = useFirestore();
 
     return useQuery({
         ...options,
-        queryFn: () => getDocData<AppModelType, DbModelType>({ db, reference, path, pathSegments })
+        queryFn: () => getDocData<AppModelType>({ db, reference, path, pathSegments })
     });
 };

package/src/firestore/useGetRealtimeDocData.ts

@@ -1,13 +1,15 @@
-import { CollectionReference, DocumentData, DocumentReference, onSnapshot } from "firebase/firestore";
+import { FirebaseFirestoreTypes, onSnapshot } from "@react-native-firebase/firestore";
 
 import { useEffect, useMemo, useState } from "react";
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { useDocReference } from "./useDocReference";
 
 /**
  * @inline
  */
-export type UseGetRealtimeDocDataOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
+export type UseGetRealtimeDocDataOptions<
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+> = {
     /**
      * A slash-separated path to a document. Has to be omitted to use
      */
@@ -15,7 +17,9 @@ export type UseGetRealtimeDocDataOptions<AppModelType, DbModelType extends Docum
     /**
      * A reference to a collection.
      */
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    reference?:
+        | FirebaseFirestoreTypes.CollectionReference<AppModelType>
+        | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
     /**
      * Additional path segments that will be applied relative
      * to the first argument.
@@ -25,7 +29,7 @@ export type UseGetRealtimeDocDataOptions<AppModelType, DbModelType extends Docum
      * A callback to be called if the listen fails or is
      * cancelled. No further callbacks will occur.
      */
-    onError?: (error: FirebaseError) => unknown;
+    onError?: (error: ReactNativeFirebase.NativeFirebaseError | Error) => unknown;
 };
 
 /**
@@ -34,7 +38,7 @@ export type UseGetRealtimeDocDataOptions<AppModelType, DbModelType extends Docum
 export type UseGetRealtimeDocDataResult<AppModelType> = {
     data: AppModelType | null;
     isError: boolean;
-    error: FirebaseError | null;
+    error: ReactNativeFirebase.NativeFirebaseError | Error | null;
     isFetching: boolean;
 };
 
@@ -60,21 +64,23 @@ export type UseGetRealtimeDocDataResult<AppModelType> = {
  * };
  * ```
  */
-export const useGetRealtimeDocData = <AppModelType, DbModelType extends DocumentData = DocumentData>({
+export const useGetRealtimeDocData = <
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+>({
     path,
     pathSegments,
     reference,
     onError
-}: UseGetRealtimeDocDataOptions<AppModelType, DbModelType>): UseGetRealtimeDocDataResult<AppModelType> => {
+}: UseGetRealtimeDocDataOptions<AppModelType>): UseGetRealtimeDocDataResult<AppModelType> => {
     const ref = useDocReference({ path, reference, pathSegments });
     const [doc, setDoc] = useState<AppModelType | null>(null);
     const [isError, setIsError] = useState(false);
     const [isFetching, setIsFetching] = useState(true);
-    const [error, setError] = useState<FirebaseError | null>(null);
+    const [error, setError] = useState<ReactNativeFirebase.NativeFirebaseError | Error | null>(null);
 
     useEffect(() => {
         const unsubscribe = ref
-            ? onSnapshot(ref, {
+            ? onSnapshot<AppModelType>(ref, {
                   next: async (snapshot) => {
                       setIsFetching(false);
                       setDoc(snapshot.data() || null);

package/src/firestore/useInfiniteQuery.ts

@@ -1,13 +1,10 @@
 import {
-    DocumentData,
-    FirestoreDataConverter,
+    FirebaseFirestoreTypes,
     getDocs,
-    Query,
     query,
-    QueryCompositeFilterConstraint,
     QueryConstraint,
     QueryNonFilterConstraint
-} from "firebase/firestore";
+} from "@react-native-firebase/firestore";
 
 import {
     useInfiniteQuery as useInfiniteReactQuery,
@@ -18,8 +15,7 @@ import {
 } from "@tanstack/react-query";
 
 type UseInfiniteQueryOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
     TQueryKey extends QueryKey = QueryKey
 > = {
     options: Omit<
@@ -46,10 +42,9 @@ type UseInfiniteQueryOptions<
                 "queryKey"
             >
         >;
-    query: Query<AppModelType, DbModelType>;
+    query: FirebaseFirestoreTypes.Query<AppModelType>;
     queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: QueryCompositeFilterConstraint;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+    compositeFilter?: FirebaseFirestoreTypes.QueryCompositeFilterConstraint;
 };
 
 /**
@@ -60,15 +55,13 @@ type UseInfiniteQueryOptions<
  * @returns {UseInfiniteQueryResult<InfiniteData<AppModelType[]>>} Result object containing the infinite data and methods for fetching more pages.
  */
 export const useInfiniteQuery = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
 >({
     options,
     query: queryReference,
     queryConstraints = [],
-    compositeFilter,
-    converter
-}: UseInfiniteQueryOptions<AppModelType, DbModelType>): UseInfiniteQueryResult<InfiniteData<AppModelType[]>> => {
+    compositeFilter
+}: UseInfiniteQueryOptions<AppModelType>): UseInfiniteQueryResult<InfiniteData<AppModelType[]>> => {
     return useInfiniteReactQuery({
         ...options,
         queryFn: async ({ pageParam }) => {
@@ -77,7 +70,7 @@ export const useInfiniteQuery = <
                 ? query(queryReference, compositeFilter, ...(allQueryConstraints as QueryNonFilterConstraint[]))
                 : query(queryReference, ...allQueryConstraints);
 
-            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const querySnapshot = await getDocs(queryToExecute);
             const docs: AppModelType[] = [];
 
             if (querySnapshot) {