react-query-firebase 1.3.2 → 2.0.0-rc1

package/src/firestore/useQuery.ts

@@ -1,13 +1,10 @@
 import {
-    DocumentData,
-    FirestoreDataConverter,
+    FirebaseFirestoreTypes,
     getDocs,
-    Query,
     query,
-    QueryCompositeFilterConstraint,
     QueryConstraint,
     QueryNonFilterConstraint
-} from "firebase/firestore";
+} from "@react-native-firebase/firestore";
 
 import {
     UseQueryResult,
@@ -15,16 +12,12 @@ import {
     UseQueryOptions as UseReactQueryOptions
 } from "@tanstack/react-query";
 
-type UseQueryOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
-> = {
+type UseQueryOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData> = {
     options: Omit<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryFn"> &
         Required<Pick<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryKey">>;
-    query: Query<AppModelType, DbModelType>;
+    query: FirebaseFirestoreTypes.Query<AppModelType>;
     queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: QueryCompositeFilterConstraint;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+    compositeFilter?: FirebaseFirestoreTypes.QueryCompositeFilterConstraint;
 };
 
 /**
@@ -33,8 +26,8 @@ type UseQueryOptions<
  * This hook utilizes an abstraction over React Query to asynchronously fetch data based on the provided query
  * reference and constraints. It supports optional filtering, conversion, and additional query constraints.
  *
- * @param {UseQueryOptions<AppModelType, DbModelType>}  options - Configuration options for the query.
- * @param {DocumentReference<AppModelType>}  queryReference - The reference to the query to be executed.
+ * @param {UseQueryOptions<AppModelType>}  options - Configuration options for the query.
+ * @param {FirebaseFirestoreTypes.DocumentReference<AppModelType>}  queryReference - The reference to the query to be executed.
  * @param {QueryConstraint[]}  queryConstraints - Additional constraints to fine-tune the query.
  * @param {QueryConstraint}  compositeFilter - Optional composite filter to apply to the query.
  * @param {FirestoreDataConverter<AppModelType>}  converter - Optional data converter for transforming snapshots.
@@ -42,15 +35,13 @@ type UseQueryOptions<
  * @returns {UseQueryResult<AppModelType[]>} Result containing an array of documents that match the query criteria.
  */
 export const useQuery = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
 >({
     options,
     query: queryReference,
     queryConstraints = [],
-    compositeFilter,
-    converter
-}: UseQueryOptions<AppModelType, DbModelType>): UseQueryResult<AppModelType[]> => {
+    compositeFilter
+}: UseQueryOptions<AppModelType>): UseQueryResult<AppModelType[]> => {
     return useReactQuery({
         ...options,
         queryFn: async () => {
@@ -58,7 +49,7 @@ export const useQuery = <
                 ? query(queryReference, compositeFilter, ...(queryConstraints as QueryNonFilterConstraint[]))
                 : query(queryReference, ...queryConstraints);
 
-            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const querySnapshot = await getDocs(queryToExecute);
             const docs: AppModelType[] = [];
 
             if (querySnapshot) {

package/src/firestore/useRunTransaction.ts

@@ -1,13 +1,18 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { runTransaction, Transaction } from "firebase/firestore";
+import { runTransaction, FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { useFirestore } from "./useFirestore";
 
-export type UseRunTransactionValues = <AppModelType = unknown>(transaction: Transaction) => AppModelType;
+export type UseRunTransactionValues = <AppModelType = unknown>(
+    transaction: FirebaseFirestoreTypes.Transaction
+) => AppModelType;
 
 export type UseRunTransactionOptions<AppModelType = unknown, TContext = unknown> = {
-    options?: Omit<UseMutationOptions<AppModelType, FirebaseError, UseRunTransactionValues, TContext>, "mutationFn">;
+    options?: Omit<
+        UseMutationOptions<AppModelType, ReactNativeFirebase.NativeFirebaseError, UseRunTransactionValues, TContext>,
+        "mutationFn"
+    >;
 };
 
 /**

package/src/firestore/useSetDocMutation.ts

@@ -1,7 +1,7 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { DocumentData, DocumentReference, setDoc, WithFieldValue } from "firebase/firestore";
+import { FirebaseFirestoreTypes, setDoc, WithFieldValue } from "@react-native-firebase/firestore";
 
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { useMemo } from "react";
 
 export type UseSetDocMutationValues<AppModelType> = {
@@ -9,13 +9,17 @@ export type UseSetDocMutationValues<AppModelType> = {
 };
 
 export type UseSetDocMutationOptions<
-    AppModelType = unknown,
-    DbModelType extends DocumentData = DocumentData,
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
     TContext = unknown
 > = {
-    reference: DocumentReference<AppModelType, DbModelType> | null;
+    reference: FirebaseFirestoreTypes.DocumentReference<AppModelType> | null;
     options?: Omit<
-        UseMutationOptions<void, FirebaseError, UseSetDocMutationValues<AppModelType>, TContext>,
+        UseMutationOptions<
+            void,
+            ReactNativeFirebase.NativeFirebaseError,
+            UseSetDocMutationValues<AppModelType>,
+            TContext
+        >,
         "mutationFn" | "mutationKey"
     >;
 };
@@ -24,19 +28,18 @@ export type UseSetDocMutationOptions<
  * Custom hook to create a mutation for setting a document in a Firestore-like database.
  * The mutation can be configured with options and reference to specific document path.
  *
- * @param {UseSetDocMutationOptions<AppModelType, DbModelType, TContext>} param0 - The options for configuring the mutation, including the document reference and additional mutation options.
+ * @param {UseSetDocMutationOptions<AppModelType, TContext>} param0 - The options for configuring the mutation, including the document reference and additional mutation options.
  * @param {Object} param0.reference - The reference object that contains the path to the document.
  * @param {Object} param0.options - Additional options for the mutation, can configure aspects like onSuccess or onError callbacks.
  * @returns {MutationResult} The result of the mutation operation, which includes states like isLoading, isSuccess, isError, and methods to control the mutation process.
  */
 export const useSetDocMutation = <
-    AppModelType = unknown,
-    DbModelType extends DocumentData = DocumentData,
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
     TContext = unknown
 >({
     reference,
     options
-}: UseSetDocMutationOptions<AppModelType, DbModelType, TContext>) => {
+}: UseSetDocMutationOptions<AppModelType, TContext>) => {
     const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
 
     return useMutation({
@@ -45,7 +48,7 @@ export const useSetDocMutation = <
             if (!reference) {
                 throw new Error("Reference is undefined");
             }
-            return setDoc<AppModelType, DbModelType>(reference, data);
+            return setDoc<AppModelType>(reference, data);
         },
         mutationKey
     });

package/src/firestore/useUpdateDocMutation.ts

@@ -1,14 +1,7 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import {
-    DocumentData,
-    updateDoc,
-    getDoc,
-    FirestoreDataConverter,
-    DocumentReference,
-    UpdateData
-} from "firebase/firestore";
+import { FirebaseFirestoreTypes, updateDoc, getDoc, UpdateData } from "@react-native-firebase/firestore";
 
-import { FirebaseError } from "firebase/app";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { useMemo } from "react";
 
 export type UseUpdateDocMutationValues<DbModelType> = {
@@ -16,14 +9,17 @@ export type UseUpdateDocMutationValues<DbModelType> = {
 };
 
 export type UseUpdateDocMutationOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
     TContext = unknown
 > = {
-    reference: DocumentReference<AppModelType, DbModelType> | null;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+    reference: FirebaseFirestoreTypes.DocumentReference<AppModelType> | null;
     options?: Omit<
-        UseMutationOptions<AppModelType, FirebaseError, UseUpdateDocMutationValues<DbModelType>, TContext>,
+        UseMutationOptions<
+            AppModelType,
+            ReactNativeFirebase.NativeFirebaseError,
+            UseUpdateDocMutationValues<AppModelType>,
+            TContext
+        >,
         "mutationFn" | "mutationKey"
     >;
 };
@@ -35,7 +31,7 @@ export type UseUpdateDocMutationOptions<
  * and retrieve the latest data snapshot. The update functionality can be configured with a custom
  * converter if needed.
  *
- * @param {UseUpdateDocMutationOptions<AppModelType, DbModelType, TContext>} options - Configuration options for the mutation,
+ * @param {UseUpdateDocMutationOptions<AppModelType, TContext>} options - Configuration options for the mutation,
  * including Firestore reference, an optional Firestore data converter, and additional mutation options.
  *
  * `reference` - The Firestore document reference that identifies the document to be updated.
@@ -48,14 +44,12 @@ export type UseUpdateDocMutationOptions<
  * which includes functions to start the mutation and properties that represent the different states of the mutation.
  */
 export const useUpdateDocMutation = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
     TContext = unknown
 >({
     reference,
-    converter,
     options = {}
-}: UseUpdateDocMutationOptions<AppModelType, DbModelType, TContext>) => {
+}: UseUpdateDocMutationOptions<AppModelType, TContext>) => {
     const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
 
     return useMutation({
@@ -65,8 +59,8 @@ export const useUpdateDocMutation = <
                 throw new Error("Reference is undefined");
             }
 
-            await updateDoc<AppModelType, DbModelType>(reference, data);
-            const docSnap = await getDoc(converter ? reference.withConverter(converter) : reference);
+            await updateDoc<AppModelType>(reference, data);
+            const docSnap = await getDoc(reference);
             return docSnap.data() as AppModelType;
         },
         mutationKey

package/src/firestore/utils/getDocData.ts

@@ -1,10 +1,9 @@
-import { DocumentData } from "firebase/firestore";
+import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 import { getDocSnap, GetDocSnapOptions } from "./getDocSnap";
 
 export type GetDocDataOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
-> = GetDocSnapOptions<AppModelType, DbModelType>;
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+> = GetDocSnapOptions<AppModelType>;
 
 /**
  * Asynchronously retrieves document data from a specified database and reference.
@@ -21,17 +20,16 @@ export type GetDocDataOptions<
  * or null if the document does not exist.
  */
 export const getDocData = async <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
 >({
     db,
     reference,
     path,
     pathSegments
-}: GetDocDataOptions<AppModelType, DbModelType>) => {
-    const docSnap = await getDocSnap<AppModelType, DbModelType>({ db, reference, path, pathSegments });
+}: GetDocDataOptions<AppModelType>) => {
+    const docSnap = await getDocSnap<AppModelType>({ db, reference, path, pathSegments });
 
-    if (docSnap && docSnap.exists()) {
+    if (docSnap && docSnap?.exists) {
         return docSnap.data();
     }
 

package/src/firestore/utils/getDocRef.ts

@@ -1,11 +1,12 @@
-import { CollectionReference, doc, DocumentData, DocumentReference, Firestore } from "firebase/firestore";
+import { doc, FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 
 export type GetDocRefOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
 > = {
-    db: Firestore;
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    db: FirebaseFirestoreTypes.Module;
+    reference?:
+        | FirebaseFirestoreTypes.CollectionReference<AppModelType>
+        | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
     path?: string;
     pathSegments?: string[];
 };
@@ -15,32 +16,27 @@ export type GetDocRefOptions<
  * Either `reference` or `path` must be provided, not both.
  *
  * @param {Object} options - The options for getting a document reference.
- * @param {Firestore} options.db - The Firestore database instance.
- * @param {DocumentReference | CollectionReference | null} [options.reference] - Reference to a document or collection.
+ * @param {FirebaseFirestoreTypes.Module} options.db - The Firestore database instance.
+ * @param {FirebaseFirestoreTypes.DocumentReference | FirebaseFirestoreTypes.CollectionReference | null} [options.reference] - Reference to a document or collection.
  * @param {string | null} [options.path] - Path to the document.
  * @param {string[] | null} [options.pathSegments] - Additional path segments if any.
- * @returns {DocumentReference<AppModelType, DbModelType>} The document reference.
+ * @returns {FirebaseFirestoreTypes.DocumentReference<AppModelType>} The document reference.
  */
 export const getDocRef = async <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
 >({
     db,
     reference,
     path,
     pathSegments
-}: GetDocRefOptions<AppModelType, DbModelType>) => {
+}: GetDocRefOptions<AppModelType>) => {
     if (!reference && !path) {
         throw new Error("One of the options must be provided: path or reference.");
     }
 
     const docRef = !reference
         ? doc(db, path as string, ...(pathSegments || []))
-        : reference.type === "collection"
-          ? doc(reference, path, ...(pathSegments || []))
-          : reference.type === "document"
-            ? doc(reference, path as string, ...(pathSegments || []))
-            : null;
+        : doc(reference, path, ...(pathSegments || []));
 
-    return docRef as DocumentReference<AppModelType, DbModelType>;
+    return docRef as FirebaseFirestoreTypes.DocumentReference<AppModelType>;
 };

package/src/firestore/utils/getDocSnap.ts

@@ -1,10 +1,9 @@
-import { DocumentData, getDoc as firestoreGetDoc } from "firebase/firestore";
+import { FirebaseFirestoreTypes, getDoc as firestoreGetDoc } from "@react-native-firebase/firestore";
 import { getDocRef, GetDocRefOptions } from "./getDocRef";
 
 export type GetDocSnapOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
-> = GetDocRefOptions<AppModelType, DbModelType>;
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
+> = GetDocRefOptions<AppModelType>;
 
 /**
  * Asynchronously retrieves a document snapshot from Firestore using a specified document reference
@@ -18,20 +17,19 @@ export type GetDocSnapOptions<
  * @param {string} options.reference - A string representing a direct Firestore document reference.
  * @param {string} options.path - A Firestore path string leading to the document.
  * @param {string[]} options.pathSegments - An array of path segments to build the Firestore path.
- * @returns {Promise<DocumentData | null>} A promise that resolves to the document data if the
+ * @returns {Promise<FirebaseFirestoreTypes.DocumentData | null>} A promise that resolves to the document data if the
  *                                         document exists, or `null` if the document does not exist
  *                                         or if the reference could not be obtained.
  */
 export const getDocSnap = async <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
+    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
 >({
     db,
     reference,
     path,
     pathSegments
-}: GetDocSnapOptions<AppModelType, DbModelType>) => {
-    const docRef = await getDocRef<AppModelType, DbModelType>({ db, reference, path, pathSegments });
+}: GetDocSnapOptions<AppModelType>) => {
+    const docRef = await getDocRef<AppModelType>({ db, reference, path, pathSegments });
 
     if (docRef) {
         return await firestoreGetDoc(docRef);

package/src/remoteConfig/useFetchAndActivate.ts

@@ -1,5 +1,5 @@
 import { useRemoteConfig } from "./useRemoteConfig";
-import { ensureInitialized, fetchAndActivate } from "firebase/remote-config";
+import { ensureInitialized, fetchAndActivate } from "@react-native-firebase/remote-config";
 import { useCallback, useMemo, useState } from "react";
 
 /**

package/src/remoteConfig/useGetValue.ts

@@ -1,4 +1,4 @@
-import { getValue } from "firebase/remote-config";
+import { getValue } from "@react-native-firebase/remote-config";
 import { useRemoteConfig } from "./useRemoteConfig";
 import { useMemo } from "react";
 

package/dist/src/auth/useAuthStateReady.d.ts

@@ -1,6 +0,0 @@
-/**
- * A custom hook that determines if the Firebase authentication state is ready.
- * It uses Firebase authentication to check if the auth state is ready and updates the state accordingly.
- * @returns {boolean} Indicates whether the authentication state is ready.
- */
-export declare const useAuthStateReady: () => boolean;

package/dist/src/auth/useAuthStateReady.js

@@ -1,19 +0,0 @@
-import { useAuth } from "./useAuth";
-import { useCallback, useEffect, useState } from "react";
-/**
- * A custom hook that determines if the Firebase authentication state is ready.
- * It uses Firebase authentication to check if the auth state is ready and updates the state accordingly.
- * @returns {boolean} Indicates whether the authentication state is ready.
- */
-export const useAuthStateReady = () => {
-    const firebaseAuth = useAuth();
-    const [isAuthStateReady, setIsAuthStateReady] = useState(false);
-    const callback = useCallback(async () => {
-        await firebaseAuth.authStateReady();
-        setIsAuthStateReady(true);
-    }, [isAuthStateReady]);
-    useEffect(() => {
-        callback();
-    }, [callback]);
-    return isAuthStateReady;
-};

package/src/auth/useAuthStateReady.ts

@@ -1,24 +0,0 @@
-import { useAuth } from "./useAuth";
-import { useCallback, useEffect, useState } from "react";
-
-/**
- * A custom hook that determines if the Firebase authentication state is ready.
- * It uses Firebase authentication to check if the auth state is ready and updates the state accordingly.
- * @returns {boolean} Indicates whether the authentication state is ready.
- */
-export const useAuthStateReady = () => {
-    const firebaseAuth = useAuth();
-
-    const [isAuthStateReady, setIsAuthStateReady] = useState(false);
-
-    const callback = useCallback(async () => {
-        await firebaseAuth.authStateReady();
-        setIsAuthStateReady(true);
-    }, [isAuthStateReady]);
-
-    useEffect(() => {
-        callback();
-    }, [callback]);
-
-    return isAuthStateReady;
-};