🐛 Fix: map gcal recurrence correctly

change to include either rule OR recurringEventId (not both)

Author: tyler-dane

packages/backend/src/event/services/recurrence/manage/recurrence.manager.test.ts

@@ -0,0 +1,48 @@
+import { Origin } from "@core/constants/core.constants";
+import { Priorities } from "@core/constants/core.constants";
+import { Summary_SeriesChange_Compass } from "../recurrence.types";
+import { shouldSplitSeries } from "./recurrence.manager";
+
+describe("shouldSplitSeries", () => {
+  it("should return true if the base event and new base event are different", () => {
+    const changes: Summary_SeriesChange_Compass = {
+      action: "UPDATE_SERIES",
+      baseEvent: {
+        description: "",
+        endDate: "2025-04-02T10:15:00-05:00",
+        isAllDay: false,
+        isSomeday: false,
+        gEventId: "439ntgoijfbls638nmrprgl6no",
+        origin: Origin.GOOGLE_IMPORT,
+        priority: Priorities.UNASSIGNED,
+        recurrence: {
+          rule: ["RRULE:FREQ=DAILY;UNTIL=20250403T045959Z"],
+        },
+        startDate: "2025-04-02T09:00:00-05:00",
+        title: "r1",
+        updatedAt: "2025-04-03T13:39:59.196Z",
+        user: "67ee8f9dda653b114194d127",
+      },
+      newBaseEvent: {
+        description: "",
+        endDate: "2025-04-03T10:15:00-05:00",
+        isAllDay: false,
+        isSomeday: false,
+        gEventId: "439ntgoijfbls638nmrprgl6no_R20250403T140000",
+        origin: Origin.GOOGLE_IMPORT,
+        priority: Priorities.UNASSIGNED,
+        recurrence: {
+          rule: ["RRULE:FREQ=DAILY"],
+        },
+        startDate: "2025-04-03T09:00:00-05:00",
+        title: "r1-i",
+        updatedAt: "2025-04-03T13:39:59.196Z",
+        user: "67ee8f9dda653b114194d127",
+      },
+      deleteFrom: "DAILY;UNTIL",
+    };
+
+    const result = shouldSplitSeries(changes);
+    expect(result).toBe(true);
+  });
+});

packages/backend/src/event/services/recurrence/manage/recurrence.manager.ts

@@ -1,3 +1,7 @@
+import {
+  Schema_Event_Recur_Base,
+  Schema_Event_Recur_Instance,
+} from "@core/types/event.types";
 import { GenericError } from "@backend/common/constants/error.constants";
 import { error } from "@backend/common/errors/handlers/error.handler";
 import { RecurringEventProcessor } from "../process/processor.interface";
@@ -16,13 +20,15 @@ export class RecurringEventManager {
 
   /**
    * Main entrypoint that handles different recurring event actions
-   * @param input The action data containing events and action type
+   * @param changes The action data containing events and action type
    */
-  async handleAction(input: Summary_SeriesChange_Compass) {
+  async handleAction(changes: Summary_SeriesChange_Compass) {
     const { action, baseEvent, newBaseEvent, modifiedInstance, deleteFrom } =
-      input;
+      changes;
+
+    console.log("handling changes:");
+    console.log(JSON.stringify(changes, null, 2));
 
-    console.log(input);
     switch (action) {
       case "CREATE_SERIES":
         if (baseEvent) {
@@ -38,14 +44,16 @@ export class RecurringEventManager {
 
       case "UPDATE_SERIES":
         // Series update with split (this and future)
-        if (baseEvent && newBaseEvent && modifiedInstance) {
+        if (shouldSplitSeries(changes)) {
+          console.log("++ updating series with split");
           return this.processor.updateSeriesWithSplit(
-            baseEvent,
-            modifiedInstance,
+            baseEvent as Schema_Event_Recur_Base,
+            modifiedInstance as Schema_Event_Recur_Instance,
           );
         }
         // Update entire series
         else if (baseEvent && newBaseEvent) {
+          console.log("++ updating entire series");
           return this.processor.updateEntireSeries(baseEvent, newBaseEvent);
         }
         break;
@@ -74,3 +82,23 @@ export class RecurringEventManager {
     );
   }
 }
+
+export const shouldSplitSeries = (changes: Summary_SeriesChange_Compass) => {
+  console.log("++ checking if shouldSplitSeries using these changes:");
+  console.log(JSON.stringify(changes, null, 2));
+
+  // If we have a base event with an UNTIL rule and a new base event with a rule but no UNTIL,
+  // we need to split the series
+  const baseEventHasUntil =
+    changes.baseEvent?.recurrence?.rule?.[0]?.includes("UNTIL");
+  const newBaseEventHasRule =
+    changes.newBaseEvent?.recurrence?.rule?.[0] !== undefined;
+  const newBaseEventHasNoUntil =
+    !changes.newBaseEvent?.recurrence?.rule?.[0]?.includes("UNTIL");
+
+  if (baseEventHasUntil && newBaseEventHasRule && newBaseEventHasNoUntil) {
+    return true;
+  }
+
+  return false;
+};

packages/backend/src/event/services/recurrence/map/gcal.recur.map.test.ts

@@ -0,0 +1,68 @@
+import { Action_Series } from "../recurrence.types";
+import { GCalRecurringEventMapper } from "./gcal.recur.map";
+
+describe("GCalRecurringEventMapper", () => {
+  it("infers the correct action", () => {
+    const changesFromGcal = {
+      action: "UPDATE_SERIES" as Action_Series,
+      baseEvent: {
+        kind: "calendar#event",
+        etag: '"3487376669522302"',
+        id: "7q78dn5t1eu6ikjq5mj4q7s93d",
+        status: "confirmed",
+        htmlLink:
+          "https://www.google.com/calendar/event?eid=N3E3OGRuNXQxZXU2aWtqcTVtajRxN3M5M2RfMjAyNTA0MDJUMTIwMDAwWiBsYW5jZS5lc3NlcnRAbQ",
+        created: "2025-04-03T13:49:29.000Z",
+        updated: "2025-04-03T13:52:14.761Z",
+        summary: "r1",
+        creator: { email: "lance.essert@gmail.com", self: true },
+        organizer: { email: "lance.essert@gmail.com", self: true },
+        start: {
+          dateTime: "2025-04-02T07:00:00-05:00",
+          timeZone: "America/Chicago",
+        },
+        end: {
+          dateTime: "2025-04-02T08:00:00-05:00",
+          timeZone: "America/Chicago",
+        },
+        recurrence: ["RRULE:FREQ=DAILY;UNTIL=20250403T045959Z"],
+        iCalUID: "7q78dn5t1eu6ikjq5mj4q7s93d@google.com",
+        sequence: 0,
+        reminders: { useDefault: true },
+        eventType: "default",
+      },
+      newBaseEvent: {
+        kind: "calendar#event",
+        etag: '"3487376669522302"',
+        id: "7q78dn5t1eu6ikjq5mj4q7s93d_R20250403T120000",
+        status: "confirmed",
+        htmlLink:
+          "https://www.google.com/calendar/event?eid=N3E3OGRuNXQxZXU2aWtqcTVtajRxN3M5M2RfMjAyNTA0MDNUMTIwMDAwWiBsYW5jZS5lc3NlcnRAbQ",
+        created: "2025-04-03T13:49:29.000Z",
+        updated: "2025-04-03T13:52:14.761Z",
+        summary: "r1-i",
+        creator: { email: "lance.essert@gmail.com", self: true },
+        organizer: { email: "lance.essert@gmail.com", self: true },
+        start: {
+          dateTime: "2025-04-03T07:00:00-05:00",
+          timeZone: "America/Chicago",
+        },
+        end: {
+          dateTime: "2025-04-03T08:00:00-05:00",
+          timeZone: "America/Chicago",
+        },
+        recurrence: ["RRULE:FREQ=DAILY"],
+        iCalUID: "7q78dn5t1eu6ikjq5mj4q7s93d_R20250403T120000@google.com",
+        sequence: 0,
+        reminders: { useDefault: true },
+        eventType: "default",
+      },
+      deleteFrom: "DAILY;UNTIL",
+      hasInstances: false,
+    };
+
+    const mapper = new GCalRecurringEventMapper("123", changesFromGcal);
+    const result = mapper.inferChanges();
+    expect(result.action).toEqual("UPDATE_SERIES");
+  });
+});

packages/backend/src/event/services/recurrence/map/gcal.recur.map.ts

@@ -22,23 +22,25 @@ export class GCalRecurringEventMapper {
   }
 
   /**
-   * Maps Google Calendar events to our schemas
+   * Infer changes from Google Calendar events
    */
-  mapEvents(): Summary_SeriesChange_Compass {
-    const schemaEvents = this.mapActionAnalysisToEvents();
-    const input = {
+  inferChanges(): Summary_SeriesChange_Compass {
+    const schemaEvents = this.mapGcalChangesToCompassChanges();
+    const compassChanges = {
       action: this.actionAnalysis.action,
       ...schemaEvents,
       deleteFrom: this.actionAnalysis.deleteFrom,
     };
 
-    return input;
+    console.log("++ compassChanges (returning these from mapper):");
+    console.log(JSON.stringify(compassChanges));
+    return compassChanges;
   }
 
   /**
-   * Maps Google Calendar action analysis to Schema_Event objects
+   * Maps Google Calendar changes to Compass changes
    */
-  private mapActionAnalysisToEvents() {
+  private mapGcalChangesToCompassChanges() {
     const result: {
       baseEvent?: Schema_Event_Recur_Base;
       newBaseEvent?: Schema_Event_Recur_Base;

packages/backend/src/event/services/recurrence/parse/recur.gcal.parse.test.ts

@@ -4,13 +4,13 @@ import { deleteSingleEventPayloads } from "@backend/__tests__/mocks.gcal/fixture
 import { deleteThisAndFollowingPayloads } from "@backend/__tests__/mocks.gcal/fixtures/recurring/delete/this-and-following";
 import { editAllPayloads } from "@backend/__tests__/mocks.gcal/fixtures/recurring/edit/all";
 import { editSingleEventPayloads } from "@backend/__tests__/mocks.gcal/fixtures/recurring/edit/single";
-import { editThisAndFollowingPayloads } from "@backend/__tests__/mocks.gcal/fixtures/recurring/edit/this-and-following";
-import { determineNextAction } from "@backend/event/services/recurrence/parse/recur.gcal.parse";
+import { thisAndFollowingPayloads } from "@backend/__tests__/mocks.gcal/fixtures/recurring/edit/this-and-following";
+import { inferGcalChange } from "@backend/event/services/recurrence/parse/recur.gcal.parse";
 
 describe("Gcal Recurring Event Payload Analysis", () => {
   describe("Create", () => {
     it("should return CREATE_SERIES after new recurring event creation", () => {
-      const analysis = determineNextAction(
+      const analysis = inferGcalChange(
         createNewRecurringEventPayload.items || [],
       );
       expect(analysis.action).toBe("CREATE_SERIES");
@@ -22,16 +22,16 @@ describe("Gcal Recurring Event Payload Analysis", () => {
   describe("Update", () => {
     it("should return UPDATE_INSTANCE after single instance update", () => {
       for (const instance of editSingleEventPayloads) {
-        const analysis = determineNextAction(instance.items || []);
+        const analysis = inferGcalChange(instance.items || []);
         expect(analysis.action).toBe("UPDATE_INSTANCE");
         expect(analysis.modifiedInstance).toBeDefined();
         expect(analysis.modifiedInstance?.recurringEventId).toBeDefined();
       }
     });
 
     it("should return UPDATE_SERIES after series split", () => {
-      for (const payload of editThisAndFollowingPayloads) {
-        const analysis = determineNextAction(payload.items || []);
+      for (const payload of thisAndFollowingPayloads) {
+        const analysis = inferGcalChange(payload.items || []);
         expect(analysis.action).toBe("UPDATE_SERIES");
         expect(analysis.baseEvent).toBeDefined();
         expect(analysis.newBaseEvent).toBeDefined();
@@ -46,7 +46,7 @@ describe("Gcal Recurring Event Payload Analysis", () => {
 
     it("should return UPDATE_SERIES after series update", () => {
       for (const payload of editAllPayloads) {
-        const analysis = determineNextAction(payload.items || []);
+        const analysis = inferGcalChange(payload.items || []);
         expect(analysis.action).toBe("UPDATE_SERIES");
         expect(analysis.baseEvent).toBeDefined();
         expect(analysis.baseEvent?.recurrence).toBeDefined();
@@ -56,7 +56,7 @@ describe("Gcal Recurring Event Payload Analysis", () => {
   describe("Delete", () => {
     it("should return DELETE_SERIES after deleting all instances", () => {
       for (const payload of deleteAllPayloads) {
-        const analysis = determineNextAction(payload.items || []);
+        const analysis = inferGcalChange(payload.items || []);
         expect(analysis.action).toBe("DELETE_SERIES");
         expect(analysis.baseEvent).toBeUndefined();
         expect(analysis.modifiedInstance).toBeUndefined();
@@ -66,7 +66,7 @@ describe("Gcal Recurring Event Payload Analysis", () => {
 
     it("should return DELETE_INSTANCES after deleting single instance", () => {
       for (const payload of deleteSingleEventPayloads) {
-        const analysis = determineNextAction(payload.items || []);
+        const analysis = inferGcalChange(payload.items || []);
         expect(analysis.action).toBe("DELETE_INSTANCES");
         expect(analysis.baseEvent).toBeDefined();
         expect(analysis.modifiedInstance).toBeDefined();
@@ -77,7 +77,7 @@ describe("Gcal Recurring Event Payload Analysis", () => {
 
     it("should return DELETE_INSTANCES after deleting this and following instances", () => {
       for (const payload of deleteThisAndFollowingPayloads) {
-        const analysis = determineNextAction(payload.items || []);
+        const analysis = inferGcalChange(payload.items || []);
         expect(analysis.action).toBe("DELETE_INSTANCES");
         expect(analysis.baseEvent).toBeDefined();
         expect(

packages/backend/src/event/services/recurrence/parse/recur.gcal.parse.ts

@@ -4,10 +4,9 @@ import { error } from "@backend/common/errors/handlers/error.handler";
 import { Summary_SeriesChange_Gcal } from "../recurrence.types";
 
 /**
- * Analyzes an array of events from Google Calendar to determine the next action needed
- * to sync the database with Google Calendar's state.
+ * Infer changes from Google Calendar events
  */
-export function determineNextAction(
+export function inferGcalChange(
   events: gSchema$Event[],
 ): Summary_SeriesChange_Gcal {
   const parser = new GCalParser(events);

packages/backend/src/event/services/recurrence/process/compass/compass.recur.processor.ts

@@ -283,6 +283,7 @@ export class CompassRecurringEventProcessor implements RecurringEventProcessor {
         "Failed to update recurring event series because untilDate was empty",
       );
     }
+    console.log("untilDate:", untilDate, typeof untilDate);
 
     await this.collection.updateOne(
       { _id: originalBase._id },

packages/backend/src/sync/services/notify/gcal.notification.handler.ts

@@ -12,7 +12,7 @@ import { findCompassEventBy } from "@backend/event/queries/event.queries";
 import eventService from "@backend/event/services/event.service";
 import { RecurringEventManager } from "@backend/event/services/recurrence/manage/recurrence.manager";
 import { GCalRecurringEventMapper } from "@backend/event/services/recurrence/map/gcal.recur.map";
-import { determineNextAction } from "@backend/event/services/recurrence/parse/recur.gcal.parse";
+import { inferGcalChange } from "@backend/event/services/recurrence/parse/recur.gcal.parse";
 import { CompassRecurringEventProcessor } from "@backend/event/services/recurrence/process/compass/compass.recur.processor";
 import { getSync, updateSyncTokenFor } from "@backend/sync/util/sync.queries";
 
@@ -38,6 +38,7 @@ export class GCalNotificationHandler {
     );
 
     if (hasChanges) {
+      console.log("++ processing changes:", changes.length);
       await this.processEvents(changes);
       return "CHANGES_PROCESSED";
     } else {
@@ -54,6 +55,9 @@ export class GCalNotificationHandler {
       syncToken,
     });
 
+    console.log("++ response after getting latest changes:");
+    console.log(JSON.stringify(response.data, null, 2));
+
     // If the nextSyncToken matches our current syncToken, we've already processed these changes
     if (response.data.nextSyncToken === syncToken) {
       logger.info(
@@ -192,15 +196,17 @@ export class GCalNotificationHandler {
    */
   private async processRecurringEvents(recurringEvents: gSchema$Event[]) {
     if (recurringEvents.length > 0) {
-      const nextAction = determineNextAction(recurringEvents);
+      const gcalChanges = inferGcalChange(recurringEvents);
 
-      const mapper = new GCalRecurringEventMapper(this.userId, nextAction);
-      const input = mapper.mapEvents();
+      console.log("++ gcalChanges (sending these to mapper):");
+      console.log(JSON.stringify(gcalChanges));
+      const mapper = new GCalRecurringEventMapper(this.userId, gcalChanges);
+      const changes = mapper.inferChanges();
 
       const processor = new CompassRecurringEventProcessor(this.userId);
       const manager = new RecurringEventManager(processor);
-      const result = await manager.handleAction(input);
-      console.log("++ from processRecurringEvents:", result);
+      const result = await manager.handleAction(changes);
+      console.log("++ result after handling:", gcalChanges.action, ":", result);
     }
   }
 }