react-query-firebase 2.5.0 → 2.6.1

package/package.json

@@ -74,5 +74,5 @@
         "docs:build": "vitepress build docs",
         "docs:preview": "vitepress preview docs"
     },
-    "version": "2.5.0"
+    "version": "2.6.1"
 }

package/react-native/context/FirebaseContextProvider.js

@@ -1,10 +1,10 @@
 import React, { useEffect, useMemo } from "react";
 import { FirebaseContext } from "./FirebaseContext";
-import auth, { connectAuthEmulator } from "@react-native-firebase/auth";
-import analytics, { setAnalyticsCollectionEnabled, setConsent } from "@react-native-firebase/analytics";
-import remoteConfig from "@react-native-firebase/remote-config";
-import firestore, { connectFirestoreEmulator } from "@react-native-firebase/firestore";
-import firebase from "@react-native-firebase/app";
+import { connectAuthEmulator, getAuth } from "@react-native-firebase/auth";
+import { setAnalyticsCollectionEnabled, setConsent, getAnalytics } from "@react-native-firebase/analytics";
+import { getRemoteConfig } from "@react-native-firebase/remote-config";
+import { connectFirestoreEmulator, getFirestore } from "@react-native-firebase/firestore";
+import { getApp } 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,
@@ -29,9 +29,9 @@ import firebase from "@react-native-firebase/app";
  * ```
  */
 export const FirebaseContextProvider = ({ emulators, children, authEnabled = true, firestoreEnabled = true, analyticsEnabled = true, consentSettings = {}, remoteConfigEnabled = true, remoteConfigSettings, remoteConfigDefaults = {}, firestoreSettings }) => {
-    const internalFirebase = useMemo(() => firebase, []);
+    const internalFirebase = useMemo(() => getApp(), []);
     useEffect(() => {
-        setConsent(analytics(), {
+        setConsent(getAnalytics(internalFirebase), {
             ad_personalization: false,
             ad_storage: false,
             ad_user_data: false,
@@ -41,23 +41,23 @@ export const FirebaseContextProvider = ({ emulators, children, authEnabled = tru
             security_storage: false,
             ...consentSettings
         });
-    }, [consentSettings]);
+    }, [consentSettings, internalFirebase]);
     const internalFirestore = useMemo(() => {
         if (firestoreEnabled) {
             if (emulators?.firestore?.host && emulators?.firestore?.port) {
-                connectFirestoreEmulator(firestore(), emulators.firestore.host, emulators.firestore.port);
+                connectFirestoreEmulator(getFirestore(internalFirebase), emulators.firestore.host, emulators.firestore.port);
             }
-            const localFirestore = firestore();
+            const localFirestore = getFirestore(internalFirebase);
             if (firestoreSettings) {
                 localFirestore.settings(firestoreSettings);
             }
             return localFirestore;
         }
         return null;
-    }, [emulators?.firestore, firestoreEnabled, firestoreSettings]);
+    }, [emulators?.firestore, firestoreEnabled, internalFirebase, firestoreSettings]);
     const internalAuth = useMemo(() => {
         if (authEnabled) {
-            const localAuth = auth();
+            const localAuth = getAuth(internalFirebase);
             if (emulators?.auth?.host) {
                 connectAuthEmulator(localAuth, emulators?.auth?.host, {
                     disableWarnings: true
@@ -66,16 +66,16 @@ export const FirebaseContextProvider = ({ emulators, children, authEnabled = tru
             return localAuth;
         }
         return null;
-    }, [emulators?.auth, authEnabled]);
+    }, [emulators?.auth, authEnabled, internalFirebase]);
     const internalAnalytics = useMemo(() => {
         if (analyticsEnabled) {
-            return analytics();
+            return getAnalytics(internalFirebase);
         }
         return null;
-    }, [analyticsEnabled]);
+    }, [analyticsEnabled, internalFirebase]);
     const internalRemoteConfig = useMemo(() => {
         if (remoteConfigEnabled) {
-            const localRemoteConfig = remoteConfig();
+            const localRemoteConfig = getRemoteConfig(internalFirebase);
             if (remoteConfigSettings) {
                 localRemoteConfig.settings.fetchTimeMillis = remoteConfigSettings.fetchTimeMillis;
                 localRemoteConfig.settings.minimumFetchIntervalMillis = remoteConfigSettings.minimumFetchIntervalMillis;
@@ -84,7 +84,7 @@ export const FirebaseContextProvider = ({ emulators, children, authEnabled = tru
             return localRemoteConfig;
         }
         return null;
-    }, [remoteConfigEnabled, remoteConfigSettings, remoteConfigDefaults]);
+    }, [remoteConfigEnabled, remoteConfigSettings, remoteConfigDefaults, internalFirebase]);
     const contextValue = useMemo(() => ({
         firebase: internalFirebase,
         auth: internalAuth,

package/react-native/context/FirebaseContextProvider.tsx

@@ -1,14 +1,15 @@
 import React, { PropsWithChildren, useEffect, useMemo } from "react";
 import { FirebaseContext, FirebaseContextValue } from "./FirebaseContext";
-import auth, { connectAuthEmulator } from "@react-native-firebase/auth";
-import analytics, {
+import { connectAuthEmulator, getAuth } from "@react-native-firebase/auth";
+import {
     FirebaseAnalyticsTypes,
     setAnalyticsCollectionEnabled,
-    setConsent
+    setConsent,
+    getAnalytics
 } from "@react-native-firebase/analytics";
-import remoteConfig, { FirebaseRemoteConfigTypes } from "@react-native-firebase/remote-config";
-import firestore, { connectFirestoreEmulator } from "@react-native-firebase/firestore";
-import firebase, { ReactNativeFirebase } from "@react-native-firebase/app";
+import { FirebaseRemoteConfigTypes, getRemoteConfig } from "@react-native-firebase/remote-config";
+import { connectFirestoreEmulator, getFirestore } from "@react-native-firebase/firestore";
+import { ReactNativeFirebase, getApp } from "@react-native-firebase/app";
 
 /**
  * @inline
@@ -164,10 +165,10 @@ export const FirebaseContextProvider: React.FC<FirebaseContextProviderProps> = (
     remoteConfigDefaults = {},
     firestoreSettings
 }) => {
-    const internalFirebase = useMemo(() => firebase, []);
+    const internalFirebase = useMemo(() => getApp(), []);
 
     useEffect(() => {
-        setConsent(analytics(), {
+        setConsent(getAnalytics(internalFirebase), {
             ad_personalization: false,
             ad_storage: false,
             ad_user_data: false,
@@ -177,15 +178,19 @@ export const FirebaseContextProvider: React.FC<FirebaseContextProviderProps> = (
             security_storage: false,
             ...consentSettings
         });
-    }, [consentSettings]);
+    }, [consentSettings, internalFirebase]);
 
     const internalFirestore = useMemo(() => {
         if (firestoreEnabled) {
             if (emulators?.firestore?.host && emulators?.firestore?.port) {
-                connectFirestoreEmulator(firestore(), emulators.firestore.host, emulators.firestore.port);
+                connectFirestoreEmulator(
+                    getFirestore(internalFirebase),
+                    emulators.firestore.host,
+                    emulators.firestore.port
+                );
             }
 
-            const localFirestore = firestore();
+            const localFirestore = getFirestore(internalFirebase);
             if (firestoreSettings) {
                 localFirestore.settings(firestoreSettings);
             }
@@ -193,11 +198,11 @@ export const FirebaseContextProvider: React.FC<FirebaseContextProviderProps> = (
         }
 
         return null;
-    }, [emulators?.firestore, firestoreEnabled, firestoreSettings]);
+    }, [emulators?.firestore, firestoreEnabled, internalFirebase, firestoreSettings]);
 
     const internalAuth = useMemo(() => {
         if (authEnabled) {
-            const localAuth = auth();
+            const localAuth = getAuth(internalFirebase);
             if (emulators?.auth?.host) {
                 connectAuthEmulator(localAuth, emulators?.auth?.host, {
                     disableWarnings: true
@@ -206,18 +211,18 @@ export const FirebaseContextProvider: React.FC<FirebaseContextProviderProps> = (
             return localAuth;
         }
         return null;
-    }, [emulators?.auth, authEnabled]);
+    }, [emulators?.auth, authEnabled, internalFirebase]);
 
     const internalAnalytics = useMemo(() => {
         if (analyticsEnabled) {
-            return analytics();
+            return getAnalytics(internalFirebase);
         }
         return null;
-    }, [analyticsEnabled]);
+    }, [analyticsEnabled, internalFirebase]);
 
     const internalRemoteConfig = useMemo(() => {
         if (remoteConfigEnabled) {
-            const localRemoteConfig = remoteConfig();
+            const localRemoteConfig = getRemoteConfig(internalFirebase);
             if (remoteConfigSettings) {
                 localRemoteConfig.settings.fetchTimeMillis = remoteConfigSettings.fetchTimeMillis;
                 localRemoteConfig.settings.minimumFetchIntervalMillis = remoteConfigSettings.minimumFetchIntervalMillis;
@@ -226,7 +231,7 @@ export const FirebaseContextProvider: React.FC<FirebaseContextProviderProps> = (
             return localRemoteConfig;
         }
         return null;
-    }, [remoteConfigEnabled, remoteConfigSettings, remoteConfigDefaults]);
+    }, [remoteConfigEnabled, remoteConfigSettings, remoteConfigDefaults, internalFirebase]);
 
     const contextValue = useMemo(
         () => ({

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

@@ -20,3 +20,4 @@ export * from "./utils/getDocSnap";
 export * from "./utils/getDocRef";
 export * from "./utils/buildQueryConstraint";
 export * from "./utils/buildCompositeFilter";
+export * from "./useEnsureDoc";

package/react-native/firestore/index.js

@@ -20,3 +20,4 @@ export * from "./utils/getDocSnap";
 export * from "./utils/getDocRef";
 export * from "./utils/buildQueryConstraint";
 export * from "./utils/buildCompositeFilter";
+export * from "./useEnsureDoc";

package/react-native/firestore/index.ts

@@ -20,3 +20,4 @@ export * from "./utils/getDocSnap";
 export * from "./utils/getDocRef";
 export * from "./utils/buildQueryConstraint";
 export * from "./utils/buildCompositeFilter";
+export * from "./useEnsureDoc";

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

@@ -0,0 +1,40 @@
+import { UseQueryOptions } from "@tanstack/react-query";
+import { AppModel } from "../../types";
+import { GetDocDataOptions } from "./utils/getDocData";
+/**
+ * @inline
+ */
+export type UseEnsureDocOptions<AppModelType extends AppModel = AppModel> = {
+    /**
+     * Reference to a document that must be written
+     */
+    defaults: AppModelType;
+    /**
+     * Options for useMutation hook excluding mutationFn.
+     */
+    options: Omit<UseQueryOptions<AppModelType, Error, AppModelType>, "queryFn"> & Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
+} & Omit<GetDocDataOptions<AppModelType>, "db">;
+/**
+ * This hook checks if a doc with a requested reference exists.
+ * It creates a document with requested data if it does not exist.
+ *
+ * @group Hook
+ *
+ * @param {UseEnsureDocOptions<AppModelType>} options - Configuration options for mutation.
+ *
+ * @returns {UseQueryResult<AppModelType, Error>}  A mutation result
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {data} = useEnsureDocQuery({
+ *      options: {
+ *      },
+ *      reference: collection().doc(),
+ *      defaults: {prop1: 'value1'}
+ *  });
+ *
+ * };
+ * ```
+ */
+export declare const useEnsureDoc: <AppModelType extends AppModel = AppModel>({ reference, path, pathSegments, defaults, options }: UseEnsureDocOptions<AppModelType>) => import("@tanstack/react-query").UseQueryResult<AppModelType, Error>;

package/react-native/firestore/useEnsureDoc.js

@@ -0,0 +1,47 @@
+import { useQuery } from "@tanstack/react-query";
+import { getDoc, setDoc } from "@react-native-firebase/firestore";
+import { getDocRef } from "./utils/getDocRef";
+import { getDocSnap } from "./utils/getDocSnap";
+import { useFirestore } from "./useFirestore";
+/**
+ * This hook checks if a doc with a requested reference exists.
+ * It creates a document with requested data if it does not exist.
+ *
+ * @group Hook
+ *
+ * @param {UseEnsureDocOptions<AppModelType>} options - Configuration options for mutation.
+ *
+ * @returns {UseQueryResult<AppModelType, Error>}  A mutation result
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {data} = useEnsureDocQuery({
+ *      options: {
+ *      },
+ *      reference: collection().doc(),
+ *      defaults: {prop1: 'value1'}
+ *  });
+ *
+ * };
+ * ```
+ */
+export const useEnsureDoc = ({ reference, path, pathSegments, defaults, options }) => {
+    const db = useFirestore();
+    return useQuery({
+        ...options,
+        queryFn: async () => {
+            const existingDocSnap = await getDocSnap({ db, path, pathSegments, reference });
+            if (existingDocSnap?.exists) {
+                return { ...existingDocSnap.data(), uid: existingDocSnap.id };
+            }
+            const docRef = getDocRef({ db, reference, path, pathSegments });
+            if (!docRef) {
+                throw new Error(`Cannot fetch document reference using data: ${reference?.path}, ${path}, ${pathSegments?.join("/")}`);
+            }
+            await setDoc(docRef, defaults);
+            const docSnap = await getDoc(docRef);
+            return { ...docSnap.data(), uid: docSnap.id };
+        }
+    });
+};

package/react-native/firestore/useEnsureDoc.ts

@@ -0,0 +1,79 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { getDoc, setDoc } from "@react-native-firebase/firestore";
+
+import { AppModel } from "../../types";
+import { GetDocDataOptions } from "./utils/getDocData";
+import { getDocRef } from "./utils/getDocRef";
+import { getDocSnap } from "./utils/getDocSnap";
+import { useFirestore } from "./useFirestore";
+
+/**
+ * @inline
+ */
+export type UseEnsureDocOptions<AppModelType extends AppModel = AppModel> = {
+    /**
+     * Reference to a document that must be written
+     */
+    defaults: AppModelType;
+
+    /**
+     * Options for useMutation hook excluding mutationFn.
+     */
+    options: Omit<UseQueryOptions<AppModelType, Error, AppModelType>, "queryFn"> &
+        Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
+} & Omit<GetDocDataOptions<AppModelType>, "db">;
+
+/**
+ * This hook checks if a doc with a requested reference exists.
+ * It creates a document with requested data if it does not exist.
+ *
+ * @group Hook
+ *
+ * @param {UseEnsureDocOptions<AppModelType>} options - Configuration options for mutation.
+ *
+ * @returns {UseQueryResult<AppModelType, Error>}  A mutation result
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {data} = useEnsureDocQuery({
+ *      options: {
+ *      },
+ *      reference: collection().doc(),
+ *      defaults: {prop1: 'value1'}
+ *  });
+ *
+ * };
+ * ```
+ */
+export const useEnsureDoc = <AppModelType extends AppModel = AppModel>({
+    reference,
+    path,
+    pathSegments,
+    defaults,
+    options
+}: UseEnsureDocOptions<AppModelType>) => {
+    const db = useFirestore();
+
+    return useQuery({
+        ...options,
+        queryFn: async () => {
+            const existingDocSnap = await getDocSnap({ db, path, pathSegments, reference });
+
+            if (existingDocSnap?.exists) {
+                return { ...(existingDocSnap.data() as AppModelType), uid: existingDocSnap.id };
+            }
+
+            const docRef = getDocRef({ db, reference, path, pathSegments });
+            if (!docRef) {
+                throw new Error(
+                    `Cannot fetch document reference using data: ${reference?.path}, ${path}, ${pathSegments?.join("/")}`
+                );
+            }
+
+            await setDoc<AppModelType>(docRef, defaults);
+            const docSnap = await getDoc(docRef);
+            return { ...(docSnap.data() as AppModelType), uid: docSnap.id };
+        }
+    });
+};

package/web/firestore/index.d.ts

@@ -15,6 +15,7 @@ export * from "./useSetDocMutation";
 export * from "./useUpdateDocMutation";
 export * from "./useGetRealtimeDocData";
 export * from "./useQueryConstraints";
+export * from "./useEnsureDoc";
 export * from "./utils/getDocData";
 export * from "./utils/getDocSnap";
 export * from "./utils/getDocRef";

package/web/firestore/index.js

@@ -15,6 +15,7 @@ export * from "./useSetDocMutation";
 export * from "./useUpdateDocMutation";
 export * from "./useGetRealtimeDocData";
 export * from "./useQueryConstraints";
+export * from "./useEnsureDoc";
 export * from "./utils/getDocData";
 export * from "./utils/getDocSnap";
 export * from "./utils/getDocRef";

package/web/firestore/index.ts

@@ -15,6 +15,7 @@ export * from "./useSetDocMutation";
 export * from "./useUpdateDocMutation";
 export * from "./useGetRealtimeDocData";
 export * from "./useQueryConstraints";
+export * from "./useEnsureDoc";
 export * from "./utils/getDocData";
 export * from "./utils/getDocSnap";
 export * from "./utils/getDocRef";

package/web/firestore/useEnsureDoc.d.ts

@@ -0,0 +1,40 @@
+import { UseQueryOptions } from "@tanstack/react-query";
+import { AppModel } from "../../types";
+import { GetDocDataOptions } from "./utils/getDocData";
+/**
+ * @inline
+ */
+export type UseEnsureDocOptions<AppModelType extends AppModel = AppModel> = {
+    /**
+     * Reference to a document that must be written
+     */
+    defaults: AppModelType;
+    /**
+     * Options for useMutation hook excluding mutationFn.
+     */
+    options: Omit<UseQueryOptions<AppModelType, Error, AppModelType>, "queryFn"> & Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
+} & Omit<GetDocDataOptions<AppModelType>, "db">;
+/**
+ * This hook checks if a doc with a requested reference exists.
+ * It creates a document with requested data if it does not exist.
+ *
+ * @group Hook
+ *
+ * @param {UseEnsureDocOptions<AppModelType>} options - Configuration options for mutation.
+ *
+ * @returns {UseQueryResult<AppModelType, Error>}  A mutation result
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {data} = useEnsureDocQuery({
+ *      options: {
+ *      },
+ *      reference: collection().doc(),
+ *      defaults: {prop1: 'value1'}
+ *  });
+ *
+ * };
+ * ```
+ */
+export declare const useEnsureDoc: <AppModelType extends AppModel = AppModel>({ reference, path, pathSegments, defaults, options }: UseEnsureDocOptions<AppModelType>) => import("@tanstack/react-query").UseQueryResult<AppModelType, Error>;

package/web/firestore/useEnsureDoc.js

@@ -0,0 +1,47 @@
+import { useQuery } from "@tanstack/react-query";
+import { getDoc, setDoc } from "firebase/firestore";
+import { getDocRef } from "./utils/getDocRef";
+import { getDocSnap } from "./utils/getDocSnap";
+import { useFirestore } from "./useFirestore";
+/**
+ * This hook checks if a doc with a requested reference exists.
+ * It creates a document with requested data if it does not exist.
+ *
+ * @group Hook
+ *
+ * @param {UseEnsureDocOptions<AppModelType>} options - Configuration options for mutation.
+ *
+ * @returns {UseQueryResult<AppModelType, Error>}  A mutation result
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {data} = useEnsureDocQuery({
+ *      options: {
+ *      },
+ *      reference: collection().doc(),
+ *      defaults: {prop1: 'value1'}
+ *  });
+ *
+ * };
+ * ```
+ */
+export const useEnsureDoc = ({ reference, path, pathSegments, defaults, options }) => {
+    const db = useFirestore();
+    return useQuery({
+        ...options,
+        queryFn: async () => {
+            const existingDocSnap = await getDocSnap({ db, path, pathSegments, reference });
+            if (existingDocSnap?.exists) {
+                return { ...existingDocSnap.data(), uid: existingDocSnap.id };
+            }
+            const docRef = getDocRef({ db, reference, path, pathSegments });
+            if (!docRef) {
+                throw new Error(`Cannot fetch document reference using data: ${reference?.path}, ${path}, ${pathSegments?.join("/")}`);
+            }
+            await setDoc(docRef, defaults);
+            const docSnap = await getDoc(docRef);
+            return { ...docSnap.data(), uid: docSnap.id };
+        }
+    });
+};

package/web/firestore/useEnsureDoc.ts

@@ -0,0 +1,79 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+import { getDoc, setDoc } from "firebase/firestore";
+
+import { AppModel } from "../../types";
+import { GetDocDataOptions } from "./utils/getDocData";
+import { getDocRef } from "./utils/getDocRef";
+import { getDocSnap } from "./utils/getDocSnap";
+import { useFirestore } from "./useFirestore";
+
+/**
+ * @inline
+ */
+export type UseEnsureDocOptions<AppModelType extends AppModel = AppModel> = {
+    /**
+     * Reference to a document that must be written
+     */
+    defaults: AppModelType;
+
+    /**
+     * Options for useMutation hook excluding mutationFn.
+     */
+    options: Omit<UseQueryOptions<AppModelType, Error, AppModelType>, "queryFn"> &
+        Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
+} & Omit<GetDocDataOptions<AppModelType>, "db">;
+
+/**
+ * This hook checks if a doc with a requested reference exists.
+ * It creates a document with requested data if it does not exist.
+ *
+ * @group Hook
+ *
+ * @param {UseEnsureDocOptions<AppModelType>} options - Configuration options for mutation.
+ *
+ * @returns {UseQueryResult<AppModelType, Error>}  A mutation result
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const {data} = useEnsureDocQuery({
+ *      options: {
+ *      },
+ *      reference: collection().doc(),
+ *      defaults: {prop1: 'value1'}
+ *  });
+ *
+ * };
+ * ```
+ */
+export const useEnsureDoc = <AppModelType extends AppModel = AppModel>({
+    reference,
+    path,
+    pathSegments,
+    defaults,
+    options
+}: UseEnsureDocOptions<AppModelType>) => {
+    const db = useFirestore();
+
+    return useQuery({
+        ...options,
+        queryFn: async () => {
+            const existingDocSnap = await getDocSnap({ db, path, pathSegments, reference });
+
+            if (existingDocSnap?.exists) {
+                return { ...(existingDocSnap.data() as AppModelType), uid: existingDocSnap.id };
+            }
+
+            const docRef = getDocRef({ db, reference, path, pathSegments });
+            if (!docRef) {
+                throw new Error(
+                    `Cannot fetch document reference using data: ${reference?.path}, ${path}, ${pathSegments?.join("/")}`
+                );
+            }
+
+            await setDoc<AppModelType, AppModelType>(docRef, defaults);
+            const docSnap = await getDoc(docRef);
+            return { ...(docSnap.data() as AppModelType), uid: docSnap.id };
+        }
+    });
+};