react-query-firebase 1.3.2 → 2.0.0-rc1

package/dist/src/context/FirebaseContextProvider.js

@@ -1,10 +1,9 @@
 import React, { useEffect, useMemo } from "react";
 import { FirebaseContext } from "./FirebaseContext";
-import { connectAuthEmulator, getAuth } from "firebase/auth";
-import { getAnalytics, setAnalyticsCollectionEnabled, setConsent } from "firebase/analytics";
-import { getRemoteConfig } from "firebase/remote-config";
-import { connectFirestoreEmulator, initializeFirestore } from "firebase/firestore";
-import { initializeApp } from "firebase/app";
+import { connectAuthEmulator } from "@react-native-firebase/auth";
+import { setAnalyticsCollectionEnabled, setConsent } from "@react-native-firebase/analytics";
+import { connectFirestoreEmulator } from "@react-native-firebase/firestore";
+import firebase, { initializeApp } from "@react-native-firebase/app";
 /**
  * FirebaseContextProvider component configures and provides Firebase services to its children.
  * Initializes Firebase app and enables optional Firebase services such as Firestore, Auth, Analytics,
@@ -28,35 +27,34 @@ import { initializeApp } from "firebase/app";
  * };
  * ```
  */
-export const FirebaseContextProvider = ({ emulators, options, children, authEnabled = true, firestoreEnabled = true, analyticsEnabled = true, consentSettings = {}, remoteConfigEnabled = true, remoteConfigSettings, remoteConfigDefaults = {}, firestoreSettings }) => {
-    const firebase = useMemo(() => {
-        return initializeApp(options);
+export const FirebaseContextProvider = ({ platform, emulators, options, children, authEnabled = true, firestoreEnabled = true, analyticsEnabled = true, consentSettings = {}, remoteConfigEnabled = true, remoteConfigSettings, remoteConfigDefaults = {}, firestoreSettings }) => {
+    const internalFirebase = useMemo(() => {
+        return platform === "Web" ? initializeApp(options) : firebase;
     }, [options]);
     useEffect(() => {
-        setConsent({
-            ad_personalization: "denied",
-            ad_storage: "denied",
-            ad_user_data: "denied",
-            analytics_storage: "denied",
-            functionality_storage: "denied",
-            personalization_storage: "denied",
-            security_storage: "denied",
+        setConsent(firebase.analytics(), {
+            ad_personalization: false,
+            ad_storage: false,
+            ad_user_data: false,
+            analytics_storage: false,
+            functionality_storage: false,
+            personalization_storage: false,
+            security_storage: false,
             ...consentSettings
         });
-    }, [consentSettings]);
-    const firestore = useMemo(() => {
+    }, [consentSettings, firebase]);
+    const internalFirestore = useMemo(() => {
         if (firestoreEnabled) {
-            const localFirestore = initializeFirestore(firebase, firestoreSettings || {});
             if (emulators?.firestore?.host && emulators?.firestore?.port) {
-                connectFirestoreEmulator(localFirestore, emulators.firestore.host, emulators.firestore.port);
+                connectFirestoreEmulator(internalFirebase.firestore(), emulators.firestore.host, emulators.firestore.port);
             }
-            return localFirestore;
+            return internalFirebase.firestore();
         }
         return null;
-    }, [firestoreSettings, emulators?.firestore, firestoreEnabled]);
-    const auth = useMemo(() => {
+    }, [firestoreSettings, emulators?.firestore, firestoreEnabled, internalFirebase]);
+    const internalAuth = useMemo(() => {
         if (authEnabled) {
-            const localAuth = getAuth(firebase);
+            const localAuth = internalFirebase.auth();
             if (emulators?.auth?.host) {
                 connectAuthEmulator(localAuth, emulators?.auth?.host, {
                     disableWarnings: true
@@ -65,35 +63,37 @@ export const FirebaseContextProvider = ({ emulators, options, children, authEnab
             return localAuth;
         }
         return null;
-    }, [emulators?.auth, authEnabled]);
-    const analytics = useMemo(() => {
-        if (analyticsEnabled && options.measurementId && typeof window !== "undefined") {
-            return getAnalytics(firebase);
+    }, [emulators?.auth, authEnabled, internalFirebase]);
+    const internalAnalytics = useMemo(() => {
+        if (analyticsEnabled &&
+            options.measurementId &&
+            (typeof window !== "undefined" || platform === "ReactNative")) {
+            return internalFirebase.analytics();
         }
         return null;
-    }, [analyticsEnabled, options.measurementId]);
-    const remoteConfig = useMemo(() => {
-        if (remoteConfigEnabled && typeof window !== "undefined") {
-            const localRemoteConfig = getRemoteConfig(firebase);
+    }, [analyticsEnabled, options.measurementId, internalFirebase]);
+    const internalRemoteConfig = useMemo(() => {
+        if (remoteConfigEnabled && (typeof window !== "undefined" || platform === "ReactNative")) {
+            const localRemoteConfig = internalFirebase.remoteConfig();
             if (remoteConfigSettings) {
-                localRemoteConfig.settings.fetchTimeoutMillis = remoteConfigSettings.fetchTimeoutMillis;
+                localRemoteConfig.settings.fetchTimeMillis = remoteConfigSettings.fetchTimeMillis;
                 localRemoteConfig.settings.minimumFetchIntervalMillis = remoteConfigSettings.minimumFetchIntervalMillis;
                 localRemoteConfig.defaultConfig = remoteConfigDefaults;
             }
             return localRemoteConfig;
         }
         return null;
-    }, [remoteConfigEnabled]);
+    }, [remoteConfigEnabled, remoteConfigSettings, internalFirebase]);
     const contextValue = useMemo(() => ({
-        firebase,
-        auth,
-        analytics,
-        firestore,
-        remoteConfig
-    }), [firebase, auth, analytics, firestore, remoteConfig]);
+        firebase: internalFirebase,
+        auth: internalAuth,
+        analytics: internalAnalytics,
+        firestore: internalFirestore,
+        remoteConfig: internalRemoteConfig
+    }), [internalFirebase, internalAuth, internalAnalytics, internalFirestore, internalRemoteConfig]);
     useEffect(() => {
         if (contextValue.analytics) {
-            setAnalyticsCollectionEnabled(contextValue.analytics, consentSettings?.analytics_storage === "granted");
+            setAnalyticsCollectionEnabled(contextValue.analytics, !!consentSettings?.analytics_storage);
         }
     }, [consentSettings]);
     return (React.createElement(FirebaseContext.Provider, { value: contextValue }, children));

package/dist/src/firestore/useAddDocMutation.d.ts

@@ -1,23 +1,21 @@
 import { UseMutationOptions } from "@tanstack/react-query";
-import { DocumentData, WithFieldValue, CollectionReference, FirestoreDataConverter } from "firebase/firestore";
-import { FirebaseError } from "firebase/app";
+import { FirebaseFirestoreTypes, WithFieldValue } from "@react-native-firebase/firestore";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 export type UseAddDocMutationValues<AppModelType> = {
     data: WithFieldValue<AppModelType>;
 };
-export type UseAddDocMutationOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown> = {
-    reference: CollectionReference<AppModelType, DbModelType>;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
-    options?: Omit<UseMutationOptions<AppModelType, FirebaseError, UseAddDocMutationValues<AppModelType>, TContext>, "mutationFn" | "mutationKey">;
+export type UseAddDocMutationOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData, TContext = unknown> = {
+    reference: FirebaseFirestoreTypes.CollectionReference<AppModelType>;
+    options?: Omit<UseMutationOptions<AppModelType, ReactNativeFirebase.NativeFirebaseError, UseAddDocMutationValues<AppModelType>, TContext>, "mutationFn" | "mutationKey">;
 };
 /**
  * Provides a mutation hook to add a document to a Firestore collection utilizing React Query's `useMutation`.
  * It handles addition and optional conversion of the document data in Firestore.
  *
  * @param {Object} options - Options for the mutation hook
- * @param {FirebaseFirestore.CollectionReference<AppModelType>} options.reference - Firestore collection reference where the document should be added.
- * @param {FirebaseFirestore.FirestoreDataConverter<DbModelType>} [options.converter] - Optional data converter for reading and writing Firestore documents.
+ * @param {FirebaseFirestore.FirebaseFirestoreTypes.CollectionReference<AppModelType>} options.reference - Firestore collection reference where the document should be added.
  * @param {UseMutationOptions<AppModelType, Error, { data: DbModelType }, TContext>} [options.options={}] - Optional configuration for the mutation.
  *
  * @returns {UseMutationResult<AppModelType, Error, { data: DbModelType }, TContext>} The mutation hook result containing status, error, and data of the mutation process.
  */
-export declare const useAddDocMutation: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown>({ reference, converter, options }: UseAddDocMutationOptions<AppModelType, DbModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<AppModelType, FirebaseError, UseAddDocMutationValues<AppModelType>, TContext>;
+export declare const useAddDocMutation: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData, TContext = unknown>({ reference, options }: UseAddDocMutationOptions<AppModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<AppModelType, ReactNativeFirebase.NativeFirebaseError, UseAddDocMutationValues<AppModelType>, TContext>;

package/dist/src/firestore/useAddDocMutation.js

@@ -1,24 +1,23 @@
 import { useMutation } from "@tanstack/react-query";
-import { addDoc, getDoc } from "firebase/firestore";
+import { addDoc, getDoc } from "@react-native-firebase/firestore";
 import { useMemo } from "react";
 /**
  * Provides a mutation hook to add a document to a Firestore collection utilizing React Query's `useMutation`.
  * It handles addition and optional conversion of the document data in Firestore.
  *
  * @param {Object} options - Options for the mutation hook
- * @param {FirebaseFirestore.CollectionReference<AppModelType>} options.reference - Firestore collection reference where the document should be added.
- * @param {FirebaseFirestore.FirestoreDataConverter<DbModelType>} [options.converter] - Optional data converter for reading and writing Firestore documents.
+ * @param {FirebaseFirestore.FirebaseFirestoreTypes.CollectionReference<AppModelType>} options.reference - Firestore collection reference where the document should be added.
  * @param {UseMutationOptions<AppModelType, Error, { data: DbModelType }, TContext>} [options.options={}] - Optional configuration for the mutation.
  *
  * @returns {UseMutationResult<AppModelType, Error, { data: DbModelType }, TContext>} The mutation hook result containing status, error, and data of the mutation process.
  */
-export const useAddDocMutation = ({ reference, converter, options = {} }) => {
+export const useAddDocMutation = ({ reference, options = {} }) => {
     const mutationKey = useMemo(() => [reference.path], [reference.path]);
     return useMutation({
         ...options,
         mutationFn: async ({ data }) => {
             const docRef = await addDoc(reference, data);
-            const docSnap = await getDoc(converter ? docRef.withConverter(converter) : docRef);
+            const docSnap = await getDoc(docRef);
             return docSnap.data();
         },
         mutationKey

package/dist/src/firestore/useBatchWrite.d.ts

@@ -1,9 +1,9 @@
 import { UseMutationOptions } from "@tanstack/react-query";
-import { WriteBatch } from "firebase/firestore";
-import { FirebaseError } from "firebase/app";
-export type UseBatchWriteVariables = (batch: WriteBatch) => Promise<void> | void;
+import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
+export type UseBatchWriteVariables = (batch: FirebaseFirestoreTypes.WriteBatch) => Promise<void> | void;
 export type UseBatchWriteOptions<TContext = unknown> = {
-    options?: Omit<UseMutationOptions<void, FirebaseError, UseBatchWriteVariables, TContext>, "mutationFn">;
+    options?: Omit<UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, UseBatchWriteVariables, TContext>, "mutationFn">;
 };
 /**
  * Custom hook to perform batch write operations using Firestore.
@@ -12,4 +12,4 @@ export type UseBatchWriteOptions<TContext = unknown> = {
  * @param {Object} options - The configuration options for the mutation operation.
  * @returns {Object} Returns an object composed of elements returned by useMutation, including properties such as status, and functions to trigger and control the mutation process.
  */
-export declare const useBatchWrite: <TContext = unknown>({ options }?: UseBatchWriteOptions<TContext>) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseBatchWriteVariables, TContext>;
+export declare const useBatchWrite: <TContext = unknown>({ options }?: UseBatchWriteOptions<TContext>) => import("@tanstack/react-query").UseMutationResult<void, ReactNativeFirebase.NativeFirebaseError, UseBatchWriteVariables, TContext>;

package/dist/src/firestore/useBatchWrite.js

@@ -1,5 +1,5 @@
 import { useMutation } from "@tanstack/react-query";
-import { writeBatch } from "firebase/firestore";
+import { writeBatch } from "@react-native-firebase/firestore";
 import { useFirestore } from "./useFirestore";
 /**
  * Custom hook to perform batch write operations using Firestore.

package/dist/src/firestore/useCollectionReference.d.ts

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

package/dist/src/firestore/useCollectionReference.js

@@ -1,4 +1,4 @@
-import { collection } from "firebase/firestore";
+import { collection } from "@react-native-firebase/firestore";
 import { useMemo } from "react";
 import { useFirestore } from "./useFirestore";
 /**
@@ -6,7 +6,7 @@ import { useFirestore } from "./useFirestore";
  *
  * This hook utilizes useMemo for optimization, ensuring the collection reference is recalculated only when its dependencies change.
  *
- * @param {UseCollectionReferenceOptions<AppModelType, DbModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
+ * @param {UseCollectionReferenceOptions<AppModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
  * @param {string} options.path - The base path for the collection.
  * @param {FirestoreReference} options.reference - An optional Firestore reference object that should be of type "collection".
  * @param {string[]} options.pathSegments - Additional path segments to append to the base path.
@@ -17,8 +17,6 @@ export const useCollectionReference = ({ path, reference, pathSegments }) => {
     return useMemo(() => {
         return !reference
             ? collection(db, path || "", ...(pathSegments || []))
-            : reference.type === "collection"
-                ? collection(reference, path, ...(pathSegments || []))
-                : collection(reference, path, ...(pathSegments || []));
+            : collection(reference, path, ...(pathSegments || []));
     }, [path, reference?.path, pathSegments]);
 };

package/dist/src/firestore/useCompositeFilter.d.ts

@@ -1,14 +1,14 @@
-import { DocumentData, QueryCompositeFilterConstraint, WhereFilterOp } from "firebase/firestore";
-type CompositeFilterDocumentData = DocumentData;
-export type QueryElement<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = Partial<QueryCompositeFilterConstraint> & {
+import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
+type CompositeFilterDocumentData = FirebaseFirestoreTypes.DocumentData;
+export type QueryElement<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = Partial<FirebaseFirestoreTypes.QueryCompositeFilterConstraint> & {
     children?: QueryElement[];
     field?: keyof (DbModelType & {
         documentId?: string[];
     });
     value?: DbModelType[keyof DbModelType];
-    op?: WhereFilterOp;
+    op?: FirebaseFirestoreTypes.WhereFilterOp;
 };
-export type CompositeFilter<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = QueryCompositeFilterConstraint & {
+export type CompositeFilter<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = FirebaseFirestoreTypes.QueryCompositeFilterConstraint & {
     children: QueryElement<DbModelType & {
         documentId?: string[];
     }>[];
@@ -26,5 +26,5 @@ export type UseCompositeFilter<DbModelType extends CompositeFilterDocumentData =
  *
  * @returns {(Function|undefined)} A composite query filter constraint function formed by combining subqueries or undefined if there are no valid constraints.
  */
-export declare const useCompositeFilter: <DbModelType extends CompositeFilterDocumentData = DocumentData>({ query }: UseCompositeFilter<DbModelType>) => QueryCompositeFilterConstraint | undefined;
+export declare const useCompositeFilter: <DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData>({ query }: UseCompositeFilter<DbModelType>) => FirebaseFirestoreTypes.QueryCompositeFilterConstraint | undefined;
 export {};

package/dist/src/firestore/useCompositeFilter.js

@@ -1,24 +1,26 @@
-import { and, documentId, or, where } from "firebase/firestore";
+import firebase, { and, or, where } from "@react-native-firebase/firestore";
 import { useMemo } from "react";
 /**
  * Constructs a composite query filter based on the provided query structure.
  * It recursively builds query constraints using logical "or" or "and" operators.
  *
  * @param {QueryElement<DbModelType>} query - The query element or structure to be evaluated and transformed into filter constraints.
- * @returns {QueryFilterConstraint | null} A constructed query filter constraint based on the input query, or null if no valid constraints can be derived.
+ * @returns {QueryFieldFilterConstraint | null} A constructed query filter constraint based on the input query, or null if no valid constraints can be derived.
  */
 const buildCompositeQuery = (query) => {
     if (query.children) {
         const queryConstraints = query.children
-            .map((subQuery) => buildCompositeQuery(subQuery))
+            .map((subQuery) => {
+            if (subQuery.field && subQuery.op) {
+                return where(query.field === "documentId" ? firebase.FieldPath.documentId() : query.field, subQuery.op, query.value);
+            }
+            return buildCompositeQuery(subQuery);
+        })
             .filter((constraint) => !!constraint);
         if (queryConstraints.length <= 0) {
             return null;
         }
-        return query.type === "or" ? or(...queryConstraints) : and(...queryConstraints);
-    }
-    if (query.field && query.op) {
-        return where(query.field === "documentId" ? documentId() : query.field, query.op, query.value);
+        return query.operator === "OR" ? or(...queryConstraints) : and(...queryConstraints);
     }
     return null;
 };
@@ -34,10 +36,11 @@ const buildCompositeQuery = (query) => {
  */
 export const useCompositeFilter = ({ query }) => {
     return useMemo(() => {
-        const queryConstraints = (query?.children?.map?.((subQuery) => buildCompositeQuery(subQuery))?.filter)?.((constraint) => !!constraint) ?? [];
+        const queryConstraints = (query?.children?.map?.((subQuery) => buildCompositeQuery(subQuery))
+            ?.filter)?.((constraint) => !!constraint) ?? [];
         if (queryConstraints.length <= 0) {
             return undefined;
         }
-        return query?.type === "or" ? or(...queryConstraints) : and(...queryConstraints);
+        return query?.operator === "OR" ? or(...queryConstraints) : and(...queryConstraints);
     }, [query]);
 };

package/dist/src/firestore/useCountQuery.d.ts

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

package/dist/src/firestore/useCountQuery.js

@@ -1,4 +1,4 @@
-import { getCountFromServer, query } from "firebase/firestore";
+import { getCountFromServer, query } from "@react-native-firebase/firestore";
 import { useQuery as useReactQuery } from "@tanstack/react-query";
 /**
  * Executes a query with specified constraints and returns the count of matched documents.
@@ -6,8 +6,8 @@ import { useQuery as useReactQuery } from "@tanstack/react-query";
  * This function utilizes React Query to asynchronously fetch the count of documents from a server database
  * that match the provided query constraints and an optional composite filter.
  *
- * @param {UseCountQueryOptions<AppModelType, DbModelType>} options - Configuration options for the query.
- * @param {AppModelType extends DocumentData = DocumentData} [options.options] - Additional options for the React Query.
+ * @param {UseCountQueryOptions<AppModelType>} options - Configuration options for the query.
+ * @param {AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData} [options.options] - Additional options for the React Query.
  * @param {unknown} [options.query] - Reference to the query object to be executed.
  * @param {unknown[]} [options.queryConstraints=[]] - An array of constraints to apply to the query.
  * @param {unknown} [options.compositeFilter] - An optional composite filter to apply to the query.

package/dist/src/firestore/useDeleteDocMutation.d.ts

@@ -1,12 +1,12 @@
 import { UseMutationOptions } from "@tanstack/react-query";
-import { DocumentData, WithFieldValue, DocumentReference } from "firebase/firestore";
-import { FirebaseError } from "firebase/app";
+import { FirebaseFirestoreTypes, WithFieldValue } from "@react-native-firebase/firestore";
+import { ReactNativeFirebase } from "@react-native-firebase/app";
 export type UseDeleteDocMutationValues<AppModelType> = {
     data: WithFieldValue<AppModelType>;
 };
-export type UseDeleteDocMutationOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown> = {
-    reference: DocumentReference<AppModelType, DbModelType> | null;
-    options?: Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "mutationFn" | "mutationKey">;
+export type UseDeleteDocMutationOptions<AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData, TContext = unknown> = {
+    reference: FirebaseFirestoreTypes.DocumentReference<AppModelType> | null;
+    options?: Omit<UseMutationOptions<void, ReactNativeFirebase.NativeFirebaseError, void, TContext>, "mutationFn" | "mutationKey">;
 };
 /**
  * A custom hook that provides a mutation function to delete a document from the database.
@@ -15,4 +15,4 @@ export type UseDeleteDocMutationOptions<AppModelType extends DocumentData = Docu
  * @param {object} options.options - Additional options for the mutation, if any (default is an empty object).
  * @returns {UseMutationResult} An object returned by the `useMutation` hook which includes properties and methods to control the mutation's execution and track its state.
  */
-export declare const useDeleteDocMutation: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown>({ reference, options }: UseDeleteDocMutationOptions<AppModelType, DbModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, void, TContext>;
+export declare const useDeleteDocMutation: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData, TContext = unknown>({ reference, options }: UseDeleteDocMutationOptions<AppModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<void, ReactNativeFirebase.NativeFirebaseError, void, TContext>;

package/dist/src/firestore/useDeleteDocMutation.js

@@ -1,5 +1,5 @@
 import { useMutation } from "@tanstack/react-query";
-import { deleteDoc } from "firebase/firestore";
+import { deleteDoc } from "@react-native-firebase/firestore";
 import { useMemo } from "react";
 /**
  * A custom hook that provides a mutation function to delete a document from the database.

package/dist/src/firestore/useDocReference.d.ts

@@ -1,6 +1,6 @@
-import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
-export type UseDocReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+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[];
 };
@@ -9,11 +9,11 @@ export type UseDocReferenceOptions<AppModelType, DbModelType extends DocumentDat
  * This hook facilitates the retrieval of a Firestore document reference based on given options such as path and reference data.
  * The reference is updated whenever the associated path, reference, or path segments change.
  *
- * @param {UseDocReferenceOptions<AppModelType, DbModelType>} options - Configuration options for setting up the document reference.
+ * @param {UseDocReferenceOptions<AppModelType>} options - Configuration options for setting up the document reference.
  * @param {string} options.path - The path to the Firestore document.
  * @param {DbModelType} options.reference - Reference data for the document, providing additional context or specifics.
  * @param {string[]} options.pathSegments - Parts of the path to construct the full document path dynamically.
  *
- * @returns {DocumentReference<AppModelType, DbModelType> | null} The Firestore document reference corresponding to the provided path and options, or null if not initialized.
+ * @returns {DocumentReference<AppModelType> | null} The Firestore document reference corresponding to the provided path and options, or null if not initialized.
  */
-export declare const useDocReference: <AppModelType, DbModelType extends DocumentData = DocumentData>({ path, reference, pathSegments }: UseDocReferenceOptions<AppModelType, DbModelType>) => DocumentReference<AppModelType, DbModelType> | null;
+export declare const useDocReference: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ path, reference, pathSegments }: UseDocReferenceOptions<AppModelType>) => FirebaseFirestoreTypes.DocumentReference<AppModelType> | null;

package/dist/src/firestore/useDocReference.js

@@ -1,4 +1,4 @@
-import { doc } from "firebase/firestore";
+import { doc } from "@react-native-firebase/firestore";
 import { useEffect, useRef } from "react";
 import { useFirestore } from "./useFirestore";
 /**
@@ -6,34 +6,30 @@ import { useFirestore } from "./useFirestore";
  * If a reference is not provided, it constructs a document reference using the Firestore instance, path, and path segments.
  *
  * @param {Firestore} db - The Firestore database instance used to create the document reference.
- * @param {UseDocReferenceOptions<AppModelType, DbModelType>} options - An object containing the path, path segments, and optional reference.
+ * @param {UseDocReferenceOptions<AppModelType>} options - An object containing the path, path segments, and optional reference.
  * @param {string} options.path - The path to the document in the Firestore database.
  * @param {string[]} [options.pathSegments] - Optional additional segments to join with the path.
  * @param {DocumentReference | CollectionReference} [options.reference] - Optional Firestore reference object that influences how the document reference is constructed.
  *
- * @returns {DocumentReference<AppModelType, DbModelType> | null} A Firestore document reference if the path is specified; otherwise, returns null if path is not provided.
+ * @returns {DocumentReference<AppModelType> | null} A Firestore document reference if the path is specified; otherwise, returns null if path is not provided.
  */
 const getDocReference = (db, { path, pathSegments, reference }) => {
     if (!path) {
         return null;
     }
-    return (!reference
-        ? doc(db, path || "", ...(pathSegments || []))
-        : reference.type === "collection"
-            ? doc(reference, path, ...(pathSegments || []))
-            : doc(reference, path, ...(pathSegments || [])));
+    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, DbModelType>} options - Configuration options for setting up the document reference.
+ * @param {UseDocReferenceOptions<AppModelType>} options - Configuration options for setting up the document reference.
  * @param {string} options.path - The path to the Firestore document.
  * @param {DbModelType} options.reference - Reference data for the document, providing additional context or specifics.
  * @param {string[]} options.pathSegments - Parts of the path to construct the full document path dynamically.
  *
- * @returns {DocumentReference<AppModelType, DbModelType> | null} The Firestore document reference corresponding to the provided path and options, or null if not initialized.
+ * @returns {DocumentReference<AppModelType> | null} The Firestore document reference corresponding to the provided path and options, or null if not initialized.
  */
 export const useDocReference = ({ path, reference, pathSegments }) => {
     const db = useFirestore();

package/dist/src/firestore/useDocReferences.d.ts

@@ -1,6 +1,6 @@
-import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
-export type UseDocReferencesOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+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[];
 };
@@ -14,10 +14,10 @@ export type UseDocReferencesOptions<AppModelType, DbModelType extends DocumentDa
  * to interact with the Firestore database documents. It uses memoization to optimize
  * reference generation.
  *
- * @param {UseDocReferencesOptions<AppModelType, DbModelType>[]} references - An array of options
+ * @param {UseDocReferencesOptions<AppModelType>[]} references - An array of options
  * specifying how to generate document references. Each option may include a `path`
  * as a string, a `reference` as a Firestore reference, and `pathSegments` as an array of strings.
- * @returns {DocumentReference<AppModelType, DbModelType>[]} An array of Firestore document references
+ * @returns {DocumentReference<AppModelType>[]} An array of Firestore document references
  * generated from the options provided.
  */
-export declare const useDocReferences: <AppModelType, DbModelType extends DocumentData = DocumentData>(references: UseDocReferencesOptions<AppModelType, DbModelType>[]) => DocumentReference<AppModelType, DbModelType>[];
+export declare const useDocReferences: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>(references: UseDocReferencesOptions<AppModelType>[]) => FirebaseFirestoreTypes.DocumentReference<AppModelType>[];

package/dist/src/firestore/useDocReferences.js

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

package/dist/src/firestore/useFirestore.d.ts

@@ -4,4 +4,4 @@
  *
  * @returns {firestore.Firestore} The Firestore instance from the Firebase context.
  */
-export declare const useFirestore: () => import("@firebase/firestore").Firestore;
+export declare const useFirestore: () => import("@react-native-firebase/firestore").FirebaseFirestoreTypes.Module;

package/dist/src/firestore/useGetDocData.d.ts

@@ -1,10 +1,10 @@
-import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+import { FirebaseFirestoreTypes } from "@react-native-firebase/firestore";
 import { UseQueryOptions } from "@tanstack/react-query";
-type UseGetDocOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = {
-    options: Omit<UseQueryOptions<AppModelType | null, Error, AppModelType>, "queryFn"> & Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
+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: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    reference: FirebaseFirestoreTypes.CollectionReference<AppModelType> | FirebaseFirestoreTypes.DocumentReference<AppModelType>;
 };
 /**
  * Custom React Hook to retrieve document data from Firestore using specified parameters.
@@ -14,5 +14,5 @@ type UseGetDocOptions<AppModelType extends DocumentData = DocumentData, DbModelT
  * @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 DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, reference, path, pathSegments }: UseGetDocOptions<AppModelType, DbModelType>) => import("@tanstack/react-query").UseQueryResult<AppModelType, Error>;
+export declare const useGetDocData: <AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData>({ options, reference, path, pathSegments }: UseGetDocOptions<AppModelType>) => import("@tanstack/react-query").UseQueryResult<AppModelType, Error>;
 export {};