react-query-firebase 2.0.2 → 2.1.0

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

@@ -1,19 +0,0 @@
-import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
-export type UseDocReferenceOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData> = {
-    reference?: FirebaseFirestoreTypes.CollectionReference<AppModelType> | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
-    path?: string;
-    pathSegments?: string[];
-};
-/**
- * Custom hook to generate and manage a Firestore document reference.
- * 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>} 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 {FirebaseFirestoreTypes.DocumentReference<AppModelType> | null} The Firestore document reference corresponding to the provided path and options, or null if not initialized.
- */
-export declare const useDocReference: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ path, reference, pathSegments }: UseDocReferenceOptions<AppModelType>) => FirebaseFirestoreTypes.DocumentReference<AppModelType>;

package/react-native/firestore/useDocReference.js

@@ -1,36 +0,0 @@
-import { doc } from "@react-native-firebase/firestore";
-import { useMemo } from "react";
-import { useFirestore } from "./useFirestore";
-/**
- * Generates a document reference for a specified path or reference in Firestore.
- * 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>} 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> | null} A Firestore document reference if the path is specified; otherwise, returns null if path is not provided.
- */
-const getDocReference = (db, { path, pathSegments, reference }) => {
-    return (!reference ? doc(db, path || "", ...(pathSegments || [])) : doc(reference, path, ...(pathSegments || [])));
-};
-/**
- * Custom hook to generate and manage a Firestore document reference.
- * 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>} 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 {FirebaseFirestoreTypes.DocumentReference<AppModelType> | null} The Firestore document reference corresponding to the provided path and options, or null if not initialized.
- */
-export const useDocReference = ({ path, reference, pathSegments }) => {
-    const db = useFirestore();
-    return useMemo(() => {
-        return getDocReference(db, { path, pathSegments, reference });
-    }, [db, reference, path, pathSegments]);
-};

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

@@ -1,23 +0,0 @@
-import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
-export type UseDocReferencesOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData> = {
-    reference?: FirebaseFirestoreTypes.CollectionReference<AppModelType> | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
-    path: string;
-    pathSegments?: string[];
-};
-/**
- * A custom hook to generate document references for Firebase Firestore documents using given
- * reference 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.
- *
- * @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.
- */
-export declare const useDocReferences: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>(references: UseDocReferencesOptions<AppModelType>[]) => FirebaseFirestoreTypes.DocumentReference<AppModelType>[];

package/react-native/firestore/useDocReferences.js

@@ -1,29 +0,0 @@
-import { doc } from "@react-native-firebase/firestore";
-import { useMemo } from "react";
-import { useFirestore } from "./useFirestore";
-/**
- * A custom hook to generate document references for Firebase Firestore documents using given
- * reference 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.
- *
- * @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.
- */
-export const useDocReferences = (references) => {
-    const db = useFirestore();
-    return useMemo(() => {
-        return references.map(({ path, reference, pathSegments }) => {
-            return (!reference
-                ? doc(db, path || "", ...(pathSegments || []))
-                : doc(reference, path, ...(pathSegments || [])));
-        });
-    }, [references, db]);
-};

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

@@ -1,7 +0,0 @@
-/**
- * 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 {firestore.Firestore} The Firestore instance from the Firebase context.
- */
-export declare const useFirestore: () => import("@react-native-firebase/firestore").FirebaseFirestoreTypes.Module;

package/react-native/firestore/useFirestore.js

@@ -1,12 +0,0 @@
-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 {firestore.Firestore} The Firestore instance from the Firebase context.
- */
-export const useFirestore = () => {
-    const { firestore } = useContext(FirebaseContext);
-    return firestore;
-};

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

@@ -1,18 +0,0 @@
-import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
-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>;
-};
-/**
- * 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.
- */
-export declare const useGetDocData: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ options, reference, path, pathSegments }: UseGetDocOptions<AppModelType>) => import("@tanstack/react-query").UseQueryResult<AppModelType, Error>;
-export {};

package/react-native/firestore/useGetDocData.js

@@ -1,18 +0,0 @@
-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.
- */
-export const useGetDocData = ({ options, reference, path, pathSegments }) => {
-    const db = useFirestore();
-    return useQuery({
-        ...options,
-        queryFn: () => getDocData({ db, reference, path, pathSegments })
-    });
-};

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

@@ -1,57 +0,0 @@
-import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
-import { ReactNativeFirebase } from "@react-native-firebase/app";
-/**
- * @inline
- */
-export type UseGetRealtimeDocDataOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData> = {
-    /**
-     * A slash-separated path to a document. Has to be omitted to use
-     */
-    path?: string;
-    /**
-     * A reference to a collection.
-     */
-    reference?: FirebaseFirestoreTypes.CollectionReference<AppModelType> | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
-    /**
-     * Additional path segments that will be applied relative
-     * to the first argument.
-     */
-    pathSegments?: string[];
-    /**
-     * A callback to be called if the listen fails or is
-     * cancelled. No further callbacks will occur.
-     */
-    onError?: (error: ReactNativeFirebase.NativeFirebaseError | Error) => unknown;
-};
-/**
- * @inline
- */
-export type UseGetRealtimeDocDataResult<AppModelType> = {
-    data: AppModelType | null;
-    isError: boolean;
-    error: ReactNativeFirebase.NativeFirebaseError | Error | null;
-    isFetching: boolean;
-};
-/**
- * A hook to get realtime updates to a firestore document.
- *
- * @group Hook
- *
- * @param {UseGetRealtimeDocDataOptions<AppModelType, DbModelType>} options
- *
- * @returns {UseGetRealtimeDocDataResult<AppModelType>}
- *
- * @example
- * ```jsx
- * const firebaseConfig = {};
- * export const MyComponent = () => {
- *  const result = useGetRealtimeDocData('collection/documentId');
- *  return (
- *      <div>
- *          {JSON.stringify(result)}
- *      </div>
- *  );
- * };
- * ```
- */
-export declare const useGetRealtimeDocData: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ path, pathSegments, reference, onError }: UseGetRealtimeDocDataOptions<AppModelType>) => UseGetRealtimeDocDataResult<AppModelType>;

package/react-native/firestore/useGetRealtimeDocData.js

@@ -1,56 +0,0 @@
-import { onSnapshot } from "@react-native-firebase/firestore";
-import { useEffect, useMemo, useState } from "react";
-import { useDocReference } from "./useDocReference";
-/**
- * A hook to get realtime updates to a firestore document.
- *
- * @group Hook
- *
- * @param {UseGetRealtimeDocDataOptions<AppModelType, DbModelType>} options
- *
- * @returns {UseGetRealtimeDocDataResult<AppModelType>}
- *
- * @example
- * ```jsx
- * const firebaseConfig = {};
- * export const MyComponent = () => {
- *  const result = useGetRealtimeDocData('collection/documentId');
- *  return (
- *      <div>
- *          {JSON.stringify(result)}
- *      </div>
- *  );
- * };
- * ```
- */
-export const useGetRealtimeDocData = ({ path, pathSegments, reference, onError }) => {
-    const ref = useDocReference({ path, reference, pathSegments });
-    const [doc, setDoc] = useState(null);
-    const [isError, setIsError] = useState(false);
-    const [isFetching, setIsFetching] = useState(true);
-    const [error, setError] = useState(null);
-    useEffect(() => {
-        const unsubscribe = ref
-            ? onSnapshot(ref, {
-                next: async (snapshot) => {
-                    setIsFetching(false);
-                    setDoc(snapshot.data() || null);
-                    setError(null);
-                    setIsError(false);
-                },
-                error: (e) => {
-                    setIsError(true);
-                    setError(e);
-                    onError?.(e);
-                }
-            })
-            : () => { };
-        return () => unsubscribe();
-    }, [ref, doc, isError, onError, isFetching, error]);
-    return useMemo(() => ({
-        data: doc,
-        isError,
-        isFetching,
-        error
-    }), [doc, isError, error, isFetching]);
-};

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

@@ -1,17 +0,0 @@
-import { FirebaseFirestoreTypes, QueryConstraint, QueryNonFilterConstraint } from "@react-native-firebase/firestore";
-import { UseInfiniteQueryOptions as UseReactInfiniteQueryOptions, QueryKey, UseInfiniteQueryResult, InfiniteData } from "@tanstack/react-query";
-type UseInfiniteQueryOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = {
-    options: Omit<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, TPageParam>, "queryFn"> & Required<Pick<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, TPageParam>, "queryKey">>;
-    collectionReference: FirebaseFirestoreTypes.CollectionReference<AppModelType>;
-    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: FirebaseFirestoreTypes.QueryCompositeFilterConstraint;
-};
-/**
- * Custom hook that creates an infinite query using Firestore, allowing for query constraints, composite filters, and converters.
- * It fetches data in pages and can load more as required.
- *
- * @param {UseInfiniteQueryOptions<AppModelType, DbModelType>} options - Configuration options for the infinite query, including Firestore query reference, query constraints, composite filter, and data converter.
- * @returns {UseInfiniteQueryResult<InfiniteData<AppModelType[]>>} Result object containing the infinite data and methods for fetching more pages.
- */
-export declare const useInfiniteQuery: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ options, collectionReference, queryConstraints, compositeFilter }: UseInfiniteQueryOptions<AppModelType>) => UseInfiniteQueryResult<InfiniteData<AppModelType[]>>;
-export {};

package/react-native/firestore/useInfiniteQuery.js

@@ -1,28 +0,0 @@
-import { getDocs, query } from "@react-native-firebase/firestore";
-import { useInfiniteQuery as useInfiniteReactQuery } from "@tanstack/react-query";
-/**
- * Custom hook that creates an infinite query using Firestore, allowing for query constraints, composite filters, and converters.
- * It fetches data in pages and can load more as required.
- *
- * @param {UseInfiniteQueryOptions<AppModelType, DbModelType>} options - Configuration options for the infinite query, including Firestore query reference, query constraints, composite filter, and data converter.
- * @returns {UseInfiniteQueryResult<InfiniteData<AppModelType[]>>} Result object containing the infinite data and methods for fetching more pages.
- */
-export const useInfiniteQuery = ({ options, collectionReference, queryConstraints = [], compositeFilter }) => {
-    return useInfiniteReactQuery({
-        ...options,
-        queryFn: async ({ pageParam }) => {
-            const allQueryConstraints = [...queryConstraints, ...(pageParam ? [pageParam] : [])];
-            const queryToExecute = compositeFilter
-                ? query(collectionReference, compositeFilter, ...allQueryConstraints)
-                : query(collectionReference, ...allQueryConstraints);
-            const querySnapshot = await getDocs(queryToExecute);
-            const docs = [];
-            if (querySnapshot) {
-                querySnapshot.forEach((doc) => {
-                    docs.push(doc.data());
-                });
-            }
-            return docs;
-        }
-    });
-};

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

@@ -1,24 +0,0 @@
-import { FirebaseFirestoreTypes, QueryConstraint, QueryNonFilterConstraint } from "@react-native-firebase/firestore";
-import { UseQueryResult, UseQueryOptions as UseReactQueryOptions } from "@tanstack/react-query";
-type UseQueryOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData> = {
-    options: Omit<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryFn"> & Required<Pick<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryKey">>;
-    collectionReference: FirebaseFirestoreTypes.CollectionReference<AppModelType>;
-    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: FirebaseFirestoreTypes.QueryCompositeFilterConstraint;
-};
-/**
- * Executes a query on a Firestore-like data source and returns the resulting documents as an array.
- *
- * 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>}  options - Configuration options for the query.
- * @param {FirebaseFirestoreTypes.DocumentReference<AppModelType>}  collectionReference - 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.
- *
- * @returns {UseQueryResult<AppModelType[]>} Result containing an array of documents that match the query criteria.
- */
-export declare const useQuery: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ options, collectionReference, queryConstraints, compositeFilter }: UseQueryOptions<AppModelType>) => UseQueryResult<AppModelType[]>;
-export {};

package/react-native/firestore/useQuery.js

@@ -1,34 +0,0 @@
-import { getDocs, query } from "@react-native-firebase/firestore";
-import { useQuery as useReactQuery } from "@tanstack/react-query";
-/**
- * Executes a query on a Firestore-like data source and returns the resulting documents as an array.
- *
- * 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>}  options - Configuration options for the query.
- * @param {FirebaseFirestoreTypes.DocumentReference<AppModelType>}  collectionReference - 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.
- *
- * @returns {UseQueryResult<AppModelType[]>} Result containing an array of documents that match the query criteria.
- */
-export const useQuery = ({ options, collectionReference, queryConstraints = [], compositeFilter }) => {
-    return useReactQuery({
-        ...options,
-        queryFn: async () => {
-            const queryToExecute = compositeFilter
-                ? query(collectionReference, compositeFilter, ...queryConstraints)
-                : query(collectionReference, ...queryConstraints);
-            const querySnapshot = await getDocs(queryToExecute);
-            const docs = [];
-            if (querySnapshot) {
-                querySnapshot.forEach((doc) => {
-                    docs.push(doc.data());
-                });
-            }
-            return docs;
-        }
-    });
-};

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

@@ -1,15 +0,0 @@
-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">;
-};
-/**
- * Custom hook to execute a Firestore transaction using the useMutation hook.
- *
- * @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.
- */
-export declare const useRunTransaction: <AppModelType = unknown, TContext = unknown>({ options }: UseRunTransactionOptions<AppModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<AppModelType, ReactNativeFirebase.NativeFirebaseError, UseRunTransactionValues, TContext>;

package/react-native/firestore/useRunTransaction.js

@@ -1,19 +0,0 @@
-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.
- *
- * @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.
- */
-export const useRunTransaction = ({ options = {} }) => {
-    const db = useFirestore();
-    return useMutation({
-        ...options,
-        mutationFn: async (transactionFn) => {
-            return runTransaction(db, transactionFn);
-        }
-    });
-};

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

@@ -1,20 +0,0 @@
-import { UseMutationOptions } from "@tanstack/react-query";
-import { FirebaseFirestoreTypes, WithFieldValue } from "@react-native-firebase/firestore";
-import { ReactNativeFirebase } from "@react-native-firebase/app";
-export type UseSetDocMutationValues<AppModelType> = {
-    data: WithFieldValue<AppModelType>;
-};
-export type UseSetDocMutationOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData, TContext = unknown> = {
-    reference: FirebaseFirestoreTypes.DocumentReference<AppModelType> | null;
-    options?: Omit<UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, UseSetDocMutationValues<AppModelType>, TContext>, "mutationFn" | "mutationKey">;
-};
-/**
- * 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, 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 declare const useSetDocMutation: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData, TContext = unknown>({ reference, options }: UseSetDocMutationOptions<AppModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<void, ReactNativeFirebase.NativeFirebaseError, UseSetDocMutationValues<AppModelType>, TContext>;

package/react-native/firestore/useSetDocMutation.js

@@ -1,25 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { setDoc } from "@react-native-firebase/firestore";
-import { useMemo } from "react";
-/**
- * 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, 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 = ({ reference, options }) => {
-    const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
-    return useMutation({
-        ...options,
-        mutationFn: ({ data }) => {
-            if (!reference) {
-                throw new Error("Reference is undefined");
-            }
-            return setDoc(reference, data);
-        },
-        mutationKey
-    });
-};

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

@@ -1,30 +0,0 @@
-import { UseMutationOptions } from "@tanstack/react-query";
-import { FirebaseFirestoreTypes, UpdateData } from "@react-native-firebase/firestore";
-import { ReactNativeFirebase } from "@react-native-firebase/app";
-export type UseUpdateDocMutationValues<DbModelType> = {
-    data: UpdateData<DbModelType>;
-};
-export type UseUpdateDocMutationOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData, TContext = unknown> = {
-    reference: FirebaseFirestoreTypes.DocumentReference<AppModelType> | null;
-    options?: Omit<UseMutationOptions<AppModelType, ReactNativeFirebase.NativeFirebaseError, UseUpdateDocMutationValues<AppModelType>, TContext>, "mutationFn" | "mutationKey">;
-};
-/**
- * Custom hook that sets up a mutation for updating a document in a Firestore database.
- *
- * This hook utilizes `useMutation` for performing asynchronous operations to update the document
- * and retrieve the latest data snapshot. The update functionality can be configured with a custom
- * converter if needed.
- *
- * @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.
- *
- * `converter` - An optional Firestore converter for transforming the database response into a custom type.
- *
- * `options` - Additional options that customize the mutation's behavior.
- *
- * @returns {UseMutationResult<AppModelType, Error, {data: AppModelType}, TContext>} An object returned by `useMutation`
- * which includes functions to start the mutation and properties that represent the different states of the mutation.
- */
-export declare const useUpdateDocMutation: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData, TContext = unknown>({ reference, options }: UseUpdateDocMutationOptions<AppModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<AppModelType, ReactNativeFirebase.NativeFirebaseError, UseUpdateDocMutationValues<AppModelType>, TContext>;

package/react-native/firestore/useUpdateDocMutation.js

@@ -1,37 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { updateDoc, getDoc } from "@react-native-firebase/firestore";
-import { useMemo } from "react";
-/**
- * Custom hook that sets up a mutation for updating a document in a Firestore database.
- *
- * This hook utilizes `useMutation` for performing asynchronous operations to update the document
- * and retrieve the latest data snapshot. The update functionality can be configured with a custom
- * converter if needed.
- *
- * @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.
- *
- * `converter` - An optional Firestore converter for transforming the database response into a custom type.
- *
- * `options` - Additional options that customize the mutation's behavior.
- *
- * @returns {UseMutationResult<AppModelType, Error, {data: AppModelType}, TContext>} An object returned by `useMutation`
- * which includes functions to start the mutation and properties that represent the different states of the mutation.
- */
-export const useUpdateDocMutation = ({ reference, options = {} }) => {
-    const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
-    return useMutation({
-        ...options,
-        mutationFn: async ({ data }) => {
-            if (!reference) {
-                throw new Error("Reference is undefined");
-            }
-            await updateDoc(reference, data);
-            const docSnap = await getDoc(reference);
-            return docSnap.data();
-        },
-        mutationKey
-    });
-};

package/react-native/firestore/utils/getDocData.d.ts

@@ -1,18 +0,0 @@
-import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
-import { GetDocSnapOptions } from "./getDocSnap";
-export type GetDocDataOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData> = GetDocSnapOptions<AppModelType>;
-/**
- * Asynchronously retrieves document data from a specified database and reference.
- * Utilizes the helper function `getDocSnap` to fetch the document snapshot and
- * checks if the document exists before returning its data.
- *
- * @param {Object} options - The options for fetching document data.
- * @param {FirebaseFirestore} options.db - The Firestore database instance.
- * @param {DocumentReference=} options.reference - The document reference. This is an optional parameter.
- * @param {string=} options.path - The path to the document in the database. This is an optional parameter.
- * @param {Array<string>=} options.pathSegments - The path segments for the document's path. This is an optional parameter.
- *
- * @returns {Promise<AppModelType | null>} Returns a promise that resolves to the document data if it exists,
- * or null if the document does not exist.
- */
-export declare const getDocData: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ db, reference, path, pathSegments }: GetDocDataOptions<AppModelType>) => Promise<AppModelType | null | undefined>;

package/react-native/firestore/utils/getDocData.js

@@ -1,22 +0,0 @@
-import { getDocSnap } from "./getDocSnap";
-/**
- * Asynchronously retrieves document data from a specified database and reference.
- * Utilizes the helper function `getDocSnap` to fetch the document snapshot and
- * checks if the document exists before returning its data.
- *
- * @param {Object} options - The options for fetching document data.
- * @param {FirebaseFirestore} options.db - The Firestore database instance.
- * @param {DocumentReference=} options.reference - The document reference. This is an optional parameter.
- * @param {string=} options.path - The path to the document in the database. This is an optional parameter.
- * @param {Array<string>=} options.pathSegments - The path segments for the document's path. This is an optional parameter.
- *
- * @returns {Promise<AppModelType | null>} Returns a promise that resolves to the document data if it exists,
- * or null if the document does not exist.
- */
-export const getDocData = async ({ db, reference, path, pathSegments }) => {
-    const docSnap = await getDocSnap({ db, reference, path, pathSegments });
-    if (docSnap && docSnap?.exists) {
-        return docSnap.data();
-    }
-    return null;
-};

package/react-native/firestore/utils/getDocRef.d.ts

@@ -1,19 +0,0 @@
-import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
-export type GetDocRefOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData> = {
-    db: FirebaseFirestoreTypes.Module;
-    reference?: FirebaseFirestoreTypes.CollectionReference<AppModelType> | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
-    path?: string;
-    pathSegments?: string[];
-};
-/**
- * Retrieves a document reference based on provided database options.
- * Either `reference` or `path` must be provided, not both.
- *
- * @param {Object} options - The options for getting a document reference.
- * @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 {FirebaseFirestoreTypes.DocumentReference<AppModelType>} The document reference.
- */
-export declare const getDocRef: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ db, reference, path, pathSegments }: GetDocRefOptions<AppModelType>) => Promise<FirebaseFirestoreTypes.DocumentReference<AppModelType>>;