Small fixes, calendar token refresh for google

hooks/firebase/useClearTokens.ts

@@ -0,0 +1,39 @@
+import {useMutation} from "react-query";
+import {UserProfile} from "@firebase/auth";
+import {useAuthContext} from "@/contexts/AuthContext";
+import {useUpdateUserData} from "@/hooks/firebase/useUpdateUserData";
+
+export const useClearTokens = () => {
+    const {profileData} = useAuthContext();
+    const {mutateAsync: updateUserData} = useUpdateUserData();
+
+    return useMutation({
+        mutationKey: ["clearTokens"],
+        mutationFn: async ({provider, email}: {
+            provider: "google" | "outlook" | "apple",
+            email: string
+        }) => {
+            const newUserData: Partial<UserProfile> = {};
+            if (provider === "google") {
+                let googleAccounts = profileData?.googleAccounts;
+                if (googleAccounts) {
+                    googleAccounts[email] = null;
+                    newUserData.googleAccounts = googleAccounts;
+                }
+            } else if (provider === "outlook") {
+                let microsoftAccounts = profileData?.microsoftAccounts;
+                if (microsoftAccounts) {
+                    microsoftAccounts[email] = null;
+                    newUserData.microsoftAccounts = microsoftAccounts;
+                }
+            } else if (provider === "apple") {
+                let appleAccounts = profileData?.appleAccounts;
+                if (appleAccounts) {
+                    appleAccounts[email] = null;
+                    newUserData.appleAccounts = appleAccounts;
+                }
+            }
+            await updateUserData({newUserData});
+        },
+    })
+}

hooks/firebase/useCreateEvent.ts

@@ -45,34 +45,41 @@ export const useCreateEvent = () => {
 }
 
 export const useCreateEventsFromProvider = () => {
-    const {user: currentUser} = useAuthContext();
+    const { user: currentUser } = useAuthContext();
     const queryClient = useQueryClient();
 
     return useMutation({
         mutationKey: ["createEventsFromProvider"],
         mutationFn: async (eventDataArray: Partial<EventData>[]) => {
             try {
-                for (const eventData of eventDataArray) {
+                // Create an array of promises for each event's Firestore read/write operation
+                const promises = eventDataArray.map(async (eventData) => {
                     console.log("Processing EventData: ", eventData);
 
+                    // Check if the event already exists
                     const snapshot = await firestore()
                         .collection("Events")
                         .where("id", "==", eventData.id)
                         .get();
 
                     if (snapshot.empty) {
-                        await firestore()
+                        // Event doesn't exist, so add it
+                        return firestore()
                             .collection("Events")
-                            .add({...eventData, creatorId: currentUser?.uid});
+                            .add({ ...eventData, creatorId: currentUser?.uid });
                     } else {
-                        console.log("Event already exists, updating...");
+                        // Event exists, update it
                         const docId = snapshot.docs[0].id;
-                        await firestore()
+                        return firestore()
                             .collection("Events")
                             .doc(docId)
-                            .set({...eventData, creatorId: currentUser?.uid}, {merge: true});
+                            .set({ ...eventData, creatorId: currentUser?.uid }, { merge: true });
                     }
-                }
+                });
+
+                // Execute all promises in parallel
+                await Promise.all(promises);
+
             } catch (e) {
                 console.error("Error creating/updating events: ", e);
             }

hooks/useFetchAndSaveGoogleEvents.ts

@@ -2,11 +2,13 @@ import {useMutation, useQueryClient} from "react-query";
 import {fetchGoogleCalendarEvents} from "@/calendar-integration/google-calendar-utils";
 import {useAuthContext} from "@/contexts/AuthContext";
 import {useCreateEventsFromProvider} from "@/hooks/firebase/useCreateEvent";
+import {useClearTokens} from "@/hooks/firebase/useClearTokens";
 
 export const useFetchAndSaveGoogleEvents = () => {
     const queryClient = useQueryClient()
     const {profileData} = useAuthContext();
     const {mutateAsync: createEventsFromProvider} = useCreateEventsFromProvider();
+    const {mutateAsync: clearToken} = useClearTokens();
 
     return useMutation({
         mutationKey: ["fetchAndSaveGoogleEvents"],
@@ -26,9 +28,14 @@ export const useFetchAndSaveGoogleEvents = () => {
                     timeMax.toISOString().slice(0, -5) + "Z"
                 );
 
+                if(!response.success) {
+                    await clearToken({email: email!, provider: "google"})
+                    return
+                }
+
                 console.log("Google Calendar events fetched:", response);
 
-                const items = response?.map((item) => {
+                const items = response?.googleEvents?.map((item) => {
                     if (item.allDay) {
                         item.startDate = new Date(new Date(item.startDate).setHours(0, 0, 0, 0));
                         item.endDate = item.startDate;