react-query-firebase 2.0.0-rc5 → 2.0.0-rc7

package/web/firestore/useDocReference.js

@@ -0,0 +1,45 @@
+import { doc } from "firebase/firestore";
+import { useEffect, useRef } from "react";
+import { useFirestore } from "./useFirestore";
+/**
+ * Generates a document reference for a specified path or reference in Firestore.
+ * 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 {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.
+ */
+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 || [])));
+};
+/**
+ * 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 {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.
+ */
+export const useDocReference = ({ path, reference, pathSegments }) => {
+    const db = useFirestore();
+    const ref = useRef(getDocReference(db, { path, pathSegments, reference }));
+    useEffect(() => {
+        ref.current = getDocReference(db, { path, pathSegments, reference });
+    }, [path, reference, pathSegments]);
+    return ref.current;
+};

package/web/firestore/useDocReference.ts

@@ -0,0 +1,68 @@
+import { doc, CollectionReference, DocumentData, DocumentReference, Firestore } from "firebase/firestore";
+
+import { useEffect, useRef } from "react";
+import { useFirestore } from "./useFirestore";
+
+export type UseDocReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
+    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    path?: string;
+    pathSegments?: string[];
+};
+
+/**
+ * Generates a document reference for a specified path or reference in Firestore.
+ * 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 {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.
+ */
+const getDocReference = <AppModelType, DbModelType extends DocumentData = DocumentData>(
+    db: Firestore,
+    { path, pathSegments, reference }: UseDocReferenceOptions<AppModelType, DbModelType>
+) => {
+    if (!path) {
+        return null;
+    }
+
+    return (
+        !reference
+            ? doc(db, path || "", ...(pathSegments || []))
+            : reference.type === "collection"
+              ? doc(reference, path, ...(pathSegments || []))
+              : doc(reference, path, ...(pathSegments || []))
+    ) as DocumentReference<AppModelType, DbModelType>;
+};
+
+/**
+ * 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 {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.
+ */
+export const useDocReference = <AppModelType, DbModelType extends DocumentData = DocumentData>({
+    path,
+    reference,
+    pathSegments
+}: UseDocReferenceOptions<AppModelType, DbModelType>) => {
+    const db = useFirestore();
+    const ref = useRef<DocumentReference<AppModelType, DbModelType> | null>(
+        getDocReference(db, { path, pathSegments, reference })
+    );
+
+    useEffect(() => {
+        ref.current = getDocReference(db, { path, pathSegments, reference });
+    }, [path, reference, pathSegments]);
+
+    return ref.current;
+};

package/web/firestore/useDocReferences.d.ts

@@ -0,0 +1,23 @@
+import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+export type UseDocReferencesOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
+    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    path: string;
+    pathSegments?: string[];
+};
+/**
+ * A custom hook to generate document references for Firebase Firestore documents using given
+ * reference options.
+ *
+ * The hook accepts an array of options, where each option may contain a path,
+ * an existing reference, or path segments, and returns an array of generated
+ * Firestore document references based on those options. The references can be used
+ * to interact with the Firestore database documents. It uses memoization to optimize
+ * reference generation.
+ *
+ * @param {UseDocReferencesOptions<AppModelType, DbModelType>[]} 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
+ * generated from the options provided.
+ */
+export declare const useDocReferences: <AppModelType, DbModelType extends DocumentData = DocumentData>(references: UseDocReferencesOptions<AppModelType, DbModelType>[]) => DocumentReference<AppModelType, DbModelType>[];

package/web/firestore/useDocReferences.js

@@ -0,0 +1,31 @@
+import { doc } from "firebase/firestore";
+import { useMemo } from "react";
+import { useFirestore } from "./useFirestore";
+/**
+ * A custom hook to generate document references for Firebase Firestore documents using given
+ * reference options.
+ *
+ * The hook accepts an array of options, where each option may contain a path,
+ * an existing reference, or path segments, and returns an array of generated
+ * Firestore document references based on those options. The references can be used
+ * to interact with the Firestore database documents. It uses memoization to optimize
+ * reference generation.
+ *
+ * @param {UseDocReferencesOptions<AppModelType, DbModelType>[]} 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
+ * generated from the options provided.
+ */
+export const useDocReferences = (references) => {
+    const db = useFirestore();
+    return useMemo(() => {
+        return references.map(({ path, reference, pathSegments }) => {
+            return (!reference
+                ? doc(db, path || "", ...(pathSegments || []))
+                : reference.type === "collection"
+                    ? doc(reference, path, ...(pathSegments || []))
+                    : doc(reference, path, ...(pathSegments || [])));
+        });
+    }, [references]);
+};

package/web/firestore/useDocReferences.ts

@@ -0,0 +1,44 @@
+import { CollectionReference, doc, DocumentData, DocumentReference } from "firebase/firestore";
+
+import { useMemo } from "react";
+import { useFirestore } from "./useFirestore";
+
+export type UseDocReferencesOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
+    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    path: string;
+    pathSegments?: string[];
+};
+
+/**
+ * A custom hook to generate document references for Firebase Firestore documents using given
+ * reference options.
+ *
+ * The hook accepts an array of options, where each option may contain a path,
+ * an existing reference, or path segments, and returns an array of generated
+ * Firestore document references based on those options. The references can be used
+ * to interact with the Firestore database documents. It uses memoization to optimize
+ * reference generation.
+ *
+ * @param {UseDocReferencesOptions<AppModelType, DbModelType>[]} 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
+ * generated from the options provided.
+ */
+export const useDocReferences = <AppModelType, DbModelType extends DocumentData = DocumentData>(
+    references: UseDocReferencesOptions<AppModelType, DbModelType>[]
+) => {
+    const db = useFirestore();
+
+    return useMemo(() => {
+        return references.map(({ path, reference, pathSegments }) => {
+            return (
+                !reference
+                    ? doc(db, path || "", ...(pathSegments || []))
+                    : reference.type === "collection"
+                      ? doc(reference, path, ...(pathSegments || []))
+                      : doc(reference, path, ...(pathSegments || []))
+            ) as DocumentReference<AppModelType, DbModelType>;
+        });
+    }, [references]);
+};

package/web/firestore/useFirestore.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Provides a hook to access the Firestore instance from the Firebase context.
+ * It extracts the Firestore object from the Firebase context, allowing components to interact with Firestore services.
+ *
+ * @returns {firestore.Firestore} The Firestore instance from the Firebase context.
+ */
+export declare const useFirestore: () => import("@firebase/firestore").Firestore;

package/web/firestore/useFirestore.js

@@ -0,0 +1,12 @@
+import { useContext } from "react";
+import { FirebaseContext } from "../context/FirebaseContext";
+/**
+ * Provides a hook to access the Firestore instance from the Firebase context.
+ * It extracts the Firestore object from the Firebase context, allowing components to interact with Firestore services.
+ *
+ * @returns {firestore.Firestore} The Firestore instance from the Firebase context.
+ */
+export const useFirestore = () => {
+    const { firestore } = useContext(FirebaseContext);
+    return firestore;
+};

package/web/firestore/useFirestore.ts

@@ -0,0 +1,13 @@
+import { useContext } from "react";
+import { FirebaseContext } from "../context/FirebaseContext";
+
+/**
+ * Provides a hook to access the Firestore instance from the Firebase context.
+ * It extracts the Firestore object from the Firebase context, allowing components to interact with Firestore services.
+ *
+ * @returns {firestore.Firestore} The Firestore instance from the Firebase context.
+ */
+export const useFirestore = () => {
+    const { firestore } = useContext(FirebaseContext);
+    return firestore;
+};

package/web/firestore/useGetDocData.d.ts

@@ -0,0 +1,18 @@
+import { CollectionReference, DocumentData, DocumentReference } from "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">>;
+    path?: string;
+    pathSegments?: string[];
+    reference: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+};
+/**
+ * Custom React Hook to retrieve document data from Firestore using specified parameters.
+ * @param {Object} options - The options for configuring the Firestore query.
+ * @param {string} reference - The reference to the document in Firestore.
+ * @param {string} path - The path to the document in Firestore.
+ * @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 {};

package/web/firestore/useGetDocData.js

@@ -0,0 +1,18 @@
+import { useFirestore } from "./useFirestore";
+import { getDocData } from "./utils/getDocData";
+import { useQuery } from "@tanstack/react-query";
+/**
+ * Custom React Hook to retrieve document data from Firestore using specified parameters.
+ * @param {Object} options - The options for configuring the Firestore query.
+ * @param {string} reference - The reference to the document in Firestore.
+ * @param {string} path - The path to the document in Firestore.
+ * @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 const useGetDocData = ({ options, reference, path, pathSegments }) => {
+    const db = useFirestore();
+    return useQuery({
+        ...options,
+        queryFn: () => getDocData({ db, reference, path, pathSegments })
+    });
+};

package/web/firestore/useGetDocData.ts

@@ -0,0 +1,41 @@
+import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+
+import { useFirestore } from "./useFirestore";
+import { getDocData } from "./utils/getDocData";
+import { useQuery, 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">>;
+    path?: string;
+    pathSegments?: string[];
+    reference: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+};
+
+/**
+ * Custom React Hook to retrieve document data from Firestore using specified parameters.
+ * @param {Object} options - The options for configuring the Firestore query.
+ * @param {string} reference - The reference to the document in Firestore.
+ * @param {string} path - The path to the document in Firestore.
+ * @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 const useGetDocData = <
+    AppModelType extends DocumentData = DocumentData,
+    DbModelType extends DocumentData = DocumentData
+>({
+    options,
+    reference,
+    path,
+    pathSegments
+}: UseGetDocOptions<AppModelType, DbModelType>) => {
+    const db = useFirestore();
+
+    return useQuery({
+        ...options,
+        queryFn: () => getDocData<AppModelType, DbModelType>({ db, reference, path, pathSegments })
+    });
+};

package/web/firestore/useGetRealtimeDocData.d.ts

@@ -0,0 +1,57 @@
+import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
+import { FirebaseError } from "firebase/app";
+/**
+ * @inline
+ */
+export type UseGetRealtimeDocDataOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
+    /**
+     * A slash-separated path to a document. Has to be omitted to use
+     */
+    path?: string;
+    /**
+     * A reference to a collection.
+     */
+    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    /**
+     * 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: FirebaseError) => unknown;
+};
+/**
+ * @inline
+ */
+export type UseGetRealtimeDocDataResult<AppModelType> = {
+    data: AppModelType | null;
+    isError: boolean;
+    error: FirebaseError | 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 declare const useGetRealtimeDocData: <AppModelType, DbModelType extends DocumentData = DocumentData>({ path, pathSegments, reference, onError }: UseGetRealtimeDocDataOptions<AppModelType, DbModelType>) => UseGetRealtimeDocDataResult<AppModelType>;

package/web/firestore/useGetRealtimeDocData.js

@@ -0,0 +1,56 @@
+import { onSnapshot } from "firebase/firestore";
+import { useEffect, useMemo, useState } from "react";
+import { useDocReference } from "./useDocReference";
+/**
+ * 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 = ({ path, pathSegments, reference, onError }) => {
+    const ref = useDocReference({ path, reference, pathSegments });
+    const [doc, setDoc] = useState(null);
+    const [isError, setIsError] = useState(false);
+    const [isFetching, setIsFetching] = useState(true);
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        const unsubscribe = ref
+            ? onSnapshot(ref, {
+                next: async (snapshot) => {
+                    setIsFetching(false);
+                    setDoc(snapshot.data() || null);
+                    setError(null);
+                    setIsError(false);
+                },
+                error: (e) => {
+                    setIsError(true);
+                    setError(e);
+                    onError?.(e);
+                }
+            })
+            : () => { };
+        return () => unsubscribe();
+    }, [ref, doc, isError, onError, isFetching, error]);
+    return useMemo(() => ({
+        data: doc,
+        isError,
+        isFetching,
+        error
+    }), [doc, isError, error]);
+};

package/web/firestore/useGetRealtimeDocData.ts

@@ -0,0 +1,104 @@
+import { CollectionReference, DocumentData, DocumentReference, onSnapshot } from "firebase/firestore";
+
+import { useEffect, useMemo, useState } from "react";
+import { FirebaseError } from "firebase/app";
+import { useDocReference } from "./useDocReference";
+
+/**
+ * @inline
+ */
+export type UseGetRealtimeDocDataOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
+    /**
+     * A slash-separated path to a document. Has to be omitted to use
+     */
+    path?: string;
+    /**
+     * A reference to a collection.
+     */
+    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
+    /**
+     * 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: FirebaseError) => unknown;
+};
+
+/**
+ * @inline
+ */
+export type UseGetRealtimeDocDataResult<AppModelType> = {
+    data: AppModelType | null;
+    isError: boolean;
+    error: FirebaseError | 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, DbModelType extends DocumentData = DocumentData>({
+    path,
+    pathSegments,
+    reference,
+    onError
+}: UseGetRealtimeDocDataOptions<AppModelType, DbModelType>): 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<FirebaseError | null>(null);
+
+    useEffect(() => {
+        const unsubscribe = ref
+            ? onSnapshot(ref, {
+                  next: async (snapshot) => {
+                      setIsFetching(false);
+                      setDoc(snapshot.data() || null);
+                      setError(null);
+                      setIsError(false);
+                  },
+                  error: (e) => {
+                      setIsError(true);
+                      setError(e);
+                      onError?.(e);
+                  }
+              })
+            : () => {};
+
+        return () => unsubscribe();
+    }, [ref, doc, isError, onError, isFetching, error]);
+
+    return useMemo(
+        () => ({
+            data: doc,
+            isError,
+            isFetching,
+            error
+        }),
+        [doc, isError, error]
+    );
+};

package/web/firestore/useInfiniteQuery.d.ts

@@ -0,0 +1,18 @@
+import { DocumentData, FirestoreDataConverter, Query, QueryCompositeFilterConstraint, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
+import { UseInfiniteQueryOptions as UseReactInfiniteQueryOptions, QueryKey, UseInfiniteQueryResult, InfiniteData } from "@tanstack/react-query";
+type UseInfiniteQueryOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TQueryKey extends QueryKey = QueryKey> = {
+    options: Omit<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, QueryConstraint>, "queryFn"> & Required<Pick<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, QueryConstraint>, "queryKey">>;
+    query: Query<AppModelType, DbModelType>;
+    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
+    compositeFilter?: QueryCompositeFilterConstraint;
+    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+};
+/**
+ * Custom hook that creates an infinite query using Firestore, allowing for query constraints, composite filters, and converters.
+ * It fetches data in pages and can load more as required.
+ *
+ * @param {UseInfiniteQueryOptions<AppModelType, DbModelType>} options - Configuration options for the infinite query, including Firestore query reference, query constraints, composite filter, and data converter.
+ * @returns {UseInfiniteQueryResult<InfiniteData<AppModelType[]>>} Result object containing the infinite data and methods for fetching more pages.
+ */
+export declare const useInfiniteQuery: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, query: queryReference, queryConstraints, compositeFilter, converter }: UseInfiniteQueryOptions<AppModelType, DbModelType>) => UseInfiniteQueryResult<InfiniteData<AppModelType[]>>;
+export {};

package/web/firestore/useInfiniteQuery.js

@@ -0,0 +1,28 @@
+import { getDocs, query } from "firebase/firestore";
+import { useInfiniteQuery as useInfiniteReactQuery } from "@tanstack/react-query";
+/**
+ * Custom hook that creates an infinite query using Firestore, allowing for query constraints, composite filters, and converters.
+ * It fetches data in pages and can load more as required.
+ *
+ * @param {UseInfiniteQueryOptions<AppModelType, DbModelType>} options - Configuration options for the infinite query, including Firestore query reference, query constraints, composite filter, and data converter.
+ * @returns {UseInfiniteQueryResult<InfiniteData<AppModelType[]>>} Result object containing the infinite data and methods for fetching more pages.
+ */
+export const useInfiniteQuery = ({ options, query: queryReference, queryConstraints = [], compositeFilter, converter }) => {
+    return useInfiniteReactQuery({
+        ...options,
+        queryFn: async ({ pageParam }) => {
+            const allQueryConstraints = [...queryConstraints, ...(pageParam ? [pageParam] : [])];
+            const queryToExecute = compositeFilter
+                ? query(queryReference, compositeFilter, ...allQueryConstraints)
+                : query(queryReference, ...allQueryConstraints);
+            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const docs = [];
+            if (querySnapshot) {
+                querySnapshot.forEach((doc) => {
+                    docs.push(doc.data());
+                });
+            }
+            return docs;
+        }
+    });
+};