react-query-firebase 2.2.0 → 2.3.0

package/web/firestore/useCountQuery.js

@@ -3,15 +3,24 @@ import { useQuery as useReactQuery } from "@tanstack/react-query";
 /**
  * Executes a query with specified constraints and returns the count of matched documents.
  *
- * This function utilizes React Query to asynchronously fetch the count of documents from a server database
- * that match the provided query constraints and an optional composite filter.
+ * @group Hook
+ *
+ * @param {UseCountQueryOptions<AppModelType>} options - Configuration options for the query.
  *
- * @param {UseCountQueryOptions<AppModelType, DbModelType>} options - Configuration options for the query.
- * @param {AppModelType extends DocumentData = DocumentData} [options.options] - Additional options for the React Query.
- * @param {unknown} [options.query] - Reference to the query object to be executed.
- * @param {unknown[]} [options.queryConstraints=[]] - An array of constraints to apply to the query.
- * @param {unknown} [options.compositeFilter] - An optional composite filter to apply to the query.
  * @returns {UseQueryResult<number>} An object containing the number of documents that match the query.
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const count = useCountQuery({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      collectionReference: collection(),
+ *  });
+ *  console.log(count);
+ * };
+ * ```
  */
 export const useCountQuery = ({ options, collectionReference, queryConstraints = [], compositeFilter }) => {
     return useReactQuery({

package/web/firestore/useCountQuery.ts

@@ -1,5 +1,4 @@
 import {
-    DocumentData,
     getCountFromServer,
     CollectionReference,
     query,
@@ -13,36 +12,58 @@ import {
     useQuery as useReactQuery,
     UseQueryOptions as UseReactQueryOptions
 } from "@tanstack/react-query";
+import { QueryFilterConstraint } from "./useCompositeFilter";
+import { AppModel } from "../../types";
 
-type UseCountQueryOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
-> = {
+/**
+ * @inline
+ */
+type UseCountQueryOptions<AppModelType extends AppModel = AppModel, DbModelType extends AppModel = AppModel> = {
+    /**
+     * Reqct-query options that must include queryKey and shall not define queryFn
+     */
     options: Omit<UseReactQueryOptions<number, Error, number>, "queryFn"> &
         Required<Pick<UseReactQueryOptions<number, Error, number>, "queryKey">>;
+
+    /**
+     * Reference to a Firestore collection
+     */
     collectionReference: CollectionReference<AppModelType, DbModelType>;
+
+    /**
+     * Non composite filter constraints such as limit, order, where
+     */
     queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: QueryCompositeFilterConstraint;
+
+    /**
+     * Composite filter
+     */
+    compositeFilter?: QueryFilterConstraint;
 };
 
 /**
  * Executes a query with specified constraints and returns the count of matched documents.
  *
- * This function utilizes React Query to asynchronously fetch the count of documents from a server database
- * that match the provided query constraints and an optional composite filter.
+ * @group Hook
+ *
+ * @param {UseCountQueryOptions<AppModelType>} options - Configuration options for the query.
  *
- * @param {UseCountQueryOptions<AppModelType, DbModelType>} options - Configuration options for the query.
- * @param {AppModelType extends DocumentData = DocumentData} [options.options] - Additional options for the React Query.
- * @param {unknown} [options.query] - Reference to the query object to be executed.
- * @param {unknown[]} [options.queryConstraints=[]] - An array of constraints to apply to the query.
- * @param {unknown} [options.compositeFilter] - An optional composite filter to apply to the query.
  * @returns {UseQueryResult<number>} An object containing the number of documents that match the query.
+ *
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const count = useCountQuery({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      collectionReference: collection(),
+ *  });
+ *  console.log(count);
+ * };
+ * ```
  */
-
-export const useCountQuery = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
->({
+export const useCountQuery = <AppModelType extends AppModel = AppModel, DbModelType extends AppModel = AppModel>({
     options,
     collectionReference,
     queryConstraints = [],
@@ -52,7 +73,11 @@ export const useCountQuery = <
         ...options,
         queryFn: async () => {
             const queryToExecute = compositeFilter
-                ? query(collectionReference, compositeFilter, ...(queryConstraints as QueryNonFilterConstraint[]))
+                ? query(
+                      collectionReference,
+                      compositeFilter as QueryCompositeFilterConstraint,
+                      ...(queryConstraints as QueryNonFilterConstraint[])
+                  )
                 : query(collectionReference, ...queryConstraints);
 
             const querySnapshot = await getCountFromServer(queryToExecute);

package/web/firestore/useInfiniteQuery.d.ts

@@ -1,18 +1,49 @@
-import { CollectionReference, DocumentData, FirestoreDataConverter, QueryCompositeFilterConstraint, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
+import { CollectionReference, 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> = {
+import { QueryFilterConstraint } from "./useCompositeFilter";
+import { AppModel } from "../../types";
+/**
+ * @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[]>, AppModelType[], TQueryKey, QueryConstraint>, "queryFn"> & Required<Pick<UseReactInfiniteQueryOptions<AppModelType[], Error, InfiniteData<AppModelType[]>, AppModelType[], TQueryKey, QueryConstraint>, "queryKey">>;
-    collectionReference: CollectionReference<AppModelType, DbModelType>;
+    /**
+     * Reference to a Firestore collection
+     */
+    collectionReference: CollectionReference<AppModelType, AppModelType>;
+    /**
+     * Non composite filter constraints such as limit, order, where
+     */
     queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: QueryCompositeFilterConstraint;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+    /**
+     * Composite filter
+     */
+    compositeFilter?: QueryFilterConstraint;
 };
 /**
- * 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.
+ * 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.
  *
- * @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.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const docs = useInfiniteQuery({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      collectionReference: collection(),
+ *  });
+ *  console.log(docs);
+ * };
+ * ```
  */
-export declare const useInfiniteQuery: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, collectionReference, queryConstraints, compositeFilter, converter }: UseInfiniteQueryOptions<AppModelType, DbModelType>) => UseInfiniteQueryResult<InfiniteData<AppModelType[]>>;
+export declare const useInfiniteQuery: <AppModelType extends AppModel = AppModel, TQueryKey extends QueryKey = QueryKey>({ options, collectionReference, queryConstraints, compositeFilter }: UseInfiniteQueryOptions<AppModelType, TQueryKey>) => UseInfiniteQueryResult<InfiniteData<AppModelType[]>>;
 export {};

package/web/firestore/useInfiniteQuery.js

@@ -1,13 +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.
+ * Executes an infinite query on a Firestore data source and returns the resulting documents as an array.
  *
- * @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.
+ * @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 = ({ options, collectionReference, queryConstraints = [], compositeFilter, converter }) => {
+export const useInfiniteQuery = ({ options, collectionReference, queryConstraints = [], compositeFilter }) => {
     return useInfiniteReactQuery({
         ...options,
         queryFn: async ({ pageParam }) => {
@@ -15,7 +30,7 @@ export const useInfiniteQuery = ({ options, collectionReference, queryConstraint
             const queryToExecute = compositeFilter
                 ? query(collectionReference, compositeFilter, ...allQueryConstraints)
                 : query(collectionReference, ...allQueryConstraints);
-            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const querySnapshot = await getDocs(queryToExecute);
             const docs = [];
             if (querySnapshot) {
                 querySnapshot.forEach((doc) => {

package/web/firestore/useInfiniteQuery.ts

@@ -1,7 +1,5 @@
 import {
     CollectionReference,
-    DocumentData,
-    FirestoreDataConverter,
     getDocs,
     query,
     QueryCompositeFilterConstraint,
@@ -16,12 +14,16 @@ import {
     UseInfiniteQueryResult,
     InfiniteData
 } from "@tanstack/react-query";
+import { QueryFilterConstraint } from "./useCompositeFilter";
+import { AppModel } from "../../types";
 
-type UseInfiniteQueryOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData,
-    TQueryKey extends QueryKey = QueryKey
-> = {
+/**
+ * @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[],
@@ -46,38 +48,64 @@ type UseInfiniteQueryOptions<
                 "queryKey"
             >
         >;
-    collectionReference: CollectionReference<AppModelType, DbModelType>;
+
+    /**
+     * Reference to a Firestore collection
+     */
+    collectionReference: CollectionReference<AppModelType, AppModelType>;
+
+    /**
+     * Non composite filter constraints such as limit, order, where
+     */
     queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: QueryCompositeFilterConstraint;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+
+    /**
+     * Composite filter
+     */
+    compositeFilter?: QueryFilterConstraint;
 };
 
 /**
- * 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.
+ * 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.
  *
- * @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.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const docs = useInfiniteQuery({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      collectionReference: collection(),
+ *  });
+ *  console.log(docs);
+ * };
+ * ```
  */
-export const useInfiniteQuery = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
->({
+export const useInfiniteQuery = <AppModelType extends AppModel = AppModel, TQueryKey extends QueryKey = QueryKey>({
     options,
     collectionReference,
     queryConstraints = [],
-    compositeFilter,
-    converter
-}: UseInfiniteQueryOptions<AppModelType, DbModelType>): UseInfiniteQueryResult<InfiniteData<AppModelType[]>> => {
+    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,
+                      compositeFilter as QueryCompositeFilterConstraint,
+                      ...(allQueryConstraints as QueryNonFilterConstraint[])
+                  )
                 : query(collectionReference, ...allQueryConstraints);
 
-            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const querySnapshot = await getDocs(queryToExecute);
             const docs: AppModelType[] = [];
 
             if (querySnapshot) {

package/web/firestore/useQuery.d.ts

@@ -1,25 +1,49 @@
-import { DocumentData, FirestoreDataConverter, CollectionReference, QueryCompositeFilterConstraint, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
+import { CollectionReference, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
 import { UseQueryResult, UseQueryOptions as UseReactQueryOptions } from "@tanstack/react-query";
-type UseQueryOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = {
+import { QueryFilterConstraint } from "./useCompositeFilter";
+import { AppModel } from "../../types";
+/**
+ * @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">>;
-    collectionReference: CollectionReference<AppModelType, DbModelType>;
+    /**
+     * Reference to a Firestore collection
+     */
+    collectionReference: CollectionReference<AppModelType, AppModelType>;
+    /**
+     * Non composite filter constraints such as limit, order, where
+     */
     queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: QueryCompositeFilterConstraint;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+    /**
+     * Composite filter
+     */
+    compositeFilter?: QueryFilterConstraint;
 };
 /**
- * Executes a query on a Firestore-like data source and returns the resulting documents as an array.
+ * Executes a query on a Firestore data source and returns the resulting documents as an array.
+ *
+ * @group Hook
  *
- * 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>} options - Configuration options for the query.
  *
- * @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[]>} An object containing documents that match the query.
  *
- * @returns {UseQueryResult<AppModelType[]>} Result containing an array of documents that match the query criteria.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const docs = useQuery({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      collectionReference: collection(),
+ *  });
+ *  console.log(docs);
+ * };
+ * ```
  */
-export declare const useQuery: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, collectionReference, queryConstraints, compositeFilter, converter }: UseQueryOptions<AppModelType, DbModelType>) => UseQueryResult<AppModelType[]>;
+export declare const useQuery: <AppModelType extends AppModel = AppModel>({ options, collectionReference, queryConstraints, compositeFilter }: UseQueryOptions<AppModelType>) => UseQueryResult<AppModelType[]>;
 export {};

package/web/firestore/useQuery.js

@@ -1,27 +1,35 @@
 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.
+ * Executes a query on a Firestore 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.
+ * @group Hook
  *
- * @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.
+ * @param {UseQueryOptions<AppModelType>} options - Configuration options for the query.
  *
- * @returns {UseQueryResult<AppModelType[]>} Result containing an array of documents that match the query criteria.
+ * @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 = ({ options, collectionReference, queryConstraints = [], compositeFilter, converter }) => {
+export const useQuery = ({ options, collectionReference, queryConstraints = [], compositeFilter }) => {
     return useReactQuery({
         ...options,
         queryFn: async () => {
             const queryToExecute = compositeFilter
                 ? query(collectionReference, compositeFilter, ...queryConstraints)
                 : query(collectionReference, ...queryConstraints);
-            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const querySnapshot = await getDocs(queryToExecute);
             const docs = [];
             if (querySnapshot) {
                 querySnapshot.forEach((doc) => {

package/web/firestore/useQuery.ts

@@ -1,6 +1,4 @@
 import {
-    DocumentData,
-    FirestoreDataConverter,
     getDocs,
     CollectionReference,
     query,
@@ -14,51 +12,75 @@ import {
     useQuery as useReactQuery,
     UseQueryOptions as UseReactQueryOptions
 } from "@tanstack/react-query";
+import { QueryFilterConstraint } from "./useCompositeFilter";
+import { AppModel } from "../../types";
 
-type UseQueryOptions<
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
-> = {
+/**
+ * @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">>;
-    collectionReference: CollectionReference<AppModelType, DbModelType>;
+
+    /**
+     * Reference to a Firestore collection
+     */
+    collectionReference: CollectionReference<AppModelType, AppModelType>;
+
+    /**
+     * Non composite filter constraints such as limit, order, where
+     */
     queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: QueryCompositeFilterConstraint;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
+
+    /**
+     * Composite filter
+     */
+    compositeFilter?: QueryFilterConstraint;
 };
 
 /**
- * Executes a query on a Firestore-like data source and returns the resulting documents as an array.
+ * Executes a query on a Firestore data source and returns the resulting documents as an array.
+ *
+ * @group Hook
  *
- * 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>} options - Configuration options for the query.
  *
- * @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[]>} An object containing documents that match the query.
  *
- * @returns {UseQueryResult<AppModelType[]>} Result containing an array of documents that match the query criteria.
+ * @example
+ * ```jsx
+ * export const MyComponent = () => {
+ *  const docs = useQuery({
+ *      options: {
+ *          queryKey: ['key']
+ *      },
+ *      collectionReference: collection(),
+ *  });
+ *  console.log(docs);
+ * };
+ * ```
  */
-export const useQuery = <
-    AppModelType extends DocumentData = DocumentData,
-    DbModelType extends DocumentData = DocumentData
->({
+export const useQuery = <AppModelType extends AppModel = AppModel>({
     options,
     collectionReference,
     queryConstraints = [],
-    compositeFilter,
-    converter
-}: UseQueryOptions<AppModelType, DbModelType>): UseQueryResult<AppModelType[]> => {
+    compositeFilter
+}: UseQueryOptions<AppModelType>): UseQueryResult<AppModelType[]> => {
     return useReactQuery({
         ...options,
         queryFn: async () => {
             const queryToExecute = compositeFilter
-                ? query(collectionReference, compositeFilter, ...(queryConstraints as QueryNonFilterConstraint[]))
+                ? query(
+                      collectionReference,
+                      compositeFilter as QueryCompositeFilterConstraint,
+                      ...(queryConstraints as QueryNonFilterConstraint[])
+                  )
                 : query(collectionReference, ...queryConstraints);
 
-            const querySnapshot = await getDocs(converter ? queryToExecute.withConverter(converter) : queryToExecute);
+            const querySnapshot = await getDocs(queryToExecute);
             const docs: AppModelType[] = [];
 
             if (querySnapshot) {