Merge branch 'next' into ft-add-useWriteBatchCommitMutation

packages/react/src/firestore/index.ts

@@ -1,9 +1,9 @@
 export { useClearIndexedDbPersistenceMutation } from "./useClearIndexedDbPersistenceMutation";
 // useEnableIndexedDbPersistenceMutation
-// useDisableNetworkMutation
+export { useDisableNetworkMutation } from "./useDisableNetworkMutation";
 // useEnableNetworkMutation
+export { useWaitForPendingWritesQuery } from "./useWaitForPendingWritesQuery";
 export { useRunTransactionMutation } from "./useRunTransactionMutation";
-// useWaitForPendingWritesQuery
 export { useWriteBatchCommitMutation } from "./useWriteBatchCommitMutation";
 export { useDocumentQuery } from "./useDocumentQuery";
 export { useCollectionQuery } from "./useCollectionQuery";

packages/react/src/firestore/useDisableNetworkMutation.test.tsx

@@ -0,0 +1,56 @@
+import React from "react";
+import { describe, expect, test, beforeEach, vi } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import {
+  expectFirestoreError,
+  firestore,
+  wipeFirestore,
+} from "~/testing-utils";
+import { useDisableNetworkMutation } from "./useDisableNetworkMutation";
+import {
+  doc,
+  enableNetwork,
+  getDocFromServer,
+} from "firebase/firestore";
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: { retry: false },
+    mutations: { retry: false },
+  },
+});
+
+const wrapper = ({ children }: { children: React.ReactNode }) => (
+  <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+);
+
+describe("useDisableNetworkMutation", () => {
+  beforeEach(async () => {
+    queryClient.clear();
+    await enableNetwork(firestore);
+    await wipeFirestore();
+  });
+
+  test("should successfully disable the Firestore network", async () => {
+    const { result } = renderHook(() => useDisableNetworkMutation(firestore), {
+      wrapper,
+    });
+
+    await act(() => result.current.mutate());
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    // Verify that network operations fail
+    const docRef = doc(firestore, "tests", "someDoc");
+
+    try {
+      await getDocFromServer(docRef);
+      throw new Error(
+        "Expected the network to be disabled, but Firestore operation succeeded."
+      );
+    } catch (error) {
+      expectFirestoreError(error, "unavailable");
+    }
+  });
+});

packages/react/src/firestore/useDisableNetworkMutation.ts

@@ -0,0 +1,21 @@
+import { useMutation, type UseMutationOptions } from "@tanstack/react-query";
+import {
+  disableNetwork,
+  type FirestoreError,
+  type Firestore,
+} from "firebase/firestore";
+
+type FirestoreUseMutationOptions<TData = unknown, TError = Error> = Omit<
+  UseMutationOptions<TData, TError, void>,
+  "mutationFn"
+>;
+
+export function useDisableNetworkMutation(
+  firestore: Firestore,
+  options?: FirestoreUseMutationOptions<void, FirestoreError>
+) {
+  return useMutation<void, FirestoreError>({
+    ...options,
+    mutationFn: () => disableNetwork(firestore),
+  });
+}

packages/react/src/firestore/useWaitForPendingWritesQuery.test.tsx

@@ -0,0 +1,46 @@
+import React from "react";
+import { describe, expect, test, beforeEach, vi } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import {
+  expectFirestoreError,
+  firestore,
+  wipeFirestore,
+} from "~/testing-utils";
+import { useWaitForPendingWritesQuery } from "./useWaitForPendingWritesQuery";
+import { doc, setDoc } from "firebase/firestore";
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: { retry: false },
+    mutations: { retry: false },
+  },
+});
+
+const wrapper = ({ children }: { children: React.ReactNode }) => (
+  <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+);
+
+describe("useWaitForPendingWritesQuery", () => {
+  beforeEach(async () => {
+    queryClient.clear();
+    await wipeFirestore();
+  });
+
+  test("enters loading state when pending writes are in progress", async () => {
+    const docRef = doc(firestore, "tests", "loadingStateDoc");
+
+    const { result } = renderHook(
+      () =>
+        useWaitForPendingWritesQuery(firestore, {
+          queryKey: ["pending", "write", "loading"],
+        }),
+      { wrapper }
+    );
+
+    // Initiate a write without an await
+    setDoc(docRef, { value: "loading-test" });
+
+    expect(result.current.isPending).toBe(true);
+  });
+});

packages/react/src/firestore/useWaitForPendingWritesQuery.ts

@@ -0,0 +1,21 @@
+import { useQuery, type UseQueryOptions } from "@tanstack/react-query";
+import {
+  type Firestore,
+  type FirestoreError,
+  waitForPendingWrites,
+} from "firebase/firestore";
+
+type FirestoreUseQueryOptions<TData = unknown, TError = Error> = Omit<
+  UseQueryOptions<TData, TError, void>,
+  "queryFn"
+>;
+
+export function useWaitForPendingWritesQuery(
+  firestore: Firestore,
+  options: FirestoreUseQueryOptions<void, FirestoreError>
+) {
+  return useQuery<void, FirestoreError, void>({
+    ...options,
+    queryFn: () => waitForPendingWrites(firestore),
+  });
+}