react-query-firebase 2.3.2 → 2.4.0

package/react-native/firestore/useDocReferences.ts

@@ -1,48 +1,40 @@
-import { doc, FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
-
 import { useMemo } from "react";
 import { useFirestore } from "./useFirestore";
+import { AppModel } from "../../types";
+import { getDocRef, GetDocRefOptions } from "./utils/getDocRef";
 
-export type UseDocReferencesOptions<
-    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
-> = {
-    reference?:
-        | FirebaseFirestoreTypes.CollectionReference<AppModelType>
-        | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
-    path: string;
-    pathSegments?: string[];
+/**
+ * @inline
+ */
+export type UseDocReferencesOptions<AppModelType extends AppModel = AppModel> = {
+    references: Omit<GetDocRefOptions<AppModelType>, "db">[];
 };
 
 /**
- * A custom hook to generate document references for Firebase Firestore documents using given
- * reference options.
+ * Gets `CollectionReference` instances
+ *
+ * @group Hook
+ *
+ * @param {UseDocReferencesOptions<AppModelType>} options - Options
  *
- * The hook accepts an array of options, where each option may contain a path,
- * an existing reference, or path segments, and returns an array of generated
- * Firestore document references based on those options. The references can be used
- * to interact with the Firestore database documents. It uses memoization to optimize
- * reference generation.
+ * @returns {Array<FirebaseFirestoreTypes.DocumentReference<AppModelType> | null>} A reference to a Firestore document
  *
- * @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>[]} An array of Firestore document references
- * generated from the options provided.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const ref = useDocReference({
+ *      reference: collection('todos')
+ *      path: 'first'
+ *  });
+ * };
+ * ```
  */
-export const useDocReferences = <
-    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
->(
-    references: UseDocReferencesOptions<AppModelType>[]
-) => {
+export const useDocReferences = <AppModelType extends AppModel = AppModel>({
+    references
+}: UseDocReferencesOptions<AppModelType>) => {
     const db = useFirestore();
 
     return useMemo(() => {
-        return references.map(({ path, reference, pathSegments }) => {
-            return (
-                !reference
-                    ? doc(db, path || "", ...(pathSegments || []))
-                    : doc(reference, path, ...(pathSegments || []))
-            ) as FirebaseFirestoreTypes.DocumentReference<AppModelType>;
-        });
+        return references.map(({ path, reference, pathSegments }) => getDocRef({ db, reference, path, pathSegments }));
     }, [references, db]);
 };

package/react-native/firestore/useFirestore.d.ts

@@ -1,7 +1,8 @@
 /**
- * Provides a hook to access the Firestore instance from the Firebase context.
- * It extracts the Firestore object from the Firebase context, allowing components to interact with Firestore services.
+ * Returns an instance of firestore bound to the closest context.
  *
- * @returns {firestore.Firestore} The Firestore instance from the Firebase context.
+ * @group Hook
+ *
+ * @returns {Firestore}
  */
 export declare const useFirestore: () => import("@react-native-firebase/firestore").FirebaseFirestoreTypes.Module;

package/react-native/firestore/useFirestore.js

@@ -1,10 +1,11 @@
 import { useContext } from "react";
 import { FirebaseContext } from "../context/FirebaseContext";
 /**
- * Provides a hook to access the Firestore instance from the Firebase context.
- * It extracts the Firestore object from the Firebase context, allowing components to interact with Firestore services.
+ * Returns an instance of firestore bound to the closest context.
  *
- * @returns {firestore.Firestore} The Firestore instance from the Firebase context.
+ * @group Hook
+ *
+ * @returns {Firestore}
  */
 export const useFirestore = () => {
     const { firestore } = useContext(FirebaseContext);

package/react-native/firestore/useFirestore.ts

@@ -2,10 +2,11 @@ import { useContext } from "react";
 import { FirebaseContext } from "../context/FirebaseContext";
 
 /**
- * Provides a hook to access the Firestore instance from the Firebase context.
- * It extracts the Firestore object from the Firebase context, allowing components to interact with Firestore services.
+ * Returns an instance of firestore bound to the closest context.
  *
- * @returns {firestore.Firestore} The Firestore instance from the Firebase context.
+ * @group Hook
+ *
+ * @returns {Firestore}
  */
 export const useFirestore = () => {
     const { firestore } = useContext(FirebaseContext);

package/react-native/firestore/useGetDocData.d.ts

@@ -1,18 +1,37 @@
-import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
+import { GetDocDataOptions } from "./utils/getDocData";
 import { UseQueryOptions } from "@tanstack/react-query";
-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>;
-};
+import { AppModel } from "../../types";
 /**
- * Custom React Hook to retrieve document data from Firestore using specified parameters.
- * @param {Object} options - The options for configuring the Firestore query.
- * @param {string} reference - The reference to the document in Firestore.
- * @param {string} path - The path to the document in Firestore.
- * @param {Array<string>} pathSegments - Segments of the path to document in Firestore.
- * @returns {Object} Result of the query containing document data and query status.
+ * @inline
  */
-export declare const useGetDocData: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ options, reference, path, pathSegments }: UseGetDocOptions<AppModelType>) => import("@tanstack/react-query").UseQueryResult<AppModelType, Error>;
+type UseGetDocOptions<AppModelType extends AppModel = AppModel> = {
+    /**
+     * Reqct-query options that must include queryKey and shall not define queryFn
+     */
+    options: Omit<UseQueryOptions<AppModelType | null, Error, AppModelType>, "queryFn"> & Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
+} & Omit<GetDocDataOptions<AppModelType>, "db">;
+/**
+ * Executes a query on a Firestore data source and returns the resulting document.
+ *
+ * @group Hook
+ *
+ * @param {UseGetDocOptions<AppModelType>} options - Configuration options for the query.
+ *
+ * @returns {UseQueryResult<AppModelType, Error>} An object containing document's data
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const doc = useGetDocData({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      reference: collection(),
+ *      path: 'id'
+ *  });
+ *  console.log(doc);
+ * };
+ * ```
+ */
+export declare const useGetDocData: <AppModelType extends AppModel = AppModel>({ options, reference, path, pathSegments }: UseGetDocOptions<AppModelType>) => import("@tanstack/react-query").UseQueryResult<AppModelType, Error>;
 export {};

package/react-native/firestore/useGetDocData.js

@@ -2,12 +2,27 @@ import { useFirestore } from "./useFirestore";
 import { getDocData } from "./utils/getDocData";
 import { useQuery } from "@tanstack/react-query";
 /**
- * Custom React Hook to retrieve document data from Firestore using specified parameters.
- * @param {Object} options - The options for configuring the Firestore query.
- * @param {string} reference - The reference to the document in Firestore.
- * @param {string} path - The path to the document in Firestore.
- * @param {Array<string>} pathSegments - Segments of the path to document in Firestore.
- * @returns {Object} Result of the query containing document data and query status.
+ * Executes a query on a Firestore data source and returns the resulting document.
+ *
+ * @group Hook
+ *
+ * @param {UseGetDocOptions<AppModelType>} options - Configuration options for the query.
+ *
+ * @returns {UseQueryResult<AppModelType, Error>} An object containing document's data
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const doc = useGetDocData({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      reference: collection(),
+ *      path: 'id'
+ *  });
+ *  console.log(doc);
+ * };
+ * ```
  */
 export const useGetDocData = ({ options, reference, path, pathSegments }) => {
     const db = useFirestore();

package/react-native/firestore/useGetDocData.ts

@@ -1,31 +1,43 @@
-import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
-
 import { useFirestore } from "./useFirestore";
-import { getDocData } from "./utils/getDocData";
+import { getDocData, GetDocDataOptions } from "./utils/getDocData";
 import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { AppModel } from "../../types";
 
-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>;
-    };
+/**
+ * @inline
+ */
+type UseGetDocOptions<AppModelType extends AppModel = AppModel> = {
+    /**
+     * Reqct-query options that must include queryKey and shall not define queryFn
+     */
+    options: Omit<UseQueryOptions<AppModelType | null, Error, AppModelType>, "queryFn"> &
+        Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
+} & Omit<GetDocDataOptions<AppModelType>, "db">;
 
 /**
- * Custom React Hook to retrieve document data from Firestore using specified parameters.
- * @param {Object} options - The options for configuring the Firestore query.
- * @param {string} reference - The reference to the document in Firestore.
- * @param {string} path - The path to the document in Firestore.
- * @param {Array<string>} pathSegments - Segments of the path to document in Firestore.
- * @returns {Object} Result of the query containing document data and query status.
+ * Executes a query on a Firestore data source and returns the resulting document.
+ *
+ * @group Hook
+ *
+ * @param {UseGetDocOptions<AppModelType>} options - Configuration options for the query.
+ *
+ * @returns {UseQueryResult<AppModelType, Error>} An object containing document's data
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const doc = useGetDocData({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      reference: collection(),
+ *      path: 'id'
+ *  });
+ *  console.log(doc);
+ * };
+ * ```
  */
-export const useGetDocData = <
-    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData
->({
+export const useGetDocData = <AppModelType extends AppModel = AppModel>({
     options,
     reference,
     path,

package/react-native/firestore/useInfiniteQuery.d.ts

@@ -1,6 +1,6 @@
 import { FirebaseFirestoreTypes, QueryConstraint, QueryNonFilterConstraint } from "@react-native-firebase/firestore";
 import { UseInfiniteQueryOptions as UseReactInfiniteQueryOptions, QueryKey, UseInfiniteQueryResult, InfiniteData } from "@tanstack/react-query";
-import { QueryFilterConstraint } from "./useCompositeFilter";
+import { QueryFilterConstraint } from "./utils/buildCompositeFilter";
 import { AppModel } from "../../types";
 /**
  * @inline
@@ -9,7 +9,7 @@ type UseInfiniteQueryOptions<AppModelType extends AppModel = AppModel, TQueryKey
     /**
      * Reqct-query options that must include queryKey and shall not define queryFn
      */
-    options: Omit<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, QueryConstraint>, "queryFn"> & Required<Pick<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, QueryConstraint>, "queryKey">>;
+    options: Omit<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, QueryNonFilterConstraint>, "queryFn"> & Required<Pick<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, QueryNonFilterConstraint>, "queryKey">>;
     /**
      * Reference to a Firestore collection
      */

package/react-native/firestore/useInfiniteQuery.ts

@@ -13,7 +13,7 @@ import {
     UseInfiniteQueryResult,
     InfiniteData
 } from "@tanstack/react-query";
-import { QueryFilterConstraint } from "./useCompositeFilter";
+import { QueryFilterConstraint } from "./utils/buildCompositeFilter";
 import { AppModel } from "../../types";
 
 /**
@@ -30,7 +30,7 @@ type UseInfiniteQueryOptions<AppModelType extends AppModel = AppModel, TQueryKey
             InfiniteData<AppModelType[]>,
             AppModelType[],
             TQueryKey,
-            QueryConstraint
+            QueryNonFilterConstraint
         >,
         "queryFn"
     > &
@@ -42,7 +42,7 @@ type UseInfiniteQueryOptions<AppModelType extends AppModel = AppModel, TQueryKey
                     InfiniteData<AppModelType[]>,
                     AppModelType[],
                     TQueryKey,
-                    QueryConstraint
+                    QueryNonFilterConstraint
                 >,
                 "queryKey"
             >

package/react-native/firestore/useQuery.d.ts

@@ -1,6 +1,6 @@
 import { FirebaseFirestoreTypes, QueryConstraint, QueryNonFilterConstraint } from "@react-native-firebase/firestore";
 import { UseQueryResult, UseQueryOptions as UseReactQueryOptions } from "@tanstack/react-query";
-import { QueryFilterConstraint } from "./useCompositeFilter";
+import { QueryFilterConstraint } from "./utils/buildCompositeFilter";
 import { AppModel } from "../../types";
 /**
  * @inline

package/react-native/firestore/useQuery.ts

@@ -11,7 +11,7 @@ import {
     useQuery as useReactQuery,
     UseQueryOptions as UseReactQueryOptions
 } from "@tanstack/react-query";
-import { QueryFilterConstraint } from "./useCompositeFilter";
+import { QueryFilterConstraint } from "./utils/buildCompositeFilter";
 import { AppModel } from "../../types";
 
 /**

package/react-native/firestore/useQueryConstraints.d.ts

@@ -1,3 +1,4 @@
+import { type QueryNonFilterConstraint } from "@react-native-firebase/firestore";
 import { AppModel } from "../../types/AppModel";
 import { type NonFilterQueryConstraint } from "../../types/QueryConstraints";
 /**
@@ -9,27 +10,6 @@ export type UseQueryConstraints<AppModelType extends AppModel = AppModel> = {
      */
     constraints: NonFilterQueryConstraint<AppModelType>[];
 };
-/**
- * A generic mothod to build query constraints for firebase
- *
- * @group Utility
- *
- * @param {NonFilterQueryConstraint<AppModelType>} constraint
- *
- * @returns {FirebaseFirestoreTypes.QueryNonFilterConstraint}
- *
- * @example
- * ```jsx
- * const firebaseConfig = {};
- * export const constraint = useMemo(() => {
- *  return buildQueryConstraint({
- *      type: 'limit',
- *      limit: 1
- *  });
- * };
- * ```
- */
-export declare const buildQueryConstraint: <AppModelType extends AppModel = AppModel>(constraint: NonFilterQueryConstraint<AppModelType>) => import("@react-native-firebase/firestore").QueryOrderByConstraint | import("@react-native-firebase/firestore").QueryLimitConstraint | import("@react-native-firebase/firestore").QueryStartAtConstraint;
 /**
  * A hook to build a list of non-filter query constraints for firebase queries.
  * It uses buildQueryConstraint method and useMemo hook.
@@ -51,4 +31,4 @@ export declare const buildQueryConstraint: <AppModelType extends AppModel = AppM
  * ]};
  * ```
  */
-export declare const useQueryConstraints: <AppModelType extends AppModel = AppModel>({ constraints }: UseQueryConstraints<AppModelType>) => (import("@react-native-firebase/firestore").QueryOrderByConstraint | import("@react-native-firebase/firestore").QueryLimitConstraint | import("@react-native-firebase/firestore").QueryStartAtConstraint)[];
+export declare const useQueryConstraints: <AppModelType extends AppModel = AppModel>({ constraints }: UseQueryConstraints<AppModelType>) => QueryNonFilterConstraint[];

package/react-native/firestore/useQueryConstraints.js

@@ -1,43 +1,5 @@
-import { startAt, orderBy, limit, limitToLast, startAfter, endAt, endBefore } from "@react-native-firebase/firestore";
 import { useMemo } from "react";
-/**
- * A generic mothod to build query constraints for firebase
- *
- * @group Utility
- *
- * @param {NonFilterQueryConstraint<AppModelType>} constraint
- *
- * @returns {FirebaseFirestoreTypes.QueryNonFilterConstraint}
- *
- * @example
- * ```jsx
- * const firebaseConfig = {};
- * export const constraint = useMemo(() => {
- *  return buildQueryConstraint({
- *      type: 'limit',
- *      limit: 1
- *  });
- * };
- * ```
- */
-export const buildQueryConstraint = (constraint) => {
-    switch (constraint.type) {
-        case "orderBy":
-            return orderBy(constraint.fieldPath, constraint.directionStr);
-        case "startAt":
-            return startAt(...constraint.arguments);
-        case "startAfter":
-            return startAfter(...constraint.arguments);
-        case "endAt":
-            return endAt(constraint.value, constraint.key);
-        case "endBefore":
-            return endBefore(constraint.value, constraint.key);
-        case "limit":
-            return limit(constraint.limit);
-        case "limitToLast":
-            return limitToLast(constraint.limit);
-    }
-};
+import { buildQueryConstraint } from "./utils/buildQueryConstraint";
 /**
  * A hook to build a list of non-filter query constraints for firebase queries.
  * It uses buildQueryConstraint method and useMemo hook.

package/react-native/firestore/useQueryConstraints.ts

@@ -1,7 +1,8 @@
-import { startAt, orderBy, limit, limitToLast, startAfter, endAt, endBefore } from "@react-native-firebase/firestore";
+import { type QueryNonFilterConstraint } from "@react-native-firebase/firestore";
 import { useMemo } from "react";
 import { AppModel } from "../../types/AppModel";
 import { type NonFilterQueryConstraint } from "../../types/QueryConstraints";
+import { buildQueryConstraint } from "./utils/buildQueryConstraint";
 
 /**
  * @inline
@@ -13,47 +14,6 @@ export type UseQueryConstraints<AppModelType extends AppModel = AppModel> = {
     constraints: NonFilterQueryConstraint<AppModelType>[];
 };
 
-/**
- * A generic mothod to build query constraints for firebase
- *
- * @group Utility
- *
- * @param {NonFilterQueryConstraint<AppModelType>} constraint
- *
- * @returns {FirebaseFirestoreTypes.QueryNonFilterConstraint}
- *
- * @example
- * ```jsx
- * const firebaseConfig = {};
- * export const constraint = useMemo(() => {
- *  return buildQueryConstraint({
- *      type: 'limit',
- *      limit: 1
- *  });
- * };
- * ```
- */
-export const buildQueryConstraint = <AppModelType extends AppModel = AppModel>(
-    constraint: NonFilterQueryConstraint<AppModelType>
-) => {
-    switch (constraint.type) {
-        case "orderBy":
-            return orderBy(constraint.fieldPath as string, constraint.directionStr);
-        case "startAt":
-            return startAt(...constraint.arguments);
-        case "startAfter":
-            return startAfter(...constraint.arguments);
-        case "endAt":
-            return endAt(constraint.value, constraint.key);
-        case "endBefore":
-            return endBefore(constraint.value, constraint.key);
-        case "limit":
-            return limit(constraint.limit);
-        case "limitToLast":
-            return limitToLast(constraint.limit);
-    }
-};
-
 /**
  * A hook to build a list of non-filter query constraints for firebase queries.
  * It uses buildQueryConstraint method and useMemo hook.
@@ -77,7 +37,7 @@ export const buildQueryConstraint = <AppModelType extends AppModel = AppModel>(
  */
 export const useQueryConstraints = <AppModelType extends AppModel = AppModel>({
     constraints
-}: UseQueryConstraints<AppModelType>) => {
+}: UseQueryConstraints<AppModelType>): QueryNonFilterConstraint[] => {
     return useMemo(() => {
         return constraints.map(buildQueryConstraint);
     }, [constraints]);

package/react-native/firestore/useRunTransaction.d.ts

@@ -1,15 +1,39 @@
 import { UseMutationOptions } from "@tanstack/react-query";
 import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
-import { ReactNativeFirebase } from "@react-native-firebase/app";
-export type UseRunTransactionValues = <AppModelType = unknown>(transaction: FirebaseFirestoreTypes.Transaction) => AppModelType;
-export type UseRunTransactionOptions<AppModelType = unknown, TContext = unknown> = {
-    options?: Omit<UseMutationOptions<AppModelType, ReactNativeFirebase.NativeFirebaseError, UseRunTransactionValues, TContext>, "mutationFn">;
+/**
+ * @inline
+ */
+export type UseRunTransactionValues = <T = unknown>(transaction: FirebaseFirestoreTypes.Transaction) => T;
+/**
+ * @inline
+ */
+export type UseRunTransactionOptions<T = unknown, TContext = unknown> = {
+    /**
+     * Reqct-mutation options that shall omit mutationFn
+     */
+    options?: Omit<UseMutationOptions<T, Error, UseRunTransactionValues, TContext>, "mutationFn">;
 };
 /**
- * Custom hook to execute a Firestore transaction using the useMutation hook.
+ * Executes a Firestore transaction
+ *
+ * @group Hook
+ *
+ * @param {UseRunTransactionOptions<T>} options - Configuration options for the mutation.
+ *
+ * @returns {UseMutationResult<T, Error>} An object representing mutation
  *
- * @param {UseRunTransactionOptions<AppModelType, TContext>} options - Configuration options for running the transaction.
- * @param {Object} options.options - Options to customize the behavior of useMutation and runTransaction.
- * @returns {UseMutationResult} The result object from the useMutation hook, allowing to track the transaction state and outcome.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const doc = useGetDocData({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      reference: collection(),
+ *      path: 'id'
+ *  });
+ *  console.log(doc);
+ * };
+ * ```
  */
-export declare const useRunTransaction: <AppModelType = unknown, TContext = unknown>({ options }: UseRunTransactionOptions<AppModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<AppModelType, ReactNativeFirebase.NativeFirebaseError, UseRunTransactionValues, TContext>;
+export declare const useRunTransaction: <T = unknown, TContext = unknown>({ options }: UseRunTransactionOptions<T, TContext>) => import("@tanstack/react-query").UseMutationResult<T, Error, UseRunTransactionValues, TContext>;

package/react-native/firestore/useRunTransaction.js

@@ -2,11 +2,27 @@ import { useMutation } from "@tanstack/react-query";
 import { runTransaction } from "@react-native-firebase/firestore";
 import { useFirestore } from "./useFirestore";
 /**
- * Custom hook to execute a Firestore transaction using the useMutation hook.
+ * Executes a Firestore transaction
  *
- * @param {UseRunTransactionOptions<AppModelType, TContext>} options - Configuration options for running the transaction.
- * @param {Object} options.options - Options to customize the behavior of useMutation and runTransaction.
- * @returns {UseMutationResult} The result object from the useMutation hook, allowing to track the transaction state and outcome.
+ * @group Hook
+ *
+ * @param {UseRunTransactionOptions<T>} options - Configuration options for the mutation.
+ *
+ * @returns {UseMutationResult<T, Error>} An object representing mutation
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const doc = useGetDocData({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      reference: collection(),
+ *      path: 'id'
+ *  });
+ *  console.log(doc);
+ * };
+ * ```
  */
 export const useRunTransaction = ({ options = {} }) => {
     const db = useFirestore();

package/react-native/firestore/useRunTransaction.ts

@@ -1,36 +1,55 @@
 import { useMutation, UseMutationOptions } from "@tanstack/react-query";
 import { runTransaction, FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 
-import { ReactNativeFirebase } from "@react-native-firebase/app";
 import { useFirestore } from "./useFirestore";
 
-export type UseRunTransactionValues = <AppModelType = unknown>(
-    transaction: FirebaseFirestoreTypes.Transaction
-) => AppModelType;
+/**
+ * @inline
+ */
+export type UseRunTransactionValues = <T = unknown>(transaction: FirebaseFirestoreTypes.Transaction) => T;
 
-export type UseRunTransactionOptions<AppModelType = unknown, TContext = unknown> = {
-    options?: Omit<
-        UseMutationOptions<AppModelType, ReactNativeFirebase.NativeFirebaseError, UseRunTransactionValues, TContext>,
-        "mutationFn"
-    >;
+/**
+ * @inline
+ */
+export type UseRunTransactionOptions<T = unknown, TContext = unknown> = {
+    /**
+     * Reqct-mutation options that shall omit mutationFn
+     */
+    options?: Omit<UseMutationOptions<T, Error, UseRunTransactionValues, TContext>, "mutationFn">;
 };
 
 /**
- * Custom hook to execute a Firestore transaction using the useMutation hook.
+ * Executes a Firestore transaction
+ *
+ * @group Hook
+ *
+ * @param {UseRunTransactionOptions<T>} options - Configuration options for the mutation.
+ *
+ * @returns {UseMutationResult<T, Error>} An object representing mutation
  *
- * @param {UseRunTransactionOptions<AppModelType, TContext>} options - Configuration options for running the transaction.
- * @param {Object} options.options - Options to customize the behavior of useMutation and runTransaction.
- * @returns {UseMutationResult} The result object from the useMutation hook, allowing to track the transaction state and outcome.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const doc = useGetDocData({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      reference: collection(),
+ *      path: 'id'
+ *  });
+ *  console.log(doc);
+ * };
+ * ```
  */
-export const useRunTransaction = <AppModelType = unknown, TContext = unknown>({
+export const useRunTransaction = <T = unknown, TContext = unknown>({
     options = {}
-}: UseRunTransactionOptions<AppModelType, TContext>) => {
+}: UseRunTransactionOptions<T, TContext>) => {
     const db = useFirestore();
 
     return useMutation({
         ...options,
         mutationFn: async (transactionFn) => {
-            return runTransaction<AppModelType>(db, transactionFn);
+            return runTransaction<T>(db, transactionFn);
         }
     });
 };