react-query-firebase 2.13.3 → 2.13.4

package/web/firestore/useInfiniteQuery.ts

@@ -1,117 +0,0 @@
-import {
-    CollectionReference,
-    getDocs,
-    query,
-    QueryCompositeFilterConstraint,
-    QueryConstraint,
-    QueryNonFilterConstraint
-} from "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: CollectionReference<AppModelType, 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 as QueryCompositeFilterConstraint,
-                      ...(allQueryConstraints as QueryNonFilterConstraint[])
-                  )
-                : query(collectionReference, ...allQueryConstraints);
-
-            const querySnapshot = await getDocs(queryToExecute);
-            const docs: AppModelType[] = [];
-
-            if (querySnapshot) {
-                querySnapshot.forEach((doc) => {
-                    docs.push({ ...doc.data(), uid: doc.id });
-                });
-            }
-            return docs;
-        }
-    });
-};

package/web/firestore/useQuery.ts

@@ -1,94 +0,0 @@
-import {
-    getDocs,
-    CollectionReference,
-    query,
-    QueryCompositeFilterConstraint,
-    QueryConstraint,
-    QueryNonFilterConstraint
-} from "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: CollectionReference<AppModelType, 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 as QueryCompositeFilterConstraint,
-                      ...(queryConstraints as QueryNonFilterConstraint[])
-                  )
-                : query(collectionReference, ...queryConstraints);
-
-            const querySnapshot = await getDocs(queryToExecute);
-            const docs: AppModelType[] = [];
-
-            if (querySnapshot) {
-                querySnapshot.forEach((doc) => {
-                    docs.push({ ...doc.data(), uid: doc.id });
-                });
-            }
-            return docs;
-        }
-    });
-};

package/web/firestore/useQueryConstraints.ts

@@ -1,44 +0,0 @@
-import { QueryNonFilterConstraint } from "firebase/firestore";
-import { useMemo } from "react";
-import { AppModel } from "../../types/AppModel";
-import { 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>} constraints
- *
- * @returns {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]);
-};

package/web/firestore/useRunTransaction.ts

@@ -1,56 +0,0 @@
-import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { runTransaction, Transaction } from "firebase/firestore";
-
-import { FirebaseError } from "firebase/app";
-import { useFirestore } from "./useFirestore";
-
-/**
- * @inline
- */
-export type UseRunTransactionValues = <T = unknown>(transaction: Transaction) => T;
-
-/**
- * @inline
- */
-export type UseRunTransactionOptions<T = unknown, TContext = unknown> = {
-    /**
-     * Reqct-mutation options that shall omit mutationFn
-     */
-    options?: Omit<UseMutationOptions<T, FirebaseError, UseRunTransactionValues, TContext>, "mutationFn">;
-};
-
-/**
- * Executes a Firestore transaction
- *
- * @group Hook
- *
- * @param {UseRunTransactionOptions<T>} options - Configuration options for the mutation.
- *
- * @returns {UseMutationResult<T, Error>} An object representing mutation
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const doc = useGetDocData({
- *      options: {
- *          queryKey: ['key']
- *      },
- *      reference: collection(),
- *      path: 'id'
- *  });
- *  console.log(doc);
- * };
- * ```
- */
-export const useRunTransaction = <T = unknown, TContext = unknown>({
-    options = {}
-}: UseRunTransactionOptions<T, TContext>) => {
-    const db = useFirestore();
-
-    return useMutation({
-        ...options,
-        mutationFn: async (transactionFn) => {
-            return runTransaction<T>(db, transactionFn);
-        }
-    });
-};

package/web/firestore/useSetDocMutation.ts

@@ -1,77 +0,0 @@
-import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { DocumentReference, getDoc, setDoc, WithFieldValue } from "firebase/firestore";
-
-import { FirebaseError } from "firebase/app";
-import { useMemo } from "react";
-import { AppModel } from "../../types";
-
-/**
- * @inline
- */
-export type UseSetDocMutationValues<AppModelType extends AppModel = AppModel> = {
-    /**
-     * Data to write
-     */
-    data: WithFieldValue<AppModelType>;
-};
-
-/**
- * @inline
- */
-export type UseSetDocMutationOptions<AppModelType extends AppModel = AppModel, TContext = unknown> = {
-    /**
-     * Reference to a document that must be written
-     */
-    reference: DocumentReference<AppModelType, AppModelType> | null;
-    /**
-     * Options for useMutation hook excluding mutationFn.
-     */
-    options?: Omit<
-        UseMutationOptions<AppModelType, FirebaseError, UseSetDocMutationValues<AppModelType>, TContext>,
-        "mutationFn"
-    >;
-};
-
-/**
- * Executes a mutation and returns added document
- *
- * @group Hook
- *
- * @param {UseSetDocMutationOptions<AppModelType>} options - Configuration options for mutation.
- *
- * @returns {UseMutationResult<AppModelType, Error, UseAddDocMutationValues<AppModelType>, TContext>}  A mutation result
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const {mutate} = useSetDocMutation({
- *      options: {
- *      },
- *      reference: collection().doc(),
- *  });
- *
- *  // ....
- *  mutate({data: {test: 'value'}});
- *  // ....
- * };
- * ```
- */
-export const useSetDocMutation = <AppModelType extends AppModel = AppModel, TContext = unknown>({
-    reference,
-    options
-}: UseSetDocMutationOptions<AppModelType, TContext>) => {
-    const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
-
-    return useMutation({
-        ...options,
-        mutationKey,
-        mutationFn: async ({ data }) => {
-            if (!reference) {
-                throw new Error("Reference is undefined");
-            }
-            await setDoc<AppModelType, AppModelType>(reference, data);
-            const docSnap = await getDoc(reference);
-            return { ...(docSnap.data() as AppModelType), uid: docSnap.id };
-        }
-    });
-};

package/web/firestore/useUpdateDocMutation.ts

@@ -1,78 +0,0 @@
-import { useMutation, UseMutationOptions } from "@tanstack/react-query";
-import { updateDoc, getDoc, DocumentReference, UpdateData } from "firebase/firestore";
-
-import { FirebaseError } from "firebase/app";
-import { useMemo } from "react";
-import { AppModel } from "../../types";
-
-/**
- * @inline
- */
-export type UseUpdateDocMutationValues<AppModelType extends AppModel = AppModel> = {
-    /**
-     * Data to write
-     */
-    data: UpdateData<AppModelType>;
-};
-
-/**
- * @inline
- */
-export type UseUpdateDocMutationOptions<AppModelType extends AppModel = AppModel, TContext = unknown> = {
-    /**
-     * Reference to a document that must be updated
-     */
-    reference: DocumentReference<AppModelType, AppModelType> | null;
-    /**
-     * Options for useMutation hook excluding mutationFn.
-     */
-    options?: Omit<
-        UseMutationOptions<AppModelType, FirebaseError, UseUpdateDocMutationValues<AppModelType>, TContext>,
-        "mutationFn"
-    >;
-};
-
-/**
- * Executes a mutation and returns updated document
- *
- * @group Hook
- *
- * @param {UseUpdateDocMutationOptions<AppModelType>} options - Configuration options for mutation.
- *
- * @returns {UseMutationResult<AppModelType, Error, UseAddDocMutationValues<AppModelType>, TContext>}  A mutation result
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const {mutate} = useUpdateDocMutation({
- *      options: {
- *      },
- *      reference: collection().doc(),
- *  });
- *
- *  // ....
- *  mutate({data: {test: 'value'}});
- *  // ....
- * };
- * ```
- */
-export const useUpdateDocMutation = <AppModelType extends AppModel = AppModel, TContext = unknown>({
-    reference,
-    options = {}
-}: UseUpdateDocMutationOptions<AppModelType, TContext>) => {
-    const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
-
-    return useMutation({
-        ...options,
-        mutationFn: async ({ data }) => {
-            if (!reference) {
-                throw new Error("Reference is undefined");
-            }
-
-            await updateDoc<AppModelType, AppModelType>(reference, data);
-            const docSnap = await getDoc(reference);
-            return { ...(docSnap.data() as AppModelType), uid: docSnap.id };
-        },
-        mutationKey
-    });
-};

package/web/firestore/utils/buildCompositeFilter.ts

@@ -1,73 +0,0 @@
-import {
-    QueryFilterConstraint as FBQueryFilterConstraint,
-    QueryCompositeFilterConstraint as FBQueryCompositeFilterConstraint,
-    WhereFilterOp,
-    or,
-    and,
-    where,
-    documentId
-} from "firebase/firestore";
-import { AppModel } from "../../../types/AppModel";
-
-export type QueryFilterConstraint = FBQueryFilterConstraint | FBQueryCompositeFilterConstraint;
-
-export type QueryElement<AppModelType extends AppModel = AppModel> = {
-    operator?: "OR" | "AND";
-    children?: QueryElement[];
-    field?: keyof (AppModelType & { documentId?: string[] });
-    value?: AppModelType[keyof AppModelType];
-    op?: WhereFilterOp;
-};
-
-export type CompositeFilter<AppModelType extends AppModel = AppModel> = {
-    operator: "OR" | "AND";
-    children: QueryElement<AppModelType & { documentId?: string[] }>[];
-};
-/**
- * Constructs a composite or where query filter based on the provided query structure.
- * It recursively builds query constraints using logical "or" or "and" operators.
- *
- * @group Utility
- *
- * @param {QueryElement<AppModelType>} query
- *
- * @returns {QueryFilterConstraint | null}
- *
- * @example
- * ```jsx
- * export const MyComponent = () => {
- *  const filter = buildCompositeFilter({
- *      operator: "AND",
- *      children: [
- *          {
- *              field: "field",
- *              value: "value",
- *              op: "=="
- *          },
- *          ...(query ? [query] : [])
- *      ]
- *  });
- *  console.log(filter);
- * };
- * ```
- */
-
-export const buildCompositeFilter = <AppModelType extends AppModel = AppModel>(
-    query: QueryElement<AppModelType>
-): QueryFilterConstraint | null => {
-    if (query.children) {
-        const queryConstraints = query.children.map(buildCompositeFilter).filter((constraint) => !!constraint);
-
-        if (queryConstraints.length <= 0) {
-            return null;
-        }
-
-        return (query as CompositeFilter).operator === "OR" ? or(...queryConstraints) : and(...queryConstraints);
-    }
-
-    if (query.field && query.op) {
-        return where(query.field === "documentId" ? documentId() : (query.field as string), query.op, query.value);
-    }
-
-    return null;
-};

package/web/firestore/utils/buildQueryConstraint.ts

@@ -1,55 +0,0 @@
-import {
-    QueryNonFilterConstraint,
-    orderBy,
-    startAt,
-    startAfter,
-    endAt,
-    endBefore,
-    limit,
-    limitToLast
-} from "firebase/firestore";
-import { AppModel, NonFilterQueryConstraint } from "../../../types";
-
-/**
- * A generic mothod to build query constraints for firebase
- *
- * @group Utility
- *
- * @param {NonFilterQueryConstraint<AppModelType>} constraint
- *
- * @returns {QueryNonFilterConstraint}
- *
- * @example
- * ```jsx
- * const firebaseConfig = {};
- * export const constraint = useMemo(() => {
- *  return buildQueryConstraint({
- *      type: 'limit',
- *      limit: 1
- *  });
- * };
- * ```
- */
-
-export const buildQueryConstraint = <AppModelType extends AppModel = AppModel>(
-    constraint: NonFilterQueryConstraint<AppModelType>
-): QueryNonFilterConstraint => {
-    switch (constraint.type) {
-        case "orderBy":
-            return orderBy(constraint.fieldPath as string, constraint.directionStr);
-        case "startAt":
-            return startAt(...constraint.arguments);
-        case "startAfter":
-            return startAfter(...constraint.arguments);
-        case "endAt":
-            return endAt(...constraint.arguments);
-        case "endBefore":
-            return endBefore(...constraint.arguments);
-        case "limit":
-            return limit(constraint.limit);
-        case "limitToLast":
-            return limitToLast(constraint.limit);
-        default:
-            throw new Error(`Unsupported constaint ${JSON.stringify(constraint)}`);
-    }
-};

package/web/firestore/utils/getDocData.ts

@@ -1,33 +0,0 @@
-import { AppModel } from "../../../types";
-import { getDocSnap, GetDocSnapOptions } from "./getDocSnap";
-
-/**
- * @inline
- */
-export type GetDocDataOptions<AppModelType extends AppModel = AppModel> = GetDocSnapOptions<AppModelType>;
-
-/**
- * Asynchronously retrieves document data from a specified database reference.
- * Utilizes the helper function `getDocSnap` to fetch the document snapshot and
- * checks if the document exists before returning its data.
- *
- * @group Utility
- *
- * @param {GetDocDataOptions<AppModelType>} options - The options for fetching document data.
- *
- * @returns {Promise<AppModelType | null>} Returns a promise that resolves to the document data if it exists, or null if the document does not exist.
- */
-export const getDocData = async <AppModelType extends AppModel = AppModel>({
-    db,
-    reference,
-    path,
-    pathSegments
-}: GetDocDataOptions<AppModelType>) => {
-    const docSnap = await getDocSnap<AppModelType>({ db, reference, path, pathSegments });
-
-    if (docSnap && docSnap.exists()) {
-        return { ...docSnap.data(), uid: docSnap.id };
-    }
-
-    return null;
-};

package/web/firestore/utils/getDocRef.ts

@@ -1,43 +0,0 @@
-import { CollectionReference, doc, DocumentReference, Firestore } from "firebase/firestore";
-import { AppModel } from "../../../types";
-
-/**
- * @inline
- */
-export type GetDocRefOptions<AppModelType extends AppModel = AppModel> = {
-    db: Firestore;
-    reference?: CollectionReference<AppModelType, AppModelType> | DocumentReference<AppModelType, AppModelType>;
-    path?: string;
-    pathSegments?: string[];
-};
-
-/**
- * Retrieves a document reference based on provided database options.
- * Either `reference` or `path`.
- *
- * @group Utility
- *
- * @param {GetDocRefOptions<AppModelType>} options - The options for building doc reference.
- *
- * @returns {DocumentReference<AppModelType, AppModelType>} Returns a document reference
- */
-export const getDocRef = <AppModelType extends AppModel = AppModel>({
-    db,
-    reference,
-    path,
-    pathSegments
-}: GetDocRefOptions<AppModelType>) => {
-    if ((!reference && !path) || (reference && !path)) {
-        return null;
-    }
-
-    const docRef = !reference
-        ? (doc(db, path as string, ...(pathSegments || [])) as DocumentReference<AppModelType, AppModelType>)
-        : reference.type === "collection"
-          ? (doc(reference, path, ...(pathSegments || [])) as DocumentReference<AppModelType, AppModelType>)
-          : reference.type === "document"
-            ? (doc(reference, path as string, ...(pathSegments || [])) as DocumentReference<AppModelType, AppModelType>)
-            : null;
-
-    return docRef;
-};