fix: appease the ci godas

src/seqta/utils/outlookCalendar/syncEngine.ts

@@ -2,18 +2,20 @@ import { verboseLog } from "@/utils/verboseLog";
 import { isOutlookCalendarConfigured } from "@/config/outlookCalendar";
 import { getSyncWeeksAhead } from "@/seqta/utils/calendarSync/settings";
 import {
-  getStoredEventId,
-  lessonDateFromSeqtaKey,
-  normalizeEventMapEntry,
-} from "@/seqta/utils/googleCalendar/eventMapEntry";
-import {
-  isDateInRange,
-  syncWindowRange,
-} from "@/seqta/utils/googleCalendar/syncDateRange";
+  buildLessonSyncResult,
+  emptyLessonsSyncResult,
+  entriesToPrune,
+  EVENT_MAP_PERSIST_EVERY,
+  notConfiguredSyncResult,
+  notConnectedSyncResult,
+  originEventMapEntries,
+  persistFinalSyncState,
+  reportSyncProgress,
+  upsertLessonEvents,
+} from "@/seqta/utils/calendarSync/lessonSyncShared";
 import type {
   GoogleCalendarDeleteResult,
   GoogleCalendarSyncOptions,
-  GoogleCalendarSyncProgress,
   GoogleCalendarSyncRequest,
   GoogleCalendarSyncResult,
 } from "@/seqta/utils/googleCalendar/types";
@@ -31,24 +33,11 @@ import {
   upsertOutlookCalendarEvent,
 } from "@/seqta/utils/outlookCalendar/upsertEvent";
 
-const EVENT_MAP_PERSIST_EVERY = 10;
-
 type DeleteTrackedEventsResult = {
   deleted: number;
   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 deleteTrackedEventsFromOutlook(
   entries: Array<[string, string]>,
   eventMap: Record<string, string | { id: string; date: string }>,
@@ -73,7 +62,7 @@ async function deleteTrackedEventsFromOutlook(
       delete eventMap[mapKey];
       deleted += 1;
 
-      reportProgress(onProgress, {
+      reportSyncProgress(onProgress, {
         phase: "deleting",
         current: progressOffset + deleted + failed,
         total: progressTotal,
@@ -86,7 +75,7 @@ async function deleteTrackedEventsFromOutlook(
     } catch (err) {
       verboseLog("[BetterSEQTA+] Outlook Calendar event delete failed:", err);
       failed += 1;
-      reportProgress(onProgress, {
+      reportSyncProgress(onProgress, {
         phase: "deleting",
         current: progressOffset + deleted + failed,
         total: progressTotal,
@@ -98,67 +87,20 @@ async function deleteTrackedEventsFromOutlook(
   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;
-}
-
 export async function syncLessonsToOutlookCalendar(
   request: GoogleCalendarSyncRequest,
   getAccessToken: () => Promise<string>,
   options: GoogleCalendarSyncOptions = {},
 ): Promise<GoogleCalendarSyncResult> {
   if (!isOutlookCalendarConfigured()) {
-    return {
-      success: false,
-      configured: false,
-      error: "Outlook Calendar is not configured in this extension build.",
-    };
+    return notConfiguredSyncResult(
+      "Outlook Calendar is not configured in this extension build.",
+    );
   }
 
   const state = await readOutlookCalendarState();
   if (!state.refreshToken && !state.accessToken) {
-    return { success: false, configured: true, connected: false, error: "Connect Outlook Calendar first." };
+    return notConnectedSyncResult("Connect Outlook Calendar first.");
   }
 
   const mode = request.mode ?? "full";
@@ -167,28 +109,23 @@ export async function syncLessonsToOutlookCalendar(
   const events = mapLessonsToOutlookEvents(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) => outlookEventMapKey(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 deleteTrackedEventsFromOutlook(
     staleEntries,
@@ -200,88 +137,52 @@ export async function syncLessonsToOutlookCalendar(
     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 = outlookEventMapKey(request.origin, event.seqtaKey);
-    const existingId = getStoredEventId(eventMap[mapKey]);
-    try {
-      const outlookId = await upsertOutlookCalendarEvent(
+  const upsertResult = await upsertLessonEvents({
+    events,
+    eventMap,
+    origin: request.origin,
+    staleEntryCount: staleEntries.length,
+    totalSteps,
+    lastSyncAt,
+    initialFailed: staleResult.failed,
+    getAccessToken,
+    mapKey: outlookEventMapKey,
+    upsert: (accessToken, existingId, event, refreshAccessToken) =>
+      upsertOutlookCalendarEvent(
         accessToken,
         existingId,
         outlookGraphEventBody(event),
-        async () => {
-          accessToken = await getAccessToken();
-          return accessToken;
-        },
-      );
-      if (existingId) updated += 1;
-      else created += 1;
-      eventMap[mapKey] = {
-        id: outlookId,
-        date: lessonDateForEvent(event.startDateTime, event.seqtaKey),
-      };
+        refreshAccessToken,
+      ),
+    writeState: writeOutlookCalendarState,
+    onProgress: options.onProgress,
+    logLabel: "Outlook Calendar",
+  });
 
-      reportProgress(options.onProgress, {
-        phase: "upserting",
-        current: staleEntries.length + i + 1,
-        total: totalSteps,
-        message: `Syncing events (${i + 1}/${events.length})…`,
-      });
+  await persistFinalSyncState(
+    writeOutlookCalendarState,
+    eventMap,
+    lastSyncAt,
+    request.origin,
+    staleResult.deleted,
+    staleEntries.length,
+    events.length,
+  );
 
-      if ((i + 1) % EVENT_MAP_PERSIST_EVERY === 0 || i === events.length - 1) {
-        await writeOutlookCalendarState({
-          eventMap,
-          lastSyncAt,
-          lastSyncOrigin: request.origin,
-        });
-      }
-    } catch (err) {
-      verboseLog("[BetterSEQTA+] Outlook 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 writeOutlookCalendarState({
-      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,
-  };
+  );
 }
 
 export async function deleteSyncedEventsFromOutlookCalendar(
@@ -307,7 +208,7 @@ export async function deleteSyncedEventsFromOutlookCalendar(
     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 +228,7 @@ export async function deleteSyncedEventsFromOutlookCalendar(
 
   await writeOutlookCalendarState({ eventMap });
 
-  reportProgress(options.onProgress, {
+  reportSyncProgress(options.onProgress, {
     phase: "done",
     current: entries.length,
     total: entries.length,