🐛 fix(sign-up-import-gcal): prevent sync data from being initialized multiple times

Author: victor-enogwe

packages/backend/src/sync/controllers/sync.controller.ts

@@ -2,6 +2,7 @@ import { Request, Response } from "express";
 import { Status } from "@core/errors/status.codes";
 import { Logger } from "@core/logger/winston.logger";
 import { Payload_Sync_Notif } from "@core/types/sync.types";
+import { shouldImportGCal } from "@core/util/event/event.util";
 import { getGcalClient } from "@backend/auth/services/google.auth.service";
 import { SyncError } from "@backend/common/errors/sync/sync.errors";
 import { UserError } from "@backend/common/errors/user/user.errors";
@@ -96,17 +97,24 @@ class SyncController {
   importGCal = async (req: Request, res: Response): Promise<Response> => {
     const userId = req.session!.getUserId()!;
     const gcalClient = await getGcalClient(userId);
-    const gCalendarIds = await initSync(gcalClient, userId);
-    const lastGCalSync = new Date().toUTCString();
+    const sync = await getSync({ userId });
+
+    let gCalendarIds: string[] =
+      sync?.google.calendarlist.map((item) => item.gCalendarId) ?? [];
+
+    if (!sync) gCalendarIds = await initSync(gcalClient, userId);
+
+    logger.debug(
+      `starting gCal(${gCalendarIds.toString()}) imports for user(${userId})`,
+    );
 
     webSocketServer.handleImportGCalStart(userId);
 
     userService
       .fetchUserMetadata(userId)
-      .then(async (metadata) => {
-        const sync = metadata.sync ?? {};
-
-        if (sync?.importGCal?.importing) {
+      .then(shouldImportGCal)
+      .then(async (proceed) => {
+        if (!proceed) {
           webSocketServer.handleImportGCalEnd(
             userId,
             `User ${userId} is already importing GCal, ignoring this request`,
@@ -117,22 +125,27 @@ class SyncController {
 
         await userService.updateUserMetadata({
           userId,
-          data: { sync: { importGCal: { importing: true, lastGCalSync } } },
+          data: { sync: { importGCal: "importing" } },
         });
 
         await syncService.importFull(gcalClient, gCalendarIds, userId);
 
         await userService.updateUserMetadata({
           userId,
-          data: { sync: { importGCal: { importing: false } } },
+          data: { sync: { importGCal: "completed" } },
         });
 
         webSocketServer.handleImportGCalEnd(userId);
         webSocketServer.handleBackgroundCalendarChange(userId);
       })
-      .catch((err) => {
+      .catch(async (err) => {
         const message = `Import gCal failed for user: ${userId}`;
 
+        await userService.updateUserMetadata({
+          userId,
+          data: { sync: { importGCal: "errored" } },
+        });
+
         webSocketServer.handleImportGCalEnd(userId, message);
 
         logger.error(message, err);

packages/core/src/types/user.types.ts

@@ -16,10 +16,5 @@ export interface Schema_User {
 }
 
 export interface UserMetadata extends SupertokensUserMetadata.JSONObject {
-  sync?: {
-    importGCal?: {
-      importing?: boolean; // gCal import in progress
-      lastGCalSync?: string; // utc Date string
-    };
-  };
+  sync?: { importGCal?: "importing" | "errored" | "completed" | "restart" };
 }

packages/core/src/util/event/event.util.ts

@@ -4,6 +4,7 @@ import {
   Schema_Event_Recur_Base,
   Schema_Event_Recur_Instance,
 } from "@core/types/event.types";
+import { UserMetadata } from "@core/types/user.types";
 
 /** Event utilities for Compass events */
 
@@ -83,3 +84,17 @@ export const filterBaseEvents = (e: Schema_Event[]) => {
  */
 export const filterExistingInstances = (e: Schema_Event[]) =>
   e.filter(isExistingInstance);
+
+export const shouldImportGCal = (metadata: UserMetadata): boolean => {
+  const sync = metadata.sync;
+
+  switch (sync?.importGCal) {
+    case "importing":
+    case "completed":
+      return false;
+    case "restart":
+    case "errored":
+    default:
+      return true;
+  }
+};

packages/web/src/socket/SocketProvider.tsx

@@ -11,6 +11,7 @@ import {
   USER_SIGN_OUT,
 } from "@core/constants/websocket.constants";
 import { UserMetadata } from "@core/types/user.types";
+import { shouldImportGCal } from "@core/util/event/event.util";
 import { ENV_WEB } from "@web/common/constants/env.constants";
 import { Sync_AsyncStateContextReason } from "@web/ducks/events/context/sync.context";
 import {
@@ -98,12 +99,12 @@ const SocketProvider = ({ children }: { children: ReactNode }) => {
   }, [dispatch]);
 
   const onMetadataFetch = useCallback(
-    (data: UserMetadata) => {
-      const { importing, lastGCalSync } = data.sync?.importGCal ?? {};
+    (metadata: UserMetadata) => {
+      const importGcal = shouldImportGCal(metadata);
 
-      onImportStart(importing);
+      onImportStart(metadata.sync?.importGCal === "importing");
 
-      if (!importing && !lastGCalSync) {
+      if (importGcal) {
         dispatch(importGCalSlice.actions.request(undefined));
       }
     },