fix: appease the ci godas

src/seqta/utils/googleCalendar/calendarSyncListener.ts

@@ -4,13 +4,11 @@ import {
   shouldRunWeeklySync,
 } from "@/seqta/utils/calendarSync/settings";
 import {
-  formatSyncResultMessage,
-  runGoogleCalendarSync,
-} from "@/seqta/utils/googleCalendar/syncRunner";
-import {
-  formatOutlookSyncResultMessage,
-  runOutlookCalendarSync,
-} from "@/seqta/utils/outlookCalendar/syncRunner";
+  formatWeeklySyncMessages,
+  weeklySyncErrorMessage,
+} from "@/seqta/utils/calendarSync/weeklySyncMessages";
+import { runGoogleCalendarSync } from "@/seqta/utils/googleCalendar/syncRunner";
+import { runOutlookCalendarSync } from "@/seqta/utils/outlookCalendar/syncRunner";
 import { readGoogleCalendarState } from "@/seqta/utils/googleCalendar/storage";
 import { readOutlookCalendarState } from "@/seqta/utils/outlookCalendar/storage";
 import type { GoogleCalendarSyncResult } from "@/seqta/utils/googleCalendar/types";
@@ -70,27 +68,13 @@ export async function maybeRunDueWeeklySync(
   const results = await runWeeklySyncForConnectedProviders();
   if (!onComplete) return;
 
-  const errors = results.filter((r) => !r.success);
-  if (errors.length > 0) {
-    onComplete(errors[0]?.error ?? "Weekly calendar sync failed.", true);
+  const errorMessage = weeklySyncErrorMessage(results);
+  if (errorMessage) {
+    onComplete(errorMessage, true);
     return;
   }
 
-  const messages: string[] = [];
-  let index = 0;
-  if (google.refreshToken || google.accessToken) {
-    const result = results[index++];
-    const changed =
-      (result.created ?? 0) + (result.updated ?? 0) + (result.deleted ?? 0) > 0;
-    if (changed) messages.push(formatSyncResultMessage(result));
-  }
-  if (outlook.refreshToken || outlook.accessToken) {
-    const result = results[index++];
-    const changed =
-      (result.created ?? 0) + (result.updated ?? 0) + (result.deleted ?? 0) > 0;
-    if (changed) messages.push(formatOutlookSyncResultMessage(result));
-  }
-
+  const messages = formatWeeklySyncMessages(google, outlook, results);
   if (messages.length > 0) {
     onComplete(messages.join(" "));
   }

src/seqta/utils/googleCalendar/syncEngine.ts

@@ -1,16 +1,19 @@
 import { verboseLog } from "@/utils/verboseLog";
 import { isGoogleCalendarConfigured } from "@/config/googleCalendar";
 import { googleApiEventBody, mapLessonsToGoogleEvents } from "@/seqta/utils/googleCalendar/eventMapper";
-import {
-  getStoredEventId,
-  lessonDateFromSeqtaKey,
-  normalizeEventMapEntry,
-} from "@/seqta/utils/googleCalendar/eventMapEntry";
-import {
-  isDateInRange,
-  syncWindowRange,
-} from "@/seqta/utils/googleCalendar/syncDateRange";
 import { getSyncWeeksAhead } from "@/seqta/utils/calendarSync/settings";
+import {
+  buildLessonSyncResult,
+  emptyLessonsSyncResult,
+  entriesToPrune,
+  EVENT_MAP_PERSIST_EVERY,
+  notConfiguredSyncResult,
+  notConnectedSyncResult,
+  originEventMapEntries,
+  persistFinalSyncState,
+  reportSyncProgress,
+  upsertLessonEvents,
+} from "@/seqta/utils/calendarSync/lessonSyncShared";
 import {
   eventMapKey,
   readGoogleCalendarState,
@@ -19,7 +22,6 @@ import {
 import type {
   GoogleCalendarDeleteResult,
   GoogleCalendarSyncOptions,
-  GoogleCalendarSyncProgress,
   GoogleCalendarSyncRequest,
   GoogleCalendarSyncResult,
 } from "@/seqta/utils/googleCalendar/types";
@@ -28,7 +30,6 @@ import {
   upsertGoogleCalendarEvent,
 } from "@/seqta/utils/googleCalendar/upsertEvent";
 
-const EVENT_MAP_PERSIST_EVERY = 10;
 const CALENDAR_ID = "primary";
 
 type DeleteTrackedEventsResult = {
@@ -36,17 +37,6 @@ type DeleteTrackedEventsResult = {
   failed: number;
 };
 
-function reportProgress(
-  onProgress: GoogleCalendarSyncOptions["onProgress"],
-  progress: GoogleCalendarSyncProgress,
-) {
-  onProgress?.(progress);
-}
-
-function lessonDateForEvent(startDateTime: string, seqtaKey: string): string {
-  return startDateTime.slice(0, 10) || lessonDateFromSeqtaKey(seqtaKey) || "";
-}
-
 async function deleteTrackedEventsFromGoogle(
   entries: Array<[string, string]>,
   eventMap: Record<string, string | { id: string; date: string }>,
@@ -72,7 +62,7 @@ async function deleteTrackedEventsFromGoogle(
       delete eventMap[mapKey];
       deleted += 1;
 
-      reportProgress(onProgress, {
+      reportSyncProgress(onProgress, {
         phase: "deleting",
         current: progressOffset + deleted + failed,
         total: progressTotal,
@@ -85,7 +75,7 @@ async function deleteTrackedEventsFromGoogle(
     } catch (err) {
       verboseLog("[BetterSEQTA+] Google Calendar event delete failed:", err);
       failed += 1;
-      reportProgress(onProgress, {
+      reportSyncProgress(onProgress, {
         phase: "deleting",
         current: progressOffset + deleted + failed,
         total: progressTotal,
@@ -97,51 +87,6 @@ async function deleteTrackedEventsFromGoogle(
   return { deleted, failed };
 }
 
-function originEventMapEntries(
-  eventMap: Record<string, string | { id: string; date: string }>,
-  origin: string,
-): Array<[string, string]> {
-  const prefix = `${origin}::`;
-  const entries: Array<[string, string]> = [];
-  for (const [key, value] of Object.entries(eventMap)) {
-    if (!key.startsWith(prefix)) continue;
-    const id = getStoredEventId(value);
-    if (id) entries.push([key, id]);
-  }
-  return entries;
-}
-
-function entriesToPrune(
-  eventMap: Record<string, string | { id: string; date: string }>,
-  origin: string,
-  mode: "full" | "incremental",
-  weeksAhead: number,
-  currentMapKeys: Set<string>,
-): Array<[string, string]> {
-  const window = syncWindowRange(weeksAhead);
-  const prefix = `${origin}::`;
-  const entries: Array<[string, string]> = [];
-
-  for (const [mapKey, raw] of Object.entries(eventMap)) {
-    if (!mapKey.startsWith(prefix)) continue;
-    const entry = normalizeEventMapEntry(raw);
-    if (!entry) continue;
-
-    let shouldDelete = false;
-    if (mode === "incremental") {
-      shouldDelete = false;
-    } else if (entry.date) {
-      shouldDelete = !isDateInRange(entry.date, window);
-    } else {
-      shouldDelete = !currentMapKeys.has(mapKey);
-    }
-
-    if (shouldDelete) entries.push([mapKey, entry.id]);
-  }
-
-  return entries;
-}
-
 /** Runs in the content script tab so long syncs are not killed by the MV3 service worker. */
 export async function syncLessonsToGoogleCalendar(
   request: GoogleCalendarSyncRequest,
@@ -149,16 +94,14 @@ export async function syncLessonsToGoogleCalendar(
   options: GoogleCalendarSyncOptions = {},
 ): Promise<GoogleCalendarSyncResult> {
   if (!isGoogleCalendarConfigured()) {
-    return {
-      success: false,
-      configured: false,
-      error: "Google Calendar is not configured in this extension build.",
-    };
+    return notConfiguredSyncResult(
+      "Google Calendar is not configured in this extension build.",
+    );
   }
 
   const state = await readGoogleCalendarState();
   if (!state.refreshToken && !state.accessToken) {
-    return { success: false, configured: true, connected: false, error: "Connect Google Calendar first." };
+    return notConnectedSyncResult("Connect Google Calendar first.");
   }
 
   const mode = request.mode ?? "full";
@@ -167,26 +110,21 @@ export async function syncLessonsToGoogleCalendar(
   const events = mapLessonsToGoogleEvents(request.origin, request.lessons, timeZone);
 
   if (events.length === 0 && mode === "full") {
-    return {
-      success: false,
-      configured: true,
-      connected: true,
-      error: "No timetable classes found to sync for the selected range.",
-    };
+    return emptyLessonsSyncResult();
   }
 
-  reportProgress(options.onProgress, {
+  reportSyncProgress(options.onProgress, {
     phase: "preparing",
     current: 0,
     total: Math.max(events.length, 1),
     message: mode === "incremental" ? "Preparing weekly sync…" : "Preparing sync…",
   });
 
-  let accessToken = await getAccessToken();
   const eventMap = { ...(state.eventMap ?? {}) };
   const currentMapKeys = new Set(events.map((event) => eventMapKey(request.origin, event.seqtaKey)));
   const staleEntries = entriesToPrune(eventMap, request.origin, mode, weeksAhead, currentMapKeys);
   const totalSteps = staleEntries.length + events.length;
+  const lastSyncAt = Date.now();
 
   const staleResult = await deleteTrackedEventsFromGoogle(
     staleEntries,
@@ -198,89 +136,53 @@ export async function syncLessonsToGoogleCalendar(
     totalSteps,
   );
 
-  let created = 0;
-  let updated = 0;
-  let failed = staleResult.failed;
-  const lastSyncAt = Date.now();
-
-  for (let i = 0; i < events.length; i++) {
-    const event = events[i];
-    const mapKey = eventMapKey(request.origin, event.seqtaKey);
-    const existingId = getStoredEventId(eventMap[mapKey]);
-    try {
-      const googleId = await upsertGoogleCalendarEvent(
+  const upsertResult = await upsertLessonEvents({
+    events,
+    eventMap,
+    origin: request.origin,
+    staleEntryCount: staleEntries.length,
+    totalSteps,
+    lastSyncAt,
+    initialFailed: staleResult.failed,
+    getAccessToken,
+    mapKey: eventMapKey,
+    upsert: (accessToken, existingId, event, refreshAccessToken) =>
+      upsertGoogleCalendarEvent(
         accessToken,
         CALENDAR_ID,
         existingId,
         googleApiEventBody(event),
-        async () => {
-          accessToken = await getAccessToken();
-          return accessToken;
-        },
-      );
-      if (existingId) updated += 1;
-      else created += 1;
-      eventMap[mapKey] = {
-        id: googleId,
-        date: lessonDateForEvent(event.startDateTime, event.seqtaKey),
-      };
+        refreshAccessToken,
+      ),
+    writeState: writeGoogleCalendarState,
+    onProgress: options.onProgress,
+    logLabel: "Google Calendar",
+  });
 
-      reportProgress(options.onProgress, {
-        phase: "upserting",
-        current: staleEntries.length + i + 1,
-        total: totalSteps,
-        message: `Syncing events (${i + 1}/${events.length})…`,
-      });
+  await persistFinalSyncState(
+    writeGoogleCalendarState,
+    eventMap,
+    lastSyncAt,
+    request.origin,
+    staleResult.deleted,
+    staleEntries.length,
+    events.length,
+  );
 
-      if ((i + 1) % EVENT_MAP_PERSIST_EVERY === 0 || i === events.length - 1) {
-        await writeGoogleCalendarState({
-          eventMap,
-          lastSyncAt,
-          lastSyncOrigin: request.origin,
-        });
-      }
-    } catch (err) {
-      verboseLog("[BetterSEQTA+] Google Calendar event sync failed:", err);
-      failed += 1;
-      reportProgress(options.onProgress, {
-        phase: "upserting",
-        current: staleEntries.length + i + 1,
-        total: totalSteps,
-        message: `Syncing events (${i + 1}/${events.length})…`,
-      });
-    }
-  }
-
-  if (staleResult.deleted > 0 || staleEntries.length > 0 || events.length > 0) {
-    await writeGoogleCalendarState({
-      eventMap,
-      lastSyncAt,
-      lastSyncOrigin: request.origin,
-    });
-  }
-
-  reportProgress(options.onProgress, {
+  reportSyncProgress(options.onProgress, {
     phase: "done",
     current: totalSteps,
     total: totalSteps,
     message: "Sync complete",
   });
 
-  return {
-    success: failed === 0,
-    configured: true,
-    connected: true,
-    created,
-    updated,
-    deleted: staleResult.deleted,
-    skipped: 0,
-    failed,
+  return buildLessonSyncResult(
+    upsertResult.created,
+    upsertResult.updated,
+    staleResult.deleted,
+    upsertResult.failed,
     lastSyncAt,
-    error:
-      failed > 0
-        ? `Synced with ${failed} error${failed === 1 ? "" : "s"}. Check the console for details.`
-        : undefined,
-  };
+  );
 }
 
 /** Delete all tracked BetterSEQTA+ events for this SEQTA origin from Google Calendar. */
@@ -307,7 +209,7 @@ export async function deleteSyncedEventsFromGoogleCalendar(
     return { success: true, configured: true, connected: true, deleted: 0, failed: 0 };
   }
 
-  reportProgress(options.onProgress, {
+  reportSyncProgress(options.onProgress, {
     phase: "preparing",
     current: 0,
     total: entries.length,
@@ -327,7 +229,7 @@ export async function deleteSyncedEventsFromGoogleCalendar(
 
   await writeGoogleCalendarState({ eventMap });
 
-  reportProgress(options.onProgress, {
+  reportSyncProgress(options.onProgress, {
     phase: "done",
     current: entries.length,
     total: entries.length,