react-query-firebase 2.13.3 → 2.13.4

package/react-native/firestore/useDeleteDocMutation.ts

@@ -1,71 +0,0 @@
-import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { FirebaseFirestoreTypes, deleteDoc, WithFieldValue } from "@react-native-firebase/firestore";
-
-import { useMemo } from "react";
-import { AppModel } from "../../types";
-
-/**
- * @inline
- */
-export type UseDeleteDocMutationValues<AppModelType extends AppModel = AppModel> = {
-    data: WithFieldValue<AppModelType>;
-};
-
-/**
- * @inline
- */
-export type UseDeleteDocMutationOptions<AppModelType extends AppModel = AppModel, TContext = unknown> = {
-    /**
-     * A reference to a firestore document
-     */
-    reference: FirebaseFirestoreTypes.DocumentReference<AppModelType> | null;
-    /**
-     * Options for useMutation hook excluding mutationFn. MutationKey will be equal to reference.path by default.
-     */
-    options?: Omit<UseMutationOptions<void, Error, void, TContext>, "mutationFn">;
-};
-
-/**
- * Executes a query with specified constraints and returns the count of matched documents.
- *
- * @group Hook
- *
- * @param {UseDeleteDocMutationOptions<AppModelType>} options - Configuration options for the query.
- *
- * @returns {UseMutationResult<void, Error, UseDeleteDocMutationValues<AppModelType>, TContext>}  A mutation result
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const {mutate} = useDeleteDocMutation({
- *      options: {
- *      },
- *      reference: document(),
- *  });
- *
- *  // ....
- *  mutate();
- *  // ....
- * };
- * ```
- */
-export const useDeleteDocMutation = <
-    AppModelType extends FirebaseFirestoreTypes.DocumentData = FirebaseFirestoreTypes.DocumentData,
-    TContext = unknown
->({
-    reference,
-    options = {}
-}: UseDeleteDocMutationOptions<AppModelType, TContext>) => {
-    const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
-
-    return useMutation({
-        ...options,
-        mutationFn: async () => {
-            if (!reference) {
-                throw new Error("Reference is undefined");
-            }
-            await deleteDoc(reference);
-        },
-        mutationKey
-    });
-};

package/react-native/firestore/useDocReference.ts

@@ -1,42 +0,0 @@
-import { useMemo } from "react";
-import { AppModel } from "../../types";
-import { useFirestore } from "./useFirestore";
-import { getDocRef, GetDocRefOptions } from "./utils/getDocRef";
-
-/**
- * @inline
- */
-export type UseDocReferenceOptions<AppModelType extends AppModel = AppModel> = Omit<
-    GetDocRefOptions<AppModelType>,
-    "db"
->;
-
-/**
- * Gets a `CollectionReference` instance.
- *
- * @group Hook
- *
- * @param {UseDocReferenceOptions<AppModelType>} options - Options
- *
- * @returns {FirebaseFirestoreTypes.DocumentReference<AppModelType, AppModelType> | null} A reference to a Firestore document
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const ref = useDocReference({
- *      reference: collection('todos')
- *      path: 'first'
- *  });
- * };
- * ```
- */
-export const useDocReference = <AppModelType extends AppModel = AppModel>({
-    path,
-    reference,
-    pathSegments
-}: UseDocReferenceOptions<AppModelType>) => {
-    const db = useFirestore();
-    return useMemo(() => {
-        return getDocRef({ db, path, pathSegments, reference });
-    }, [db, path, pathSegments, reference]);
-};

package/react-native/firestore/useDocReferences.ts

@@ -1,40 +0,0 @@
-import { useMemo } from "react";
-import { AppModel } from "../../types";
-import { useFirestore } from "./useFirestore";
-import { getDocRef, GetDocRefOptions } from "./utils/getDocRef";
-
-/**
- * @inline
- */
-export type UseDocReferencesOptions<AppModelType extends AppModel = AppModel> = {
-    references: Omit<GetDocRefOptions<AppModelType>, "db">[];
-};
-
-/**
- * Gets `CollectionReference` instances
- *
- * @group Hook
- *
- * @param {UseDocReferencesOptions<AppModelType>} options - Options
- *
- * @returns {Array<FirebaseFirestoreTypes.DocumentReference<AppModelType> | null>} A reference to a Firestore document
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const ref = useDocReference({
- *      reference: collection('todos')
- *      path: 'first'
- *  });
- * };
- * ```
- */
-export const useDocReferences = <AppModelType extends AppModel = AppModel>({
-    references
-}: UseDocReferencesOptions<AppModelType>) => {
-    const db = useFirestore();
-
-    return useMemo(() => {
-        return references.map(({ path, reference, pathSegments }) => getDocRef({ db, reference, path, pathSegments }));
-    }, [references, db]);
-};

package/react-native/firestore/useEnsureDoc.ts

@@ -1,79 +0,0 @@
-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/react-native/firestore/useFirestore.js

@@ -1,13 +0,0 @@
-import { useContext } from "react";
-import { FirebaseContext } from "../context/FirebaseContext";
-/**
- * Returns an instance of firestore bound to the closest context.
- *
- * @group Hook
- *
- * @returns {Firestore}
- */
-export const useFirestore = () => {
-    const { firestore } = useContext(FirebaseContext);
-    return firestore;
-};

package/react-native/firestore/useGetDocData.ts

@@ -1,52 +0,0 @@
-import { useQuery, UseQueryOptions } from "@tanstack/react-query";
-import { AppModel } from "../../types";
-import { useFirestore } from "./useFirestore";
-import { getDocData, GetDocDataOptions } from "./utils/getDocData";
-
-/**
- * @inline
- */
-type UseGetDocOptions<AppModelType extends AppModel = AppModel> = {
-    /**
-     * Reqct-query options that must include queryKey and shall not define queryFn
-     */
-    options: Omit<UseQueryOptions<AppModelType | null, Error, AppModelType>, "queryFn"> &
-        Required<Pick<UseQueryOptions<AppModelType, Error, AppModelType>, "queryKey">>;
-} & Omit<GetDocDataOptions<AppModelType>, "db">;
-
-/**
- * Executes a query on a Firestore data source and returns the resulting document.
- *
- * @group Hook
- *
- * @param {UseGetDocOptions<AppModelType>} options - Configuration options for the query.
- *
- * @returns {UseQueryResult<AppModelType, Error>} An object containing document's data
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const doc = useGetDocData({
- *      options: {
- *          queryKey: ['key']
- *      },
- *      reference: collection(),
- *      path: 'id'
- *  });
- *  console.log(doc);
- * };
- * ```
- */
-export const useGetDocData = <AppModelType extends AppModel = AppModel>({
-    options,
-    reference,
-    path,
-    pathSegments
-}: UseGetDocOptions<AppModelType>) => {
-    const db = useFirestore();
-
-    return useQuery({
-        ...options,
-        queryFn: () => getDocData<AppModelType>({ db, reference, path, pathSegments })
-    });
-};

package/react-native/firestore/useGetRealtimeDocData.ts

@@ -1,106 +0,0 @@
-import { FirebaseFirestoreTypes, onSnapshot } from "@react-native-firebase/firestore";
-
-import { useEffect, useMemo, useState } from "react";
-import { ReactNativeFirebase } from "@react-native-firebase/app";
-import { AppModel } from "../../types";
-import { useDocReference } from "./useDocReference";
-
-/**
- * @inline
- */
-export type UseGetRealtimeDocDataOptions<AppModelType extends AppModel = AppModel> = {
-    /**
-     * A slash-separated path to a document. Has to be omitted to use
-     */
-    path?: string;
-    /**
-     * A reference to a collection.
-     */
-    reference?: FirebaseFirestoreTypes.DocumentReference<AppModelType>;
-    /**
-     * Additional path segments that will be applied relative
-     * to the first argument.
-     */
-    pathSegments?: string[];
-    /**
-     * A callback to be called if the listen fails or is
-     * cancelled. No further callbacks will occur.
-     */
-    onError?: (error: ReactNativeFirebase.NativeFirebaseError | Error) => unknown;
-};
-
-/**
- * @inline
- */
-export type UseGetRealtimeDocDataResult<AppModelType> = {
-    data: AppModelType | null;
-    isError: boolean;
-    error: ReactNativeFirebase.NativeFirebaseError | Error | null;
-    isFetching: boolean;
-};
-
-/**
- * A hook to get realtime updates to a firestore document.
- *
- * @group Hook
- *
- * @param {UseGetRealtimeDocDataOptions<AppModelType, DbModelType>} options
- *
- * @returns {UseGetRealtimeDocDataResult<AppModelType>}
- *
- * @example
- * ```jsx
- * const firebaseConfig = {};
- * export const MyComponent = () => {
- *  const result = useGetRealtimeDocData('collection/documentId');
- *  return (
- *      <div>
- *          {JSON.stringify(result)}
- *      </div>
- *  );
- * };
- * ```
- */
-export const useGetRealtimeDocData = <AppModelType extends AppModel = AppModel>({
-    path,
-    pathSegments,
-    reference,
-    onError
-}: UseGetRealtimeDocDataOptions<AppModelType>): UseGetRealtimeDocDataResult<AppModelType> => {
-    const ref = useDocReference({ path, reference, pathSegments });
-    const [doc, setDoc] = useState<AppModelType | null>(null);
-    const [isError, setIsError] = useState(false);
-    const [isFetching, setIsFetching] = useState(true);
-    const [error, setError] = useState<ReactNativeFirebase.NativeFirebaseError | Error | null>(null);
-
-    useEffect(() => {
-        const unsubscribe = ref
-            ? onSnapshot<AppModelType>(ref, {
-                  next: async (snapshot) => {
-                      setIsFetching(false);
-                      setDoc({ ...snapshot.data(), uid: snapshot.id } as AppModelType);
-                      setError(null);
-                      setIsError(false);
-                  },
-                  error: (e) => {
-                      setIsError(true);
-                      setDoc(null);
-                      setError(e);
-                      onError?.(e);
-                  }
-              })
-            : () => {};
-
-        return () => unsubscribe();
-    }, [ref, doc, isError, onError, isFetching, error]);
-
-    return useMemo(
-        () => ({
-            data: doc,
-            isError,
-            isFetching,
-            error
-        }),
-        [doc, isError, error, isFetching]
-    );
-};

package/react-native/firestore/useInfiniteQuery.ts

@@ -1,115 +0,0 @@
-import {
-    FirebaseFirestoreTypes,
-    getDocs,
-    query,
-    QueryConstraint,
-    QueryNonFilterConstraint
-} from "@react-native-firebase/firestore";
-
-import {
-    useInfiniteQuery as useInfiniteReactQuery,
-    UseInfiniteQueryOptions as UseReactInfiniteQueryOptions,
-    QueryKey,
-    UseInfiniteQueryResult,
-    InfiniteData
-} from "@tanstack/react-query";
-import { AppModel } from "../../types";
-import { QueryFilterConstraint } from "./utils/buildCompositeFilter";
-
-/**
- * @inline
- */
-type UseInfiniteQueryOptions<AppModelType extends AppModel = AppModel, TQueryKey extends QueryKey = QueryKey> = {
-    /**
-     * Reqct-query options that must include queryKey and shall not define queryFn
-     */
-    options: Omit<
-        UseReactInfiniteQueryOptions<
-            AppModelType[],
-            Error,
-            InfiniteData<AppModelType[]>,
-            TQueryKey,
-            QueryNonFilterConstraint
-        >,
-        "queryFn"
-    > &
-        Required<
-            Pick<
-                UseReactInfiniteQueryOptions<
-                    AppModelType[],
-                    Error,
-                    InfiniteData<AppModelType[]>,
-                    TQueryKey,
-                    QueryNonFilterConstraint
-                >,
-                "queryKey"
-            >
-        >;
-
-    /**
-     * Reference to a Firestore collection
-     */
-    collectionReference: FirebaseFirestoreTypes.CollectionReference<AppModelType>;
-
-    /**
-     * Non composite filter constraints such as limit, order, where
-     */
-    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-
-    /**
-     * Composite filter
-     */
-    compositeFilter?: QueryFilterConstraint;
-};
-
-/**
- * Executes an infinite query on a Firestore data source and returns the resulting documents as an array.
- *
- * @group Hook
- *
- * @param {UseInfiniteQueryOptions<AppModelType, TQueryKey>} options - Configuration options for the query.
- *
- * @returns {UseInfiniteQueryResult<InfiniteData<AppModelType[]>>} An object containing documents that match the query.
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const docs = useInfiniteQuery({
- *      options: {
- *          queryKey: ['key']
- *      },
- *      collectionReference: collection(),
- *  });
- *  console.log(docs);
- * };
- * ```
- */
-export const useInfiniteQuery = <AppModelType extends AppModel = AppModel, TQueryKey extends QueryKey = QueryKey>({
-    options,
-    collectionReference,
-    queryConstraints = [],
-    compositeFilter
-}: UseInfiniteQueryOptions<AppModelType, TQueryKey>): UseInfiniteQueryResult<InfiniteData<AppModelType[]>> => {
-    return useInfiniteReactQuery({
-        ...options,
-        queryFn: async ({ pageParam }) => {
-            const allQueryConstraints = [...queryConstraints, ...(pageParam ? [pageParam] : [])];
-            const queryToExecute = compositeFilter
-                ? query(collectionReference, compositeFilter, ...(allQueryConstraints as QueryNonFilterConstraint[]))
-                : query(collectionReference, ...(allQueryConstraints as QueryConstraint[]));
-
-            const querySnapshot: FirebaseFirestoreTypes.QuerySnapshot<AppModelType> = await getDocs<
-                AppModelType,
-                AppModelType
-            >(queryToExecute);
-            const docs: AppModelType[] = [];
-
-            if (querySnapshot) {
-                querySnapshot.forEach((doc) => {
-                    docs.push({ ...doc.data(), uid: doc.id });
-                });
-            }
-            return docs;
-        }
-    });
-};

package/react-native/firestore/useQuery.ts

@@ -1,89 +0,0 @@
-import {
-    FirebaseFirestoreTypes,
-    getDocs,
-    query,
-    QueryConstraint,
-    QueryNonFilterConstraint
-} from "@react-native-firebase/firestore";
-
-import {
-    UseQueryResult,
-    useQuery as useReactQuery,
-    UseQueryOptions as UseReactQueryOptions
-} from "@tanstack/react-query";
-import { AppModel } from "../../types";
-import { QueryFilterConstraint } from "./utils/buildCompositeFilter";
-
-/**
- * @inline
- */
-type UseQueryOptions<AppModelType extends AppModel = AppModel> = {
-    /**
-     * Reqct-query options that must include queryKey and shall not define queryFn
-     */
-    options: Omit<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryFn"> &
-        Required<Pick<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryKey">>;
-
-    /**
-     * Reference to a Firestore collection
-     */
-    collectionReference: FirebaseFirestoreTypes.CollectionReference<AppModelType>;
-
-    /**
-     * Non composite filter constraints such as limit, order, where
-     */
-    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-
-    /**
-     * Composite filter
-     */
-    compositeFilter?: QueryFilterConstraint;
-};
-
-/**
- * Executes a query on a Firestore data source and returns the resulting documents as an array.
- *
- * @group Hook
- *
- * @param {UseQueryOptions<AppModelType>} options - Configuration options for the query.
- *
- * @returns {UseQueryResult<AppModelType[]>} An object containing documents that match the query.
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const docs = useQuery({
- *      options: {
- *          queryKey: ['key']
- *      },
- *      collectionReference: collection(),
- *  });
- *  console.log(docs);
- * };
- * ```
- */
-export const useQuery = <AppModelType extends AppModel = AppModel>({
-    options,
-    collectionReference,
-    queryConstraints = [],
-    compositeFilter
-}: UseQueryOptions<AppModelType>): UseQueryResult<AppModelType[]> => {
-    return useReactQuery({
-        ...options,
-        queryFn: async () => {
-            const queryToExecute = compositeFilter
-                ? query(collectionReference, compositeFilter, ...(queryConstraints as QueryNonFilterConstraint[]))
-                : query(collectionReference, ...(queryConstraints as QueryConstraint[]));
-
-            const querySnapshot: FirebaseFirestoreTypes.QuerySnapshot<AppModelType> = await getDocs(queryToExecute);
-            const docs: AppModelType[] = [];
-
-            if (querySnapshot) {
-                querySnapshot.forEach((doc) => {
-                    docs.push({ ...doc.data(), uid: doc.id });
-                });
-            }
-            return docs;
-        }
-    });
-};

package/react-native/firestore/useQueryConstraints.ts

@@ -1,44 +0,0 @@
-import { type QueryNonFilterConstraint } from "@react-native-firebase/firestore";
-import { useMemo } from "react";
-import { AppModel } from "../../types/AppModel";
-import { type NonFilterQueryConstraint } from "../../types/QueryConstraints";
-import { buildQueryConstraint } from "./utils/buildQueryConstraint";
-
-/**
- * @inline
- */
-export type UseQueryConstraints<AppModelType extends AppModel = AppModel> = {
-    /**
-     * A list of constraints such as limit, order, offset.
-     */
-    constraints: NonFilterQueryConstraint<AppModelType>[];
-};
-
-/**
- * A hook to build a list of non-filter query constraints for firebase queries.
- * It uses buildQueryConstraint method and useMemo hook.
- *
- * @group Hook
- *
- * @param {UseQueryConstraints<AppModelType>} options
- *
- * @returns {FirebaseFirestoreTypes.QueryNonFilterConstraint}
- *
- * @example
- * ```jsx
- * const firebaseConfig = {};
- * export const constraint = useQueryConstraints([
- *  {
- *      type: 'limit',
- *      limit: 1
- *  }
- * ]};
- * ```
- */
-export const useQueryConstraints = <AppModelType extends AppModel = AppModel>({
-    constraints
-}: UseQueryConstraints<AppModelType>): QueryNonFilterConstraint[] => {
-    return useMemo(() => {
-        return constraints.map(buildQueryConstraint);
-    }, [constraints]);
-};