Firestore persistance, when firebase emulator is empty and auth is empty

[kaleb-dev]

Anyone familiar with react native firebase? If so im having this weird issue with firestore data being persisted after database has been cleared. In the pastebin below we can see that we do disable persisting and the database is cleared no users or collection of users but the docSnap still returns data https://pastebin.com/Yuv22uJ9

[kaleb-dev]

I cant seem to solve this issue, haven't tested in production but its some weird behaviour, for context that context provider deliberates auth state of the user posing the big issue for me so when returning information about a user existing in the cache while certain data is missing when it routes the user to the home page, it gives many undefined errors

[mikehardy]

Can you just post code? Like code that is in triple-backticks with a javascript language specifier

  // comment
  console.log("like this");

so it's readable? the pastebin link is 404 images aren't executable

In general though this sounds like you might want to tag up a stackoverflow question with appropriate firebase tags as it's likely a usage issue and the firebase team provides support there

[kaleb-dev]

copy and paste the pastebin in the browser should work like that

[kaleb-dev]

github redirects the url through itself which is weird but the pastebin does work

[kaleb-dev]

Here is the code just to be safe

import {
	createContext,
	useState,
	useContext,
	useEffect,
	FC,
	PropsWithChildren,
	useCallback
} from "react";
import { authFirebase } from "@/firebaseConfig";
import { FirestoreProfile, FirestoreUser } from "../types";
import auth from "@react-native-firebase/auth";
import firestore from "@react-native-firebase/firestore";

interface UserDataContextProps {
	isLoading: boolean;
	profileData: FirestoreProfile | null;
	userData: FirestoreUser | null;
	getUserData: (uid: string) => Promise<void>;
	refreshUserData: () => Promise<void>;
	getUserProfile: (uid: string) => Promise<void>;
}

const UserDataContext = createContext<UserDataContextProps | undefined>(
	undefined
);

export const UserDataProvider: FC<PropsWithChildren> = ({ children }) => {
	const [isLoading, setIsLoading] = useState<boolean>(true);
	const [profileData, setProfileData] = useState<FirestoreProfile | null>(null);
	const [userData, setUserData] = useState<FirestoreUser | null>(null);
	const { currentUser } = authFirebase();

	async function bootstrap() {
		console.log("Disabling offline persistence");
		await firestore().settings({
			persistence: false // disable offline persistence
		});
	}

	bootstrap();

	useEffect(() => {
		const newAuth = auth();
		const unsubscribe = newAuth.onAuthStateChanged((user) => {
			if (user?.uid === undefined) {
				setIsLoading(false);
			}
		});
		return () => {
			unsubscribe();
		};
	}, []);

	const getUserData = useCallback(
		async (uid: string) => {
			const docSnap = await firestore().collection("users").doc(uid).get();
			console.log("docSnap", docSnap);
			if (docSnap.exists) {
				const userData = docSnap.data();
				if (userData) {
					setUserData(userData as FirestoreUser);
				} else {
					console.error("Invalid user data:", userData);
				}
			}

			setUserData(null);
			if (isLoading) {
				setIsLoading(false);
			}
		},
		[isLoading]
	);

	const refreshUserData = async () => {
		if (currentUser != null) {
			await getUserData(currentUser.uid);
		}
	};

	const getUserProfile = useCallback(async (uid: string) => {
		const docSnap = await firestore().collection("profiles").doc(uid).get();
		if (docSnap.exists) {
			const profileData: any = docSnap.data();
			setProfileData(profileData as FirestoreProfile);
		}
	}, []);

	useEffect(() => {
		let unSubUser: (() => void) | undefined;
		let unSubProfile: (() => void) | undefined;

		if (currentUser) {
			unSubUser = firestore()
				.collection("users")
				.doc(currentUser.uid)
				.onSnapshot(
					(doc) => {
						if (doc.exists) {
							const data = doc.data();
							if (data) {
								setUserData(data as FirestoreUser);
							}
						} else {
							console.log("No user document exists");
							setUserData(null);
						}
					},
					(error) => {
						console.error("Error in user listener:", error);
					}
				);

			unSubProfile = firestore()
				.collection("profiles")
				.doc(currentUser.uid)
				.onSnapshot(
					(doc) => {
						if (doc.exists) {
							const data = doc.data();
							if (data) {
								setProfileData(data as FirestoreProfile);
							}
						} else {
							console.log("No profile document exists");
							setProfileData(null);
						}
					},
					(error) => {
						console.error("Error in profile listener:", error);
					}
				);
		} else {
			setUserData(null);
			setProfileData(null);
		}

		return () => {
			if (unSubUser) unSubUser();
			if (unSubProfile) unSubProfile();
		};
	}, [currentUser]);

	useEffect(() => {
		if (currentUser) {
			getUserData(currentUser.uid);
			getUserProfile(currentUser.uid);
		}
	}, [currentUser, getUserData, getUserProfile]);

	return (
		<UserDataContext.Provider
			value={{
				isLoading,
				profileData,
				userData,
				getUserData,
				refreshUserData,
				getUserProfile
			}}
		>
			{children}
		</UserDataContext.Provider>
	);
};

export const useUserData = (): UserDataContextProps => {
	const context = useContext(UserDataContext);
	if (!context) {
		throw new Error("useUserData must be used within a UserDataProvider");
	}
	return context;
};

[mikehardy]

I don't have a lot of time to get into project specific stuff but it looks like on a quick glance that boostrap is async but you don't await it?
Unsure what else is going on but I don't see offline status being changed, just local persistence
setting persistence false just means "keep a local cache in sync with server" (where server is firebase emulator or cloud firestore, so that you can see data while device is offline
So if you set that to false you are not saying "don't store anything" you are saying "if I'm offline I can't see anything"

https://rnfirebase.io/firestore/usage#offline-capabilities

if you are still online, the data will be there. Additionally this is a little undefined but I'm not sure what happens if you already have data in a local cache and you set persistence to false - that is what happens to existing data that may already be stored in local cache? For that you may need to set this to zero https://rnfirebase.io/reference/firestore/settings#cacheSizeBytes