react-query-firebase 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+[![Release Train](https://github.com/vpishuk/react-query-firebase/actions/workflows/main.yaml/badge.svg?branch=main)](https://github.com/vpishuk/react-query-firebase/actions/workflows/main.yaml)
+
+# react-query-firebase
+
+This module offers a set of hooks to work with [Firebase](https://firebase.google.com/) platorrm.
+
+## Installation
+
+Run the following command to install:
+
+```
+npm i react-query-firebase
+```
+
+## Usage
+
+TODO:
+
+
+## Contribution guidelines
+
+You are encouraged to contribute to this project as soon as you see any defects or issues.
+
+## Code Editor Configuration
+
+This repository contains configuration for VSCode editor. It doesn't mean that you cannot use a different tool. Feel free to push configurations for your favourite code editor.
+
+## Commands
+
+1. To build : `npm run build`
+2. To lint use: `npm run lint`
+3. To initialize pre-commit hooks use: `npm run prepare`
+
+## Workflow
+
+Before you get started make sure that there is noone working on an issue you are going to address.
+
+As a first step, clone the repository and run `npm i && npm run prepare` command to install all dependencies and initialize pre-commit hooks.
+
+Create a branch to work on your code changes.
+
+Once you are done with coding, create pull request and get an approval.
+
+Lastly, enjoy your changes.

package/dist/src/FirebaseContext.d.ts

@@ -0,0 +1,13 @@
+import { Auth } from "firebase/auth";
+import { Analytics } from "firebase/analytics";
+import { Firestore } from "firebase/firestore";
+import { FirebaseApp } from "firebase/app";
+import { RemoteConfig } from "firebase/remote-config";
+export type FirebaseContextValue = {
+    auth: Auth;
+    analytics: Analytics;
+    firebase: FirebaseApp;
+    remoteConfig: RemoteConfig;
+    firestore: Firestore;
+};
+export declare const FirebaseContext: import("react").Context<Partial<FirebaseContextValue>>;

package/dist/src/FirebaseContext.js

@@ -0,0 +1,3 @@
+"use client";
+import { createContext } from "react";
+export const FirebaseContext = createContext({});

package/dist/src/FirebaseContextProvider.d.ts

@@ -0,0 +1,28 @@
+import React, { PropsWithChildren } from "react";
+import { RemoteConfigSettings } from "firebase/remote-config";
+import { FirebaseOptions } from "firebase/app";
+type FirestorEmulatorConfig = {
+    host: string;
+    port: number;
+};
+type AuthEmulatorConfig = {
+    host: string;
+};
+type Emulators = {
+    firestore?: FirestorEmulatorConfig;
+    auth?: AuthEmulatorConfig;
+};
+type FirebaseContextProvider = PropsWithChildren & {
+    emulators?: Emulators;
+    options: FirebaseOptions;
+    authEnabled?: boolean;
+    analyticsEnabled?: boolean;
+    firestoreEnabled?: boolean;
+    remoteConfigSettings?: RemoteConfigSettings;
+    remoteConfigDefaults?: {
+        [key: string]: string | number | boolean;
+    };
+    remoteConfigEnabled?: boolean;
+};
+export declare const FirebaseContextProvider: React.FC<FirebaseContextProvider>;
+export {};

package/dist/src/FirebaseContextProvider.js

@@ -0,0 +1,46 @@
+import React, { useMemo } from "react";
+import { FirebaseContext } from "./FirebaseContext";
+import { connectAuthEmulator, getAuth } from "firebase/auth";
+import { getAnalytics } from "firebase/analytics";
+import { getRemoteConfig } from "firebase/remote-config";
+import { connectFirestoreEmulator, getFirestore } from "firebase/firestore";
+import { initializeApp } from "firebase/app";
+export const FirebaseContextProvider = ({ emulators, options, children, authEnabled = true, firestoreEnabled = true, analyticsEnabled = true, remoteConfigEnabled = true, remoteConfigSettings, remoteConfigDefaults = {} }) => {
+    const firebase = useMemo(() => {
+        return initializeApp(options);
+    }, [options]);
+    const contextValue = useMemo(() => {
+        const value = {};
+        if (firestoreEnabled) {
+            const firestore = getFirestore(firebase);
+            if (emulators?.firestore?.host && emulators?.firestore?.port) {
+                connectFirestoreEmulator(firestore, emulators.firestore.host, emulators.firestore.port);
+            }
+            value.firestore = firestore;
+        }
+        if (authEnabled) {
+            const auth = getAuth(firebase);
+            if (emulators?.auth?.host) {
+                connectAuthEmulator(auth, emulators?.auth?.host, {
+                    disableWarnings: true
+                });
+            }
+            value.auth = auth;
+        }
+        if (analyticsEnabled && options.measurementId && typeof window !== "undefined") {
+            const analytics = getAnalytics(firebase);
+            value.analytics = analytics;
+        }
+        if (remoteConfigEnabled && typeof window !== "undefined") {
+            const remoteConfig = getRemoteConfig(firebase);
+            if (remoteConfigSettings) {
+                remoteConfig.settings.fetchTimeoutMillis = remoteConfigSettings.fetchTimeoutMillis;
+                remoteConfig.settings.minimumFetchIntervalMillis = remoteConfigSettings.minimumFetchIntervalMillis;
+                remoteConfig.defaultConfig = remoteConfigDefaults;
+            }
+            value.remoteConfig = remoteConfig;
+        }
+        return { firebase, ...value };
+    }, [firebase]);
+    return React.createElement(FirebaseContext.Provider, { value: contextValue }, children);
+};

package/dist/src/analytics/index.d.ts

@@ -0,0 +1 @@
+export * from "./useLogEvent";

package/dist/src/analytics/index.js

@@ -0,0 +1 @@
+export * from "./useLogEvent";

package/dist/src/analytics/useLogEvent.d.ts

@@ -0,0 +1,10 @@
+type UseLogEventOptions = {
+    eventName: string;
+    eventParams?: {
+        [key: string]: unknown;
+    };
+};
+export declare const useLogEvent: ({ eventName, eventParams }: UseLogEventOptions) => {
+    logEvent: () => void;
+};
+export {};

package/dist/src/analytics/useLogEvent.js

@@ -0,0 +1,14 @@
+import { logEvent } from "firebase/analytics";
+import { useAnalytics } from "../useAnalytics";
+import { useCallback, useMemo } from "react";
+export const useLogEvent = ({ eventName, eventParams }) => {
+    const analytics = useAnalytics();
+    const logEventCallback = useCallback(() => {
+        if (analytics) {
+            logEvent(analytics, eventName, eventParams);
+        }
+    }, [eventName, eventParams]);
+    return useMemo(() => ({
+        logEvent: logEventCallback
+    }), [logEventCallback]);
+};

package/dist/src/auth/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./mutation-keys";
+export * from "./useCreateUserWitEmailAndPasswordMutation";
+export * from "./useSendEmailVerificationMutation";
+export * from "./useSignInWitEmailAndPasswordMutation";
+export * from "./useCurrentUser";
+export * from "./useAuthStateReady";
+export * from "./useSignInWitRedirectMutation";
+export * from "./useUpdateProfileMutation";
+export * from "./useSignOutMutation";

package/dist/src/auth/index.js

@@ -0,0 +1,9 @@
+export * from "./mutation-keys";
+export * from "./useCreateUserWitEmailAndPasswordMutation";
+export * from "./useSendEmailVerificationMutation";
+export * from "./useSignInWitEmailAndPasswordMutation";
+export * from "./useCurrentUser";
+export * from "./useAuthStateReady";
+export * from "./useSignInWitRedirectMutation";
+export * from "./useUpdateProfileMutation";
+export * from "./useSignOutMutation";

package/dist/src/auth/mutation-keys.d.ts

@@ -0,0 +1,7 @@
+export declare const CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY: readonly ["FIREBASE", "AUTH", "CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION"];
+export declare const SEND_EMAIL_VERIFICATION_MUTATION_KEY: readonly ["FIREBASE", "AUTH", "SEND_EMAIL_VERIFICATION_MUTATION"];
+export declare const SIGN_IN_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY: readonly ["FIREBASE", "AUTH", "SIGN_IN_WITH_EMAIL_AND_PASSWORD_MUTATION"];
+export declare const SIGN_IN_WITH_REDIRECT_MUTATION_KEY: readonly ["FIREBASE", "AUTH", "SIGN_IN_WITH_REDIRECT_MUTATION"];
+export declare const SIGN_OUT_MUTATION_KEY: readonly ["FIREBASE", "AUTH", "SIGN_OUT"];
+export declare const REAUTHENTICATE_WITH_REDIRECT_MUTATION_KEY: readonly ["FIREBASE", "AUTH", "REAUTHENTICATE_WITH_REDIRECT"];
+export declare const REAUTHENTICATE_WITH_CREDENTIAL_MUTATION_KEY: readonly ["FIREBASE", "AUTH", "REAUTHENTICATE_WITH_CREDENTIAL"];

package/dist/src/auth/mutation-keys.js

@@ -0,0 +1,19 @@
+export const CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY = [
+    "FIREBASE",
+    "AUTH",
+    "CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION"
+];
+export const SEND_EMAIL_VERIFICATION_MUTATION_KEY = ["FIREBASE", "AUTH", "SEND_EMAIL_VERIFICATION_MUTATION"];
+export const SIGN_IN_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY = [
+    "FIREBASE",
+    "AUTH",
+    "SIGN_IN_WITH_EMAIL_AND_PASSWORD_MUTATION"
+];
+export const SIGN_IN_WITH_REDIRECT_MUTATION_KEY = ["FIREBASE", "AUTH", "SIGN_IN_WITH_REDIRECT_MUTATION"];
+export const SIGN_OUT_MUTATION_KEY = ["FIREBASE", "AUTH", "SIGN_OUT"];
+export const REAUTHENTICATE_WITH_REDIRECT_MUTATION_KEY = ["FIREBASE", "AUTH", "REAUTHENTICATE_WITH_REDIRECT"];
+export const REAUTHENTICATE_WITH_CREDENTIAL_MUTATION_KEY = [
+    "FIREBASE",
+    "AUTH",
+    "REAUTHENTICATE_WITH_CREDENTIAL"
+];

package/dist/src/auth/useAuthStateReady.d.ts

@@ -0,0 +1 @@
+export declare const useAuthStateReady: () => boolean;

package/dist/src/auth/useAuthStateReady.js

@@ -0,0 +1,14 @@
+import { useAuth } from "../useAuth";
+import { useCallback, useEffect, useState } from "react";
+export const useAuthStateReady = () => {
+    const firebaseAuth = useAuth();
+    const [isAuthStateReady, setIsAuthStateReady] = useState(false);
+    const callback = useCallback(async () => {
+        await firebaseAuth.authStateReady();
+        setIsAuthStateReady(true);
+    }, [isAuthStateReady]);
+    useEffect(() => {
+        callback();
+    }, [callback]);
+    return isAuthStateReady;
+};

package/dist/src/auth/useCreateUserWitEmailAndPasswordMutation.d.ts

@@ -0,0 +1,8 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { UserCredential } from "firebase/auth";
+import { FirebaseError } from "firebase/app";
+export type UseCreateUserWitEmailAndPasswordMutationVariables = {
+    email: string;
+    password: string;
+};
+export declare const useCreateUserWitEmailAndPasswordMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<UserCredential, FirebaseError, UseCreateUserWitEmailAndPasswordMutationVariables, TContext>, "mutationKey" | "mutationFn">) => import("@tanstack/react-query").UseMutationResult<UserCredential, FirebaseError, UseCreateUserWitEmailAndPasswordMutationVariables, TContext>;

package/dist/src/auth/useCreateUserWitEmailAndPasswordMutation.js

@@ -0,0 +1,12 @@
+import { useMutation } from "@tanstack/react-query";
+import { createUserWithEmailAndPassword } from "firebase/auth";
+import { useAuth } from "../useAuth";
+import { CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY } from "./mutation-keys";
+export const useCreateUserWitEmailAndPasswordMutation = (options = {}) => {
+    const firebaseAuth = useAuth();
+    return useMutation({
+        ...options,
+        mutationFn: async ({ email, password }) => await createUserWithEmailAndPassword(firebaseAuth, email, password),
+        mutationKey: CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY
+    });
+};

package/dist/src/auth/useCurrentUser.d.ts

@@ -0,0 +1 @@
+export declare const useCurrentUser: () => import("firebase/auth").User | null;

package/dist/src/auth/useCurrentUser.js

@@ -0,0 +1,15 @@
+import { useAuth } from "../useAuth";
+import { useEffect, useState } from "react";
+export const useCurrentUser = () => {
+    const firebaseAuth = useAuth();
+    const [currentUser, setCurrentUser] = useState(firebaseAuth.currentUser);
+    useEffect(() => {
+        const unsubscribe = firebaseAuth.onAuthStateChanged((user) => {
+            setCurrentUser(user);
+        });
+        return () => {
+            unsubscribe();
+        };
+    }, [currentUser?.uid ?? ""]);
+    return currentUser;
+};

package/dist/src/auth/useSendEmailVerificationMutation.d.ts

@@ -0,0 +1,7 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { User } from "firebase/auth";
+import { FirebaseError } from "firebase/app";
+export type UseSendEmailVerificationMutationVariables = {
+    user: User;
+};
+export declare const useSendEmailVerificationMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<void, FirebaseError, UseSendEmailVerificationMutationVariables, TContext>, "queryKey" | "queryFn">) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseSendEmailVerificationMutationVariables, TContext>;

package/dist/src/auth/useSendEmailVerificationMutation.js

@@ -0,0 +1,10 @@
+import { useMutation } from "@tanstack/react-query";
+import { sendEmailVerification } from "firebase/auth";
+import { SEND_EMAIL_VERIFICATION_MUTATION_KEY } from "./mutation-keys";
+export const useSendEmailVerificationMutation = (options = {}) => {
+    return useMutation({
+        ...options,
+        mutationFn: async ({ user }) => await sendEmailVerification(user),
+        mutationKey: SEND_EMAIL_VERIFICATION_MUTATION_KEY
+    });
+};

package/dist/src/auth/useSignInWitEmailAndPasswordMutation.d.ts

@@ -0,0 +1,8 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { UserCredential } from "firebase/auth";
+import { FirebaseError } from "firebase/app";
+export type UseSignInWitEmailAndPasswordMutationVariables = {
+    email: string;
+    password: string;
+};
+export declare const useSignInWitEmailAndPasswordMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<UserCredential, FirebaseError, UseSignInWitEmailAndPasswordMutationVariables, TContext>, "mutationKey" | "mutationFn">) => import("@tanstack/react-query").UseMutationResult<UserCredential, FirebaseError, UseSignInWitEmailAndPasswordMutationVariables, TContext>;

package/dist/src/auth/useSignInWitEmailAndPasswordMutation.js

@@ -0,0 +1,12 @@
+import { useMutation } from "@tanstack/react-query";
+import { signInWithEmailAndPassword } from "firebase/auth";
+import { useAuth } from "../useAuth";
+import { SIGN_IN_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY } from "./mutation-keys";
+export const useSignInWitEmailAndPasswordMutation = (options = {}) => {
+    const firebaseAuth = useAuth();
+    return useMutation({
+        ...options,
+        mutationFn: async ({ email, password }) => signInWithEmailAndPassword(firebaseAuth, email, password),
+        mutationKey: SIGN_IN_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY
+    });
+};

package/dist/src/auth/useSignInWitRedirectMutation.d.ts

@@ -0,0 +1,8 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { AuthProvider, PopupRedirectResolver } from "firebase/auth";
+import { FirebaseError } from "firebase/app";
+export type UseSignInWitRedirectMutationVariables = {
+    authProvider: AuthProvider;
+    popupRedirectResolver?: PopupRedirectResolver;
+};
+export declare const useSignInWitRedirectMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>, "mutationKey" | "mutationFn">) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>;

package/dist/src/auth/useSignInWitRedirectMutation.js

@@ -0,0 +1,12 @@
+import { useMutation } from "@tanstack/react-query";
+import { signInWithRedirect } from "firebase/auth";
+import { useAuth } from "../useAuth";
+import { SIGN_IN_WITH_REDIRECT_MUTATION_KEY } from "./mutation-keys";
+export const useSignInWitRedirectMutation = (options = {}) => {
+    const firebaseAuth = useAuth();
+    return useMutation({
+        ...options,
+        mutationFn: async ({ authProvider, popupRedirectResolver }) => signInWithRedirect(firebaseAuth, authProvider, popupRedirectResolver),
+        mutationKey: SIGN_IN_WITH_REDIRECT_MUTATION_KEY
+    });
+};

package/dist/src/auth/useSignOutMutation.d.ts

@@ -0,0 +1,3 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { FirebaseError } from "firebase/app";
+export declare const useSignOutMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "queryKey" | "queryFn">) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, void, TContext>;

package/dist/src/auth/useSignOutMutation.js

@@ -0,0 +1,12 @@
+import { useMutation } from "@tanstack/react-query";
+import { signOut } from "firebase/auth";
+import { SIGN_OUT_MUTATION_KEY } from "./mutation-keys";
+import { useAuth } from "../useAuth";
+export const useSignOutMutation = (options = {}) => {
+    const firebaseAuth = useAuth();
+    return useMutation({
+        ...options,
+        mutationFn: async () => await signOut(firebaseAuth),
+        mutationKey: SIGN_OUT_MUTATION_KEY
+    });
+};

package/dist/src/auth/useUpdateProfileMutation.d.ts

@@ -0,0 +1,8 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { User } from "firebase/auth";
+import { FirebaseError } from "firebase/app";
+export type UseUpdateProfileMutationVariables = {
+    displayName?: string;
+    user: User;
+};
+export declare const useUpdateProfileMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>, "mutationKey" | "mutationFn">) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>;

package/dist/src/auth/useUpdateProfileMutation.js

@@ -0,0 +1,10 @@
+import { useMutation } from "@tanstack/react-query";
+import { updateProfile } from "firebase/auth";
+import { CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY } from "./mutation-keys";
+export const useUpdateProfileMutation = (options = {}) => {
+    return useMutation({
+        ...options,
+        mutationFn: async ({ displayName, user }) => await updateProfile(user, { displayName }),
+        mutationKey: CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY
+    });
+};

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

@@ -0,0 +1,14 @@
+export * from "./useAddDocMutation";
+export * from "./useBatchWrite";
+export * from "./useCollectionReference";
+export * from "./useCompositeFilter";
+export * from "./useCountQuery";
+export * from "./useDeleteDocMutation";
+export * from "./useDocReference";
+export * from "./useDocReferences";
+export * from "./useGetDocData";
+export * from "./useInfiniteQuery";
+export * from "./useQuery";
+export * from "./useRunTransaction";
+export * from "./useSetDocMutation";
+export * from "./useUpdateDocMutation";

package/dist/src/firestore/index.js

@@ -0,0 +1,14 @@
+export * from "./useAddDocMutation";
+export * from "./useBatchWrite";
+export * from "./useCollectionReference";
+export * from "./useCompositeFilter";
+export * from "./useCountQuery";
+export * from "./useDeleteDocMutation";
+export * from "./useDocReference";
+export * from "./useDocReferences";
+export * from "./useGetDocData";
+export * from "./useInfiniteQuery";
+export * from "./useQuery";
+export * from "./useRunTransaction";
+export * from "./useSetDocMutation";
+export * from "./useUpdateDocMutation";

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

@@ -0,0 +1,12 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { DocumentData, WithFieldValue, CollectionReference, FirestoreDataConverter } from "firebase/firestore";
+import { FirebaseError } from "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 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>;

package/dist/src/firestore/useAddDocMutation.js

@@ -0,0 +1,15 @@
+import { useMutation } from "@tanstack/react-query";
+import { addDoc, getDoc } from "firebase/firestore";
+import { useMemo } from "react";
+export const useAddDocMutation = ({ reference, converter, 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);
+            return docSnap.data();
+        },
+        mutationKey
+    });
+};

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

@@ -0,0 +1,8 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { WriteBatch } from "firebase/firestore";
+import { FirebaseError } from "firebase/app";
+export type UseBatchWriteVariables = (batch: WriteBatch) => Promise<void> | void;
+export type UseBatchWriteOptions<TContext = unknown> = {
+    options?: Omit<UseMutationOptions<void, FirebaseError, UseBatchWriteVariables, TContext>, "mutationFn">;
+};
+export declare const useBatchWrite: <TContext = unknown>({ options }?: UseBatchWriteOptions<TContext>) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseBatchWriteVariables, TContext>;

package/dist/src/firestore/useBatchWrite.js

@@ -0,0 +1,14 @@
+import { useMutation } from "@tanstack/react-query";
+import { writeBatch } from "firebase/firestore";
+import { useFirestore } from "../useFirestore";
+export const useBatchWrite = ({ options = {} } = {}) => {
+    const db = useFirestore();
+    return useMutation({
+        ...options,
+        mutationFn: async (batchWriteFn) => {
+            const batch = writeBatch(db);
+            await batchWriteFn(batch);
+            return batch.commit();
+        }
+    });
+};

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

@@ -0,0 +1,7 @@
+import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+export type UseCollectionReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
+    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    path: string;
+    pathSegments?: string[];
+};
+export declare const useCollectionReference: <AppModelType, DbModelType extends DocumentData = DocumentData>({ path, reference, pathSegments }: UseCollectionReferenceOptions<AppModelType, DbModelType>) => CollectionReference<DocumentData, DocumentData>;

package/dist/src/firestore/useCollectionReference.js

@@ -0,0 +1,13 @@
+import { collection } from "firebase/firestore";
+import { useMemo } from "react";
+import { useFirestore } from "../useFirestore";
+export const useCollectionReference = ({ path, reference, pathSegments }) => {
+    const db = useFirestore();
+    return useMemo(() => {
+        return !reference
+            ? collection(db, path || "", ...(pathSegments || []))
+            : reference.type === "collection"
+                ? collection(reference, path, ...(pathSegments || []))
+                : collection(reference, path, ...(pathSegments || []));
+    }, [path, reference?.path, pathSegments]);
+};

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

@@ -0,0 +1,20 @@
+import { DocumentData, QueryCompositeFilterConstraint, WhereFilterOp } from "firebase/firestore";
+type CompositeFilterDocumentData = DocumentData;
+export type QueryElement<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = Partial<QueryCompositeFilterConstraint> & {
+    children?: QueryElement[];
+    field?: keyof (DbModelType & {
+        documentId?: string[];
+    });
+    value?: DbModelType[keyof DbModelType];
+    op?: WhereFilterOp;
+};
+export type CompositeFilter<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = QueryCompositeFilterConstraint & {
+    children: QueryElement<DbModelType & {
+        documentId?: string[];
+    }>[];
+};
+export type UseCompositeFilter<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = {
+    query?: CompositeFilter<DbModelType>;
+};
+export declare const useCompositeFilter: <DbModelType extends CompositeFilterDocumentData = DocumentData>({ query }: UseCompositeFilter<DbModelType>) => QueryCompositeFilterConstraint | undefined;
+export {};

package/dist/src/firestore/useCompositeFilter.js

@@ -0,0 +1,26 @@
+import { and, documentId, or, where } from "firebase/firestore";
+import { useMemo } from "react";
+const buildCompositeQuery = (query) => {
+    if (query.children) {
+        const queryConstraints = query.children
+            .map((subQuery) => 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 null;
+};
+export const useCompositeFilter = ({ query }) => {
+    return useMemo(() => {
+        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);
+    }, [query]);
+};

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

@@ -0,0 +1,10 @@
+import { DocumentData, Query, QueryCompositeFilterConstraint, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
+import { UseQueryResult, UseQueryOptions as UseReactQueryOptions } from "@tanstack/react-query";
+type UseCountQueryOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = {
+    options: Omit<UseReactQueryOptions<number, Error, number>, "queryFn"> & Required<Pick<UseReactQueryOptions<number, Error, number>, "queryKey">>;
+    query: Query<AppModelType, DbModelType>;
+    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
+    compositeFilter?: QueryCompositeFilterConstraint;
+};
+export declare const useCountQuery: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, query: queryReference, queryConstraints, compositeFilter }: UseCountQueryOptions<AppModelType, DbModelType>) => UseQueryResult<number>;
+export {};

package/dist/src/firestore/useCountQuery.js

@@ -0,0 +1,17 @@
+import { getCountFromServer, query } from "firebase/firestore";
+import { useQuery as useReactQuery } from "@tanstack/react-query";
+export const useCountQuery = ({ options, query: queryReference, queryConstraints = [], compositeFilter }) => {
+    return useReactQuery({
+        ...options,
+        queryFn: async () => {
+            const queryToExecute = compositeFilter
+                ? query(queryReference, compositeFilter, ...queryConstraints)
+                : query(queryReference, ...queryConstraints);
+            const querySnapshot = await getCountFromServer(queryToExecute);
+            if (querySnapshot) {
+                return querySnapshot.data().count;
+            }
+            return 0;
+        }
+    });
+};

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

@@ -0,0 +1,11 @@
+import { UseMutationOptions } from "@tanstack/react-query";
+import { DocumentData, WithFieldValue, DocumentReference } from "firebase/firestore";
+import { FirebaseError } from "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 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>;