react-query-firebase 2.0.0-rc6 → 2.0.0-rc7

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;
+        }
+    });
+};

package/web/firestore/useInfiniteQuery.ts

@@ -0,0 +1,91 @@
+import {
+    DocumentData,
+    FirestoreDataConverter,
+    getDocs,
+    Query,
+    query,
+    QueryCompositeFilterConstraint,
+    QueryConstraint,
+    QueryNonFilterConstraint
+} from "firebase/firestore";
+
+import {
+    useInfiniteQuery as useInfiniteReactQuery,
+    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 const useInfiniteQuery = <
+    AppModelType extends DocumentData = DocumentData,
+    DbModelType extends DocumentData = DocumentData
+>({
+    options,
+    query: queryReference,
+    queryConstraints = [],
+    compositeFilter,
+    converter
+}: UseInfiniteQueryOptions<AppModelType, DbModelType>): UseInfiniteQueryResult<InfiniteData<AppModelType[]>> => {
+    return useInfiniteReactQuery({
+        ...options,
+        queryFn: async ({ pageParam }) => {
+            const allQueryConstraints = [...queryConstraints, ...(pageParam ? [pageParam] : [])];
+            const queryToExecute = compositeFilter
+                ? query(queryReference, compositeFilter, ...(allQueryConstraints as QueryNonFilterConstraint[]))
+                : query(queryReference, ...allQueryConstraints);
+
+            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const docs: AppModelType[] = [];
+
+            if (querySnapshot) {
+                querySnapshot.forEach((doc) => {
+                    docs.push(doc.data());
+                });
+            }
+            return docs;
+        }
+    });
+};

package/web/firestore/useQuery.d.ts

@@ -0,0 +1,25 @@
+import { DocumentData, FirestoreDataConverter, Query, QueryCompositeFilterConstraint, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
+import { UseQueryResult, UseQueryOptions as UseReactQueryOptions } from "@tanstack/react-query";
+type UseQueryOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = {
+    options: Omit<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryFn"> & Required<Pick<UseReactQueryOptions<AppModelType[], Error, AppModelType[]>, "queryKey">>;
+    query: Query<AppModelType, DbModelType>;
+    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
+    compositeFilter?: QueryCompositeFilterConstraint;
+    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+};
+/**
+ * Executes a query on a Firestore-like data source and returns the resulting documents as an array.
+ *
+ * This hook utilizes an abstraction over React Query to asynchronously fetch data based on the provided query
+ * reference and constraints. It supports optional filtering, conversion, and additional query constraints.
+ *
+ * @param {UseQueryOptions<AppModelType, DbModelType>}  options - Configuration options for the query.
+ * @param {DocumentReference<AppModelType>}  queryReference - The reference to the query to be executed.
+ * @param {QueryConstraint[]}  queryConstraints - Additional constraints to fine-tune the query.
+ * @param {QueryConstraint}  compositeFilter - Optional composite filter to apply to the query.
+ * @param {FirestoreDataConverter<AppModelType>}  converter - Optional data converter for transforming snapshots.
+ *
+ * @returns {UseQueryResult<AppModelType[]>} Result containing an array of documents that match the query criteria.
+ */
+export declare const useQuery: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, query: queryReference, queryConstraints, compositeFilter, converter }: UseQueryOptions<AppModelType, DbModelType>) => UseQueryResult<AppModelType[]>;
+export {};

package/web/firestore/useQuery.js

@@ -0,0 +1,34 @@
+import { getDocs, query } from "firebase/firestore";
+import { useQuery as useReactQuery } from "@tanstack/react-query";
+/**
+ * Executes a query on a Firestore-like data source and returns the resulting documents as an array.
+ *
+ * This hook utilizes an abstraction over React Query to asynchronously fetch data based on the provided query
+ * reference and constraints. It supports optional filtering, conversion, and additional query constraints.
+ *
+ * @param {UseQueryOptions<AppModelType, DbModelType>}  options - Configuration options for the query.
+ * @param {DocumentReference<AppModelType>}  queryReference - The reference to the query to be executed.
+ * @param {QueryConstraint[]}  queryConstraints - Additional constraints to fine-tune the query.
+ * @param {QueryConstraint}  compositeFilter - Optional composite filter to apply to the query.
+ * @param {FirestoreDataConverter<AppModelType>}  converter - Optional data converter for transforming snapshots.
+ *
+ * @returns {UseQueryResult<AppModelType[]>} Result containing an array of documents that match the query criteria.
+ */
+export const useQuery = ({ options, query: queryReference, queryConstraints = [], compositeFilter, converter }) => {
+    return useReactQuery({
+        ...options,
+        queryFn: async () => {
+            const queryToExecute = compositeFilter
+                ? query(queryReference, compositeFilter, ...queryConstraints)
+                : query(queryReference, ...queryConstraints);
+            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const docs = [];
+            if (querySnapshot) {
+                querySnapshot.forEach((doc) => {
+                    docs.push(doc.data());
+                });
+            }
+            return docs;
+        }
+    });
+};