react-query-firebase 2.1.0 → 2.1.2

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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,34 @@
+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/useQueryConstraints.d.ts

@@ -0,0 +1,54 @@
+import { AppModel } from "../../types/AppModel";
+import { type NonFilterQueryConstraint } from "../../types/QueryConstraints";
+/**
+ * @inline
+ */
+export type UseQueryConstraints<AppModelType extends AppModel = AppModel> = {
+    /**
+     * A list of constraints such as limit, order, offset.
+     */
+    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.
+ *
+ * @group Hook
+ *
+ * @param {UseQueryConstraints<AppModelType>} options
+ *
+ * @returns {FirebaseFirestoreTypes.QueryNonFilterConstraint}
+ *
+ * @example
+ * ```jsx
+ * const firebaseConfig = {};
+ * export const constraint = useQueryConstraints([
+ *  {
+ *      type: 'limit',
+ *      limit: 1
+ *  }
+ * ]};
+ * ```
+ */
+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)[];

package/react-native/firestore/useQueryConstraints.js

@@ -0,0 +1,66 @@
+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);
+    }
+};
+/**
+ * A hook to build a list of non-filter query constraints for firebase queries.
+ * It uses buildQueryConstraint method and useMemo hook.
+ *
+ * @group Hook
+ *
+ * @param {UseQueryConstraints<AppModelType>} options
+ *
+ * @returns {FirebaseFirestoreTypes.QueryNonFilterConstraint}
+ *
+ * @example
+ * ```jsx
+ * const firebaseConfig = {};
+ * export const constraint = useQueryConstraints([
+ *  {
+ *      type: 'limit',
+ *      limit: 1
+ *  }
+ * ]};
+ * ```
+ */
+export const useQueryConstraints = ({ constraints }) => {
+    return useMemo(() => {
+        return constraints.map(buildQueryConstraint);
+    }, [constraints]);
+};

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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,19 @@
+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>>;

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

@@ -0,0 +1,21 @@
+import { doc } from "@react-native-firebase/firestore";
+/**
+ * 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 const getDocRef = async ({ db, reference, path, pathSegments }) => {
+    if (!reference && !path) {
+        throw new Error("One of the options must be provided: path or reference.");
+    }
+    const docRef = !reference
+        ? doc(db, path, ...(pathSegments || []))
+        : doc(reference, path, ...(pathSegments || []));
+    return docRef;
+};

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

@@ -0,0 +1,20 @@
+import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
+import { GetDocRefOptions } from "./getDocRef";
+export type GetDocSnapOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData> = GetDocRefOptions<AppModelType>;
+/**
+ * Asynchronously retrieves a document snapshot from Firestore using a specified document reference
+ * or path information. This function handles getting the appropriate document reference based on
+ * the parameters provided, and then fetches the document data from Firestore.
+ *
+ * @param {GetDocSnapOptions<AppModelType, DbModelType>} options - An object containing options
+ *                                                                for retrieving the document
+ *                                                                snapshot.
+ * @param {DocumentData} options.db - The Firestore database instance to perform the operation on.
+ * @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<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 declare const getDocSnap: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ db, reference, path, pathSegments }: GetDocSnapOptions<AppModelType>) => Promise<FirebaseFirestoreTypes.DocumentSnapshot<AppModelType> | null>;

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

@@ -0,0 +1,25 @@
+import { getDoc as firestoreGetDoc } from "@react-native-firebase/firestore";
+import { getDocRef } from "./getDocRef";
+/**
+ * Asynchronously retrieves a document snapshot from Firestore using a specified document reference
+ * or path information. This function handles getting the appropriate document reference based on
+ * the parameters provided, and then fetches the document data from Firestore.
+ *
+ * @param {GetDocSnapOptions<AppModelType, DbModelType>} options - An object containing options
+ *                                                                for retrieving the document
+ *                                                                snapshot.
+ * @param {DocumentData} options.db - The Firestore database instance to perform the operation on.
+ * @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<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 ({ db, reference, path, pathSegments }) => {
+    const docRef = await getDocRef({ db, reference, path, pathSegments });
+    if (docRef) {
+        return await firestoreGetDoc(docRef);
+    }
+    return null;
+};

package/react-native/remoteConfig/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./useFetchAndActivate";
+export * from "./useGetValue";
+export * from "./useRemoteConfig";

package/react-native/remoteConfig/index.js

@@ -0,0 +1,3 @@
+export * from "./useFetchAndActivate";
+export * from "./useGetValue";
+export * from "./useRemoteConfig";

package/react-native/remoteConfig/useFetchAndActivate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Custom hook to fetch and activate remote configuration settings.
+ * Initializes remote configuration, fetches, activates it, and tracks the fetch status.
+ * @returns {Object} An object containing:
+ * - {Function} fetchAndActivate - Callback function to fetch and activate remote configuration.
+ * - {Boolean} isFetched - Boolean representing whether the fetch-and-activate process completed.
+ */
+export declare const useFetchAndActivate: () => {
+    fetchAndActivate: () => Promise<void>;
+    isFetched: boolean;
+};

package/react-native/remoteConfig/useFetchAndActivate.js

@@ -0,0 +1,31 @@
+import { useRemoteConfig } from "./useRemoteConfig";
+import { ensureInitialized, fetchAndActivate } from "@react-native-firebase/remote-config";
+import { useCallback, useMemo, useState } from "react";
+/**
+ * Custom hook to fetch and activate remote configuration settings.
+ * Initializes remote configuration, fetches, activates it, and tracks the fetch status.
+ * @returns {Object} An object containing:
+ * - {Function} fetchAndActivate - Callback function to fetch and activate remote configuration.
+ * - {Boolean} isFetched - Boolean representing whether the fetch-and-activate process completed.
+ */
+export const useFetchAndActivate = () => {
+    const remoteConfig = useRemoteConfig();
+    const [isFetched, setIsFetched] = useState(false);
+    const fetchAndActivateCallback = useCallback(async () => {
+        try {
+            if (remoteConfig) {
+                await ensureInitialized(remoteConfig);
+                await fetchAndActivate(remoteConfig);
+                setIsFetched(true);
+            }
+        }
+        catch (e) {
+            setIsFetched(true);
+            console.log(`Cannot read remote config: ${e?.message}`);
+        }
+    }, [remoteConfig]);
+    return useMemo(() => ({
+        fetchAndActivate: fetchAndActivateCallback,
+        isFetched
+    }), [isFetched, fetchAndActivateCallback]);
+};

package/react-native/remoteConfig/useGetValue.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Custom hook to retrieve a value associated with a specified key from remote configuration.
+ * Utilizes memoization to optimize performance by recalculating the result only if dependencies change.
+ * @param {string} key - The key for which the corresponding value is to be fetched from the remote configuration.
+ * @returns {any | null} The value associated with the specified key if available, otherwise null.
+ */
+export declare const useGetValue: (key: string) => import("@react-native-firebase/remote-config").FirebaseRemoteConfigTypes.ConfigValue | null;

package/react-native/remoteConfig/useGetValue.js

@@ -0,0 +1,15 @@
+import { getValue } from "@react-native-firebase/remote-config";
+import { useRemoteConfig } from "./useRemoteConfig";
+import { useMemo } from "react";
+/**
+ * Custom hook to retrieve a value associated with a specified key from remote configuration.
+ * Utilizes memoization to optimize performance by recalculating the result only if dependencies change.
+ * @param {string} key - The key for which the corresponding value is to be fetched from the remote configuration.
+ * @returns {any | null} The value associated with the specified key if available, otherwise null.
+ */
+export const useGetValue = (key) => {
+    const remoteConfig = useRemoteConfig();
+    return useMemo(() => {
+        return remoteConfig ? getValue(remoteConfig, key) : null;
+    }, [remoteConfig, key]);
+};

package/react-native/remoteConfig/useRemoteConfig.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook to access the Firebase Remote Config instance from the context.
+ * @returns {RemoteConfig} The remoteConfig object from the Firebase context.
+ */
+export declare const useRemoteConfig: () => import("@react-native-firebase/remote-config").FirebaseRemoteConfigTypes.Module;

package/react-native/remoteConfig/useRemoteConfig.js

@@ -0,0 +1,10 @@
+import { useContext } from "react";
+import { FirebaseContext } from "../context/FirebaseContext";
+/**
+ * Hook to access the Firebase Remote Config instance from the context.
+ * @returns {RemoteConfig} The remoteConfig object from the Firebase context.
+ */
+export const useRemoteConfig = () => {
+    const { remoteConfig } = useContext(FirebaseContext);
+    return remoteConfig;
+};

package/types/AppModel.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generic definition for a data model
+ * @group Models
+ */
+export type AppModel = {
+    [key: string]: unknown;
+};

package/types/AppModel.js

@@ -0,0 +1 @@
+export {};