react-query-firebase 2.0.2 → 2.1.0

package/web/auth/useSendEmailVerificationMutation.js

@@ -1,16 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { sendEmailVerification } from "firebase/auth";
-import { SEND_EMAIL_VERIFICATION_MUTATION_KEY } from "./mutation-keys";
-/**
- * A custom hook to create a mutation for sending an email verification to a user using Firebase.
- * This uses the `useMutation` hook from a query library and wraps it with specific configuration options.
- * @param {Omit<UseMutationOptions<void, FirebaseError, UseSendEmailVerificationMutationVariables, TContext>, "queryKey" | "queryFn">} options - Configuration options for the mutation, excluding `queryKey` and `queryFn`.
- * @returns {UseMutationResult<void, FirebaseError, UseSendEmailVerificationMutationVariables, TContext>} An object containing mutation state and functions for managing the mutation lifecycle.
- */
-export const useSendEmailVerificationMutation = (options = {}) => {
-    return useMutation({
-        ...options,
-        mutationFn: async ({ user }) => await sendEmailVerification(user),
-        mutationKey: SEND_EMAIL_VERIFICATION_MUTATION_KEY
-    });
-};

package/web/auth/useSignInWitEmailAndPasswordMutation.d.ts

@@ -1,15 +0,0 @@
-import { UseMutationOptions } from "@tanstack/react-query";
-import { UserCredential } from "firebase/auth";
-import { FirebaseError } from "firebase/app";
-export type UseSignInWitEmailAndPasswordMutationVariables = {
-    email: string;
-    password: string;
-};
-/**
- * Custom hook to perform a sign-in operation using email and password with Firebase Authentication.
- * It utilizes the `useMutation` hook to manage the asynchronous operation and its state.
- *
- * @param {Omit<UseMutationOptions<UserCredential, FirebaseError, UseSignInWitEmailAndPasswordMutationVariables, TContext>, 'mutationKey' | 'mutationFn'>} options - Options to configure the mutation, excluding 'mutationKey' and 'mutationFn'.
- * @returns {MutationResult} A mutation object containing the result of the sign-in process and helper functions.
- */
-export declare const useSignInWitEmailAndPasswordMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<UserCredential, FirebaseError, UseSignInWitEmailAndPasswordMutationVariables, TContext>, "mutationKey" | "mutationFn">) => import("@tanstack/react-query").UseMutationResult<UserCredential, FirebaseError, UseSignInWitEmailAndPasswordMutationVariables, TContext>;

package/web/auth/useSignInWitEmailAndPasswordMutation.js

@@ -1,19 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { signInWithEmailAndPassword } from "firebase/auth";
-import { useAuth } from "./useAuth";
-import { SIGN_IN_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY } from "./mutation-keys";
-/**
- * Custom hook to perform a sign-in operation using email and password with Firebase Authentication.
- * It utilizes the `useMutation` hook to manage the asynchronous operation and its state.
- *
- * @param {Omit<UseMutationOptions<UserCredential, FirebaseError, UseSignInWitEmailAndPasswordMutationVariables, TContext>, 'mutationKey' | 'mutationFn'>} options - Options to configure the mutation, excluding 'mutationKey' and 'mutationFn'.
- * @returns {MutationResult} A mutation object containing the result of the sign-in process and helper functions.
- */
-export const useSignInWitEmailAndPasswordMutation = (options = {}) => {
-    const firebaseAuth = useAuth();
-    return useMutation({
-        ...options,
-        mutationFn: async ({ email, password }) => signInWithEmailAndPassword(firebaseAuth, email, password),
-        mutationKey: SIGN_IN_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY
-    });
-};

package/web/auth/useSignInWitRedirectMutation.d.ts

@@ -1,14 +0,0 @@
-import { UseMutationOptions } from "@tanstack/react-query";
-import { AuthProvider, PopupRedirectResolver } from "firebase/auth";
-import { FirebaseError } from "firebase/app";
-export type UseSignInWitRedirectMutationVariables = {
-    authProvider: AuthProvider;
-    popupRedirectResolver?: PopupRedirectResolver;
-};
-/**
- * Custom hook for handling Firebase authentication using sign-in with redirect functionality.
- * This hook utilizes the `useMutation` mechanism to perform the sign-in operation.
- * @param {Omit<UseMutationOptions<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Optional configurations for the mutation, omitting the mutationKey and mutationFn properties.
- * @returns {UseMutationResult<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>} The result object from the useMutation hook, containing the mutation function and its current state.
- */
-export declare const useSignInWitRedirectMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>, "mutationKey" | "mutationFn">) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>;

package/web/auth/useSignInWitRedirectMutation.js

@@ -1,18 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { signInWithRedirect } from "firebase/auth";
-import { useAuth } from "./useAuth";
-import { SIGN_IN_WITH_REDIRECT_MUTATION_KEY } from "./mutation-keys";
-/**
- * Custom hook for handling Firebase authentication using sign-in with redirect functionality.
- * This hook utilizes the `useMutation` mechanism to perform the sign-in operation.
- * @param {Omit<UseMutationOptions<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Optional configurations for the mutation, omitting the mutationKey and mutationFn properties.
- * @returns {UseMutationResult<void, FirebaseError, UseSignInWitRedirectMutationVariables, TContext>} The result object from the useMutation hook, containing the mutation function and its current state.
- */
-export const useSignInWitRedirectMutation = (options = {}) => {
-    const firebaseAuth = useAuth();
-    return useMutation({
-        ...options,
-        mutationFn: async ({ authProvider, popupRedirectResolver }) => signInWithRedirect(firebaseAuth, authProvider, popupRedirectResolver),
-        mutationKey: SIGN_IN_WITH_REDIRECT_MUTATION_KEY
-    });
-};

package/web/auth/useSignOutMutation.d.ts

@@ -1,10 +0,0 @@
-import { UseMutationOptions } from "@tanstack/react-query";
-import { FirebaseError } from "firebase/app";
-/**
- * Custom hook for handling the sign-out mutation using Firebase authentication.
- * It wraps the useMutation hook to provide a sign-out function with Firebase.
- *
- * @param {Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "queryKey" | "queryFn">} options - Configuration options for the mutation, excluding "queryKey" and "queryFn".
- * @returns {UseMutationResult<void, FirebaseError, void, TContext>} A mutation object for handling the sign-out process, including methods for mutating and state tracking.
- */
-export declare const useSignOutMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "queryKey" | "queryFn">) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, void, TContext>;

package/web/auth/useSignOutMutation.js

@@ -1,19 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { signOut } from "firebase/auth";
-import { SIGN_OUT_MUTATION_KEY } from "./mutation-keys";
-import { useAuth } from "./useAuth";
-/**
- * Custom hook for handling the sign-out mutation using Firebase authentication.
- * It wraps the useMutation hook to provide a sign-out function with Firebase.
- *
- * @param {Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "queryKey" | "queryFn">} options - Configuration options for the mutation, excluding "queryKey" and "queryFn".
- * @returns {UseMutationResult<void, FirebaseError, void, TContext>} A mutation object for handling the sign-out process, including methods for mutating and state tracking.
- */
-export const useSignOutMutation = (options = {}) => {
-    const firebaseAuth = useAuth();
-    return useMutation({
-        ...options,
-        mutationFn: async () => await signOut(firebaseAuth),
-        mutationKey: SIGN_OUT_MUTATION_KEY
-    });
-};

package/web/auth/useUpdateProfileMutation.d.ts

@@ -1,15 +0,0 @@
-import { UseMutationOptions } from "@tanstack/react-query";
-import { User } from "firebase/auth";
-import { FirebaseError } from "firebase/app";
-export type UseUpdateProfileMutationVariables = {
-    displayName?: string;
-    user: User;
-};
-/**
- * Custom hook to manage the mutation for updating a user's profile.
- * Utilizes Firebase for updating the user's display name.
- *
- * @param {Omit<UseMutationOptions<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Configuration options for the mutation, excluding mutationKey and mutationFn.
- * @returns {UseMutationResult<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>} The result of the mutation operation including statuses, data, and error information.
- */
-export declare const useUpdateProfileMutation: <TContext = unknown>(options?: Omit<UseMutationOptions<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>, "mutationKey" | "mutationFn">) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>;

package/web/auth/useUpdateProfileMutation.js

@@ -1,17 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { updateProfile } from "firebase/auth";
-import { CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY } from "./mutation-keys";
-/**
- * Custom hook to manage the mutation for updating a user's profile.
- * Utilizes Firebase for updating the user's display name.
- *
- * @param {Omit<UseMutationOptions<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>, "mutationKey" | "mutationFn">} options - Configuration options for the mutation, excluding mutationKey and mutationFn.
- * @returns {UseMutationResult<void, FirebaseError, UseUpdateProfileMutationVariables, TContext>} The result of the mutation operation including statuses, data, and error information.
- */
-export const useUpdateProfileMutation = (options = {}) => {
-    return useMutation({
-        ...options,
-        mutationFn: async ({ displayName, user }) => await updateProfile(user, { displayName }),
-        mutationKey: CREATE_USER_WITH_EMAIL_AND_PASSWORD_MUTATION_KEY
-    });
-};

package/web/firestore/index.d.ts

@@ -1,16 +0,0 @@
-export * from "./useFirestore";
-export * from "./useAddDocMutation";
-export * from "./useBatchWrite";
-export * from "./useCollectionReference";
-export * from "./useCompositeFilter";
-export * from "./useCountQuery";
-export * from "./useDeleteDocMutation";
-export * from "./useDocReference";
-export * from "./useDocReferences";
-export * from "./useGetDocData";
-export * from "./useInfiniteQuery";
-export * from "./useQuery";
-export * from "./useRunTransaction";
-export * from "./useSetDocMutation";
-export * from "./useUpdateDocMutation";
-export * from "./useGetRealtimeDocData";

package/web/firestore/index.js

@@ -1,16 +0,0 @@
-export * from "./useFirestore";
-export * from "./useAddDocMutation";
-export * from "./useBatchWrite";
-export * from "./useCollectionReference";
-export * from "./useCompositeFilter";
-export * from "./useCountQuery";
-export * from "./useDeleteDocMutation";
-export * from "./useDocReference";
-export * from "./useDocReferences";
-export * from "./useGetDocData";
-export * from "./useInfiniteQuery";
-export * from "./useQuery";
-export * from "./useRunTransaction";
-export * from "./useSetDocMutation";
-export * from "./useUpdateDocMutation";
-export * from "./useGetRealtimeDocData";

package/web/firestore/useAddDocMutation.d.ts

@@ -1,23 +0,0 @@
-import { UseMutationOptions } from "@tanstack/react-query";
-import { DocumentData, WithFieldValue, CollectionReference, FirestoreDataConverter } from "firebase/firestore";
-import { FirebaseError } from "firebase/app";
-export type UseAddDocMutationValues<AppModelType> = {
-    data: WithFieldValue<AppModelType>;
-};
-export type UseAddDocMutationOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown> = {
-    reference: CollectionReference<AppModelType, DbModelType>;
-    converter?: FirestoreDataConverter<AppModelType, DbModelType>;
-    options?: Omit<UseMutationOptions<AppModelType, FirebaseError, UseAddDocMutationValues<AppModelType>, TContext>, "mutationFn" | "mutationKey">;
-};
-/**
- * Provides a mutation hook to add a document to a Firestore collection utilizing React Query's `useMutation`.
- * It handles addition and optional conversion of the document data in Firestore.
- *
- * @param {Object} options - Options for the mutation hook
- * @param {FirebaseFirestore.CollectionReference<AppModelType>} options.reference - Firestore collection reference where the document should be added.
- * @param {FirebaseFirestore.FirestoreDataConverter<DbModelType>} [options.converter] - Optional data converter for reading and writing Firestore documents.
- * @param {UseMutationOptions<AppModelType, Error, { data: DbModelType }, TContext>} [options.options={}] - Optional configuration for the mutation.
- *
- * @returns {UseMutationResult<AppModelType, Error, { data: DbModelType }, TContext>} The mutation hook result containing status, error, and data of the mutation process.
- */
-export declare const useAddDocMutation: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown>({ reference, converter, options }: UseAddDocMutationOptions<AppModelType, DbModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<AppModelType, FirebaseError, UseAddDocMutationValues<AppModelType>, TContext>;

package/web/firestore/useAddDocMutation.js

@@ -1,26 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { addDoc, getDoc } from "firebase/firestore";
-import { useMemo } from "react";
-/**
- * Provides a mutation hook to add a document to a Firestore collection utilizing React Query's `useMutation`.
- * It handles addition and optional conversion of the document data in Firestore.
- *
- * @param {Object} options - Options for the mutation hook
- * @param {FirebaseFirestore.CollectionReference<AppModelType>} options.reference - Firestore collection reference where the document should be added.
- * @param {FirebaseFirestore.FirestoreDataConverter<DbModelType>} [options.converter] - Optional data converter for reading and writing Firestore documents.
- * @param {UseMutationOptions<AppModelType, Error, { data: DbModelType }, TContext>} [options.options={}] - Optional configuration for the mutation.
- *
- * @returns {UseMutationResult<AppModelType, Error, { data: DbModelType }, TContext>} The mutation hook result containing status, error, and data of the mutation process.
- */
-export const useAddDocMutation = ({ reference, converter, options = {} }) => {
-    const mutationKey = useMemo(() => [reference.path], [reference.path]);
-    return useMutation({
-        ...options,
-        mutationFn: async ({ data }) => {
-            const docRef = await addDoc(reference, data);
-            const docSnap = await getDoc(converter ? docRef.withConverter(converter) : docRef);
-            return docSnap.data();
-        },
-        mutationKey
-    });
-};

package/web/firestore/useBatchWrite.d.ts

@@ -1,15 +0,0 @@
-import { UseMutationOptions } from "@tanstack/react-query";
-import { WriteBatch } from "firebase/firestore";
-import { FirebaseError } from "firebase/app";
-export type UseBatchWriteVariables = (batch: WriteBatch) => Promise<void> | void;
-export type UseBatchWriteOptions<TContext = unknown> = {
-    options?: Omit<UseMutationOptions<void, FirebaseError, UseBatchWriteVariables, TContext>, "mutationFn">;
-};
-/**
- * Custom hook to perform batch write operations using Firestore.
- * Utilizes a mutation to carry out the batch write transaction.
- * @template TContext - The type of context that can be passed into the hook, defaults to unknown.
- * @param {Object} options - The configuration options for the mutation operation.
- * @returns {Object} Returns an object composed of elements returned by useMutation, including properties such as status, and functions to trigger and control the mutation process.
- */
-export declare const useBatchWrite: <TContext = unknown>({ options }?: UseBatchWriteOptions<TContext>) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, UseBatchWriteVariables, TContext>;

package/web/firestore/useBatchWrite.js

@@ -1,21 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { writeBatch } from "firebase/firestore";
-import { useFirestore } from "./useFirestore";
-/**
- * Custom hook to perform batch write operations using Firestore.
- * Utilizes a mutation to carry out the batch write transaction.
- * @template TContext - The type of context that can be passed into the hook, defaults to unknown.
- * @param {Object} options - The configuration options for the mutation operation.
- * @returns {Object} Returns an object composed of elements returned by useMutation, including properties such as status, and functions to trigger and control the mutation process.
- */
-export const useBatchWrite = ({ options = {} } = {}) => {
-    const db = useFirestore();
-    return useMutation({
-        ...options,
-        mutationFn: async (batchWriteFn) => {
-            const batch = writeBatch(db);
-            await batchWriteFn(batch);
-            return batch.commit();
-        }
-    });
-};

package/web/firestore/useCollectionReference.d.ts

@@ -1,18 +0,0 @@
-import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
-export type UseCollectionReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
-    path: string;
-    pathSegments?: string[];
-};
-/**
- * Creates a reference to a Firestore collection based on the provided path, reference, and path segments.
- *
- * This hook utilizes useMemo for optimization, ensuring the collection reference is recalculated only when its dependencies change.
- *
- * @param {UseCollectionReferenceOptions<AppModelType, DbModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
- * @param {string} options.path - The base path for the collection.
- * @param {FirestoreReference} options.reference - An optional Firestore reference object that should be of type "collection".
- * @param {string[]} options.pathSegments - Additional path segments to append to the base path.
- * @returns {CollectionReference} A Firestore collection reference constructed using the specified path, reference, and path segments.
- */
-export declare const useCollectionReference: <AppModelType, DbModelType extends DocumentData = DocumentData>({ path, reference, pathSegments }: UseCollectionReferenceOptions<AppModelType, DbModelType>) => CollectionReference<DocumentData, DocumentData>;

package/web/firestore/useCollectionReference.js

@@ -1,24 +0,0 @@
-import { collection } from "firebase/firestore";
-import { useMemo } from "react";
-import { useFirestore } from "./useFirestore";
-/**
- * Creates a reference to a Firestore collection based on the provided path, reference, and path segments.
- *
- * This hook utilizes useMemo for optimization, ensuring the collection reference is recalculated only when its dependencies change.
- *
- * @param {UseCollectionReferenceOptions<AppModelType, DbModelType>} options - The options including path, reference, and pathSegments to construct the Firestore collection reference.
- * @param {string} options.path - The base path for the collection.
- * @param {FirestoreReference} options.reference - An optional Firestore reference object that should be of type "collection".
- * @param {string[]} options.pathSegments - Additional path segments to append to the base path.
- * @returns {CollectionReference} A Firestore collection reference constructed using the specified path, reference, and path segments.
- */
-export const useCollectionReference = ({ path, reference, pathSegments }) => {
-    const db = useFirestore();
-    return useMemo(() => {
-        return !reference
-            ? collection(db, path || "", ...(pathSegments || []))
-            : reference.type === "collection"
-                ? collection(reference, path, ...(pathSegments || []))
-                : collection(reference, path, ...(pathSegments || []));
-    }, [path, reference, pathSegments, db]);
-};

package/web/firestore/useCompositeFilter.d.ts

@@ -1,32 +0,0 @@
-import { DocumentData, WhereFilterOp } from "firebase/firestore";
-type CompositeFilterDocumentData = DocumentData;
-export type QueryElement<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = {
-    operator: "OR" | "AND";
-    children?: QueryElement[];
-    field?: keyof (DbModelType & {
-        documentId?: string[];
-    });
-    value?: DbModelType[keyof DbModelType];
-    op?: WhereFilterOp;
-};
-export type CompositeFilter<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = {
-    operator: "OR" | "AND";
-    children: QueryElement<DbModelType & {
-        documentId?: string[];
-    }>[];
-};
-export type UseCompositeFilter<DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData> = {
-    query?: CompositeFilter<DbModelType>;
-};
-/**
- * A custom hook that generates a composite filter for database queries, using the provided query configuration.
- * It applies either an 'OR' or 'AND' logical operation based on the type specified in the query.
- *
- * @param {Object} query - The query configuration object that contains subqueries and a type for logical combination.
- * @param {string} query.type - The type of composite operation ('or'/'and').
- * @param {Array} query.children - An array of subqueries that will be processed to form the composite filter.
- *
- * @returns {(Function|undefined)} A composite query filter constraint function formed by combining subqueries or undefined if there are no valid constraints.
- */
-export declare const useCompositeFilter: <DbModelType extends CompositeFilterDocumentData = CompositeFilterDocumentData>({ query }: UseCompositeFilter<DbModelType>) => import("@firebase/firestore").QueryCompositeFilterConstraint | undefined;
-export {};

package/web/firestore/useCompositeFilter.js

@@ -1,41 +0,0 @@
-import { documentId, and, or, where } from "firebase/firestore";
-import { useMemo } from "react";
-/**
- * Constructs a composite query filter based on the provided query structure.
- * It recursively builds query constraints using logical "or" or "and" operators.
- *
- * @param {QueryElement<DbModelType>} query - The query element or structure to be evaluated and transformed into filter constraints.
- * @returns {QueryFieldFilterConstraint | null} A constructed query filter constraint based on the input query, or null if no valid constraints can be derived.
- */
-const buildCompositeQuery = (query) => {
-    if (query.children) {
-        const queryConstraints = query.children.map(buildCompositeQuery).filter((constraint) => !!constraint);
-        if (queryConstraints.length <= 0) {
-            return null;
-        }
-        return query.operator === "OR" ? or(...queryConstraints) : and(...queryConstraints);
-    }
-    if (query.field && query.op) {
-        return where(query.field === "documentId" ? documentId() : query.field, query.op, query.value);
-    }
-    return null;
-};
-/**
- * A custom hook that generates a composite filter for database queries, using the provided query configuration.
- * It applies either an 'OR' or 'AND' logical operation based on the type specified in the query.
- *
- * @param {Object} query - The query configuration object that contains subqueries and a type for logical combination.
- * @param {string} query.type - The type of composite operation ('or'/'and').
- * @param {Array} query.children - An array of subqueries that will be processed to form the composite filter.
- *
- * @returns {(Function|undefined)} A composite query filter constraint function formed by combining subqueries or undefined if there are no valid constraints.
- */
-export const useCompositeFilter = ({ query }) => {
-    return useMemo(() => {
-        const queryConstraints = (query?.children?.map?.((subQuery) => buildCompositeQuery(subQuery))?.filter)?.((constraint) => !!constraint) ?? [];
-        if (queryConstraints.length <= 0) {
-            return undefined;
-        }
-        return query?.operator === "OR" ? or(...queryConstraints) : and(...queryConstraints);
-    }, [query]);
-};

package/web/firestore/useCountQuery.d.ts

@@ -1,23 +0,0 @@
-import { DocumentData, CollectionReference, QueryCompositeFilterConstraint, QueryConstraint, QueryNonFilterConstraint } from "firebase/firestore";
-import { UseQueryResult, UseQueryOptions as UseReactQueryOptions } from "@tanstack/react-query";
-type UseCountQueryOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData> = {
-    options: Omit<UseReactQueryOptions<number, Error, number>, "queryFn"> & Required<Pick<UseReactQueryOptions<number, Error, number>, "queryKey">>;
-    collectionReference: CollectionReference<AppModelType, DbModelType>;
-    queryConstraints?: QueryConstraint[] | QueryNonFilterConstraint[];
-    compositeFilter?: QueryCompositeFilterConstraint;
-};
-/**
- * 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.
- *
- * @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.
- */
-export declare const useCountQuery: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData>({ options, collectionReference, queryConstraints, compositeFilter }: UseCountQueryOptions<AppModelType, DbModelType>) => UseQueryResult<number>;
-export {};

package/web/firestore/useCountQuery.js

@@ -1,30 +0,0 @@
-import { getCountFromServer, query } from "firebase/firestore";
-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.
- *
- * @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.
- */
-export const useCountQuery = ({ options, collectionReference, queryConstraints = [], compositeFilter }) => {
-    return useReactQuery({
-        ...options,
-        queryFn: async () => {
-            const queryToExecute = compositeFilter
-                ? query(collectionReference, compositeFilter, ...queryConstraints)
-                : query(collectionReference, ...queryConstraints);
-            const querySnapshot = await getCountFromServer(queryToExecute);
-            if (querySnapshot) {
-                return querySnapshot.data().count;
-            }
-            return 0;
-        }
-    });
-};

package/web/firestore/useDeleteDocMutation.d.ts

@@ -1,18 +0,0 @@
-import { UseMutationOptions } from "@tanstack/react-query";
-import { DocumentData, WithFieldValue, DocumentReference } from "firebase/firestore";
-import { FirebaseError } from "firebase/app";
-export type UseDeleteDocMutationValues<AppModelType> = {
-    data: WithFieldValue<AppModelType>;
-};
-export type UseDeleteDocMutationOptions<AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown> = {
-    reference: DocumentReference<AppModelType, DbModelType> | null;
-    options?: Omit<UseMutationOptions<void, FirebaseError, void, TContext>, "mutationFn" | "mutationKey">;
-};
-/**
- * A custom hook that provides a mutation function to delete a document from the database.
- * @param {UseDeleteDocMutationOptions<AppModelType, DbModelType, TContext>} options - An object containing the reference to the document and additional options for the mutation.
- * @param {FirestoreReference<AppModelType, DbModelType>} options.reference - The reference to the document that needs to be deleted.
- * @param {object} options.options - Additional options for the mutation, if any (default is an empty object).
- * @returns {UseMutationResult} An object returned by the `useMutation` hook which includes properties and methods to control the mutation's execution and track its state.
- */
-export declare const useDeleteDocMutation: <AppModelType extends DocumentData = DocumentData, DbModelType extends DocumentData = DocumentData, TContext = unknown>({ reference, options }: UseDeleteDocMutationOptions<AppModelType, DbModelType, TContext>) => import("@tanstack/react-query").UseMutationResult<void, FirebaseError, void, TContext>;

package/web/firestore/useDeleteDocMutation.js

@@ -1,23 +0,0 @@
-import { useMutation } from "@tanstack/react-query";
-import { deleteDoc } from "firebase/firestore";
-import { useMemo } from "react";
-/**
- * A custom hook that provides a mutation function to delete a document from the database.
- * @param {UseDeleteDocMutationOptions<AppModelType, DbModelType, TContext>} options - An object containing the reference to the document and additional options for the mutation.
- * @param {FirestoreReference<AppModelType, DbModelType>} options.reference - The reference to the document that needs to be deleted.
- * @param {object} options.options - Additional options for the mutation, if any (default is an empty object).
- * @returns {UseMutationResult} An object returned by the `useMutation` hook which includes properties and methods to control the mutation's execution and track its state.
- */
-export const useDeleteDocMutation = ({ reference, options = {} }) => {
-    const mutationKey = useMemo(() => [reference?.path], [reference?.path]);
-    return useMutation({
-        ...options,
-        mutationFn: async () => {
-            if (!reference) {
-                throw new Error("Reference is undefined");
-            }
-            await deleteDoc(reference);
-        },
-        mutationKey
-    });
-};

package/web/firestore/useDocReference.d.ts

@@ -1,19 +0,0 @@
-import { CollectionReference, DocumentData, DocumentReference } from "firebase/firestore";
-export type UseDocReferenceOptions<AppModelType, DbModelType extends DocumentData = DocumentData> = {
-    reference?: CollectionReference<AppModelType, DbModelType> | DocumentReference<AppModelType, DbModelType>;
-    path?: string;
-    pathSegments?: string[];
-};
-/**
- * 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 declare const useDocReference: <AppModelType, DbModelType extends DocumentData = DocumentData>({ path, reference, pathSegments }: UseDocReferenceOptions<AppModelType, DbModelType>) => DocumentReference<AppModelType, DbModelType> | null;

package/web/firestore/useDocReference.js

@@ -1,45 +0,0 @@
-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, db]);
-    return ref.current;
-};

package/web/firestore/useDocReferences.d.ts

@@ -1,23 +0,0 @@
-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>[];