🐛 fix(gcal-event-processor): update gcal sync processor

Author: victor-enogwe

packages/backend/src/sync/services/sync/__tests__/gcal.sync.processor.delete.test.ts

@@ -1,9 +1,6 @@
-import { Categories_Recurrence, Schema_Event } from "@core/types/event.types";
+import { Categories_Recurrence } from "@core/types/event.types";
 import { WithGcalId, gSchema$Event } from "@core/types/gcal";
-import {
-  categorizeEvents,
-  isExistingInstance,
-} from "@core/util/event/event.util";
+import { categorizeEvents } from "@core/util/event/event.util";
 import { UtilDriver } from "@backend/__tests__/drivers/util.driver";
 import {
   getEventsInDb,
@@ -16,11 +13,8 @@ import {
 } from "@backend/__tests__/helpers/mock.db.setup";
 import { simulateDbAfterGcalImport } from "@backend/__tests__/helpers/mock.events.init";
 import { mockRecurringGcalBaseEvent } from "@backend/__tests__/mocks.gcal/factories/gcal.event.factory";
-import { RecurringEventRepository } from "@backend/event/services/recur/repo/recur.event.repo";
-import { createSeries } from "@backend/sync/services/sync/__tests__/gcal.sync.processor.delete.util";
 import { createCompassSeriesFromGcalBase } from "@backend/sync/services/sync/__tests__/gcal.sync.processor.test.util";
 import { GcalSyncProcessor } from "@backend/sync/services/sync/gcal.sync.processor";
-import { Change_Gcal } from "@backend/sync/sync.types";
 
 describe("GcalSyncProcessor: DELETE", () => {
   beforeAll(setupTestDb);
@@ -32,7 +26,6 @@ describe("GcalSyncProcessor: DELETE", () => {
   it("should delete a STANDALONE event", async () => {
     /* Assemble */
     const { user } = await UtilDriver.setupTestUser();
-    const repo = new RecurringEventRepository(user._id.toString());
 
     const { gcalEvents } = await simulateDbAfterGcalImport(user._id.toString());
 
@@ -47,14 +40,14 @@ describe("GcalSyncProcessor: DELETE", () => {
       status: "cancelled",
     } as WithGcalId<gSchema$Event>;
 
-    const processor = new GcalSyncProcessor(repo);
+    const processor = new GcalSyncProcessor(user._id.toString());
     const changes = await processor.processEvents([cancelledGStandalone]);
 
     /* Assert: Should return a DELETED change */
     expect(changes).toHaveLength(1);
     expect(changes[0]).toMatchObject({
       title: cancelledGStandalone.id,
-      operation: "DELETED",
+      operation: "STANDALONE_DELETED",
     });
 
     // Verify the event is deleted from the DB
@@ -76,48 +69,66 @@ describe("GcalSyncProcessor: DELETE", () => {
   it("should delete an INSTANCE after cancelling it", async () => {
     /* Assemble */
     const { user } = await UtilDriver.setupTestUser();
-    const repo = new RecurringEventRepository(user._id.toString());
-    const { compassBaseId, gcalBaseId, meta } = await createSeries(user);
 
-    // Query the Compass DB for actual recurring instances
-    const compassInstances = await getEventsInDb({
-      gRecurringEventId: compassBaseId,
-    });
+    const { gcalEvents, compassEvents } = await simulateDbAfterGcalImport(
+      user._id.toString(),
+    );
 
-    const compassInstance = compassInstances[0];
+    const compassInstance = compassEvents[0];
 
     const cancelledGcalInstance = {
-      kind: "calendar#event",
-      id: compassInstance?.gEventId,
+      ...gcalEvents.instances[1],
       status: "cancelled",
-      recurringEventId: gcalBaseId,
       originalStartTime: {
-        date: compassInstance?.startDate?.slice(0, 10) || "2025-04-10",
+        dateTime: compassInstance?.startDate || "2025-04-10",
       },
     };
 
     /* Act */
-    const processor = new GcalSyncProcessor(repo);
-    const changes = await processor.processEvents([cancelledGcalInstance]);
+    const processor = new GcalSyncProcessor(user._id.toString());
+
+    const changes = await processor.processEvents([
+      gcalEvents.recurring,
+      cancelledGcalInstance,
+    ]);
 
     /* Assert */
-    expect(changes).toHaveLength(1);
-    const expected: Change_Gcal = {
-      title: cancelledGcalInstance.id as string,
-      category: Categories_Recurrence.RECURRENCE_INSTANCE,
-      operation: "DELETED",
-    };
-    expect(changes[0]).toEqual(expected);
+    expect(changes).toHaveLength(3);
+
+    expect(changes).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          title: gcalEvents.recurring.summary,
+          category: Categories_Recurrence.RECURRENCE_BASE,
+          operation: "RECURRENCE_BASE_UPDATED",
+        }),
+        expect.objectContaining({
+          title: gcalEvents.recurring.summary,
+          category: Categories_Recurrence.RECURRENCE_BASE,
+          operation: "TIMED_INSTANCES_UPDATED",
+        }),
+        expect.objectContaining({
+          title: cancelledGcalInstance.summary as string,
+          category: Categories_Recurrence.RECURRENCE_INSTANCE,
+          operation: "RECURRENCE_INSTANCE_DELETED",
+        }),
+      ]),
+    );
 
     const remainingEvents = await getEventsInDb({ user: user._id.toString() });
 
     // Verify only the instance was deleted
-    expect(remainingEvents).toHaveLength(meta.createdCount - 1);
-    expect(remainingEvents[0]?._id?.toString()).toBe(compassBaseId);
+    expect(remainingEvents).toHaveLength(compassEvents.length - 1);
+    expect(remainingEvents[0]?._id?.toString()).toBe(
+      compassEvents[0]?._id.toString(),
+    );
 
     expect(
-      isExistingInstance(remainingEvents[1] as unknown as Schema_Event),
-    ).toBe(true);
+      remainingEvents.find(
+        ({ gRecurringEventId }) =>
+          gRecurringEventId === cancelledGcalInstance.id,
+      ),
+    ).toBeUndefined();
   });
 
   it("should handle a mixed payload of multiple INSTANCE DELETIONS and one BASE UPSERT", async () => {
@@ -129,36 +140,37 @@ describe("GcalSyncProcessor: DELETE", () => {
     });
 
     const { user } = await UtilDriver.setupTestUser();
-    const repo = new RecurringEventRepository(user._id.toString());
 
     const { state } = await createCompassSeriesFromGcalBase(
       user,
       gcalBaseEvent,
     );
 
     // Create cancellation payloads for each instance
-    const cancellations = state.instances.map((i) => ({
+    const cancellations: gSchema$Event[] = state.instances.map((i) => ({
       kind: "calendar#event",
       id: i.gEventId,
+      start: { dateTime: i.startDate },
+      recurringEventId: gcalBaseEvent.id,
       status: "cancelled",
     }));
 
     /* Act */
-    const processor = new GcalSyncProcessor(repo);
+    const processor = new GcalSyncProcessor(user._id.toString());
     const changes = await processor.processEvents([
       gcalBaseEvent,
       ...cancellations,
     ]);
 
     /* Assert */
     // Validate all changes detected
-    expect(changes).toHaveLength(3);
+    expect(changes).toHaveLength(4);
 
     // Validate change types
-    const deletions = changes.filter((c) => c.operation === "DELETED");
-    const upserts = changes.filter((c) => c.operation === "UPSERTED");
-    expect(deletions).toHaveLength(2);
-    expect(upserts).toHaveLength(1);
+    const deletions = changes.filter((c) => c.operation?.includes("DELETED"));
+    const upserts = changes.filter((c) => c.operation?.includes("UPDATED"));
+    expect(deletions).toHaveLength(cancellations.length);
+    expect(upserts).toHaveLength(cancellations.length);
 
     // Validate DB state
     const remainingEvents = await getEventsInDb({
@@ -180,7 +192,6 @@ describe("GcalSyncProcessor: DELETE", () => {
 
   it("should delete BASE and all INSTANCES after cancelling a BASE", async () => {
     const { user } = await UtilDriver.setupTestUser();
-    const repo = new RecurringEventRepository(user._id.toString());
 
     const gcalBaseEvent = mockRecurringGcalBaseEvent({
       recurrence: ["RRULE:FREQ=DAILY"],
@@ -190,21 +201,24 @@ describe("GcalSyncProcessor: DELETE", () => {
 
     // Cancel the entire series
     const cancelledBase = {
-      kind: "calendar#event",
-      id: gcalBaseEvent.id,
+      ...gcalBaseEvent,
       status: "cancelled",
     };
 
-    const processor = new GcalSyncProcessor(repo);
+    const processor = new GcalSyncProcessor(user._id.toString());
     const changes = await processor.processEvents([cancelledBase]);
 
     expect(changes).toHaveLength(1);
-    const expected: Change_Gcal = {
-      title: cancelledBase.id as string,
-      category: Categories_Recurrence.RECURRENCE_BASE,
-      operation: "DELETED",
-    };
-    expect(changes[0]).toEqual(expected);
+
+    expect(changes).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          title: cancelledBase.summary as string,
+          category: Categories_Recurrence.RECURRENCE_BASE,
+          operation: "SERIES_DELETED",
+        }),
+      ]),
+    );
 
     // Verify all Compass events that match the gcal base were deleted
     const isEmpty = await isEventCollectionEmpty();

packages/backend/src/sync/services/sync/__tests__/gcal.sync.processor.upsert.base.split.test.ts

@@ -8,8 +8,8 @@ import {
   setupTestDb,
 } from "@backend/__tests__/helpers/mock.db.setup";
 import { simulateDbAfterGcalImport } from "@backend/__tests__/helpers/mock.events.init";
-import { RecurringEventRepository } from "@backend/event/services/recur/repo/recur.event.repo";
 import { GcalSyncProcessor } from "@backend/sync/services/sync/gcal.sync.processor";
+import { gSchema$Event } from "../../../../../../core/src/types/gcal";
 import {
   baseHasRecurrenceRule,
   noInstancesAfterSplitDate,
@@ -28,7 +28,6 @@ describe("GcalSyncProcessor: UPSERT: BASE SPLIT", () => {
   it("should handle new UNTIL in BASE by updating BASE rule and DELETING instances after the UNTIL date", async () => {
     /* Assemble */
     const { user } = await UtilDriver.setupTestUser();
-    const repo = new RecurringEventRepository(user._id.toString());
 
     const { gcalEvents } = await simulateDbAfterGcalImport(user._id.toString());
 
@@ -37,17 +36,34 @@ describe("GcalSyncProcessor: UPSERT: BASE SPLIT", () => {
 
     /* Act */
     const origEvents = await getEventsInDb({ user: user._id.toString() });
-    const processor = new GcalSyncProcessor(repo);
+    const processor = new GcalSyncProcessor(user._id.toString());
     const changes = await processor.processEvents([gBaseWithUntil]);
 
     /* Assert */
     // Verify the base was updated
-    expect(changes).toHaveLength(1);
-    expect(changes[0]).toEqual({
-      title: gBaseWithUntil.summary as string,
-      category: Categories_Recurrence.RECURRENCE_BASE,
-      operation: "UPSERTED",
-    });
+    expect(changes).toHaveLength(3);
+    expect(changes).toEqual(
+      expect.arrayContaining([
+        {
+          title: gBaseWithUntil.summary as string,
+          category: Categories_Recurrence.RECURRENCE_BASE,
+          operation: "SERIES_AFTER_UNTIL_DELETED",
+          transition: ["RECURRENCE_BASE", "RECURRENCE_BASE_CONFIRMED"],
+        },
+        {
+          title: gBaseWithUntil.summary as string,
+          category: Categories_Recurrence.RECURRENCE_BASE,
+          operation: "RECURRENCE_BASE_UPDATED",
+          transition: ["RECURRENCE_BASE", "RECURRENCE_BASE_CONFIRMED"],
+        },
+        {
+          title: gBaseWithUntil.summary as string,
+          category: Categories_Recurrence.RECURRENCE_BASE,
+          operation: "TIMED_INSTANCES_UPDATED",
+          transition: ["RECURRENCE_BASE", "RECURRENCE_BASE_CONFIRMED"],
+        },
+      ]),
+    );
 
     // Verify DB changed
     const remainingEvents = await getEventsInDb({
@@ -74,19 +90,19 @@ describe("GcalSyncProcessor: UPSERT: BASE SPLIT", () => {
   it("should handle cancelled instance at split point by deleting it", async () => {
     /* Assemble */
     const { user } = await UtilDriver.setupTestUser();
-    const repo = new RecurringEventRepository(user._id.toString());
 
     const { gcalEvents } = await simulateDbAfterGcalImport(user._id.toString());
 
     const origEvents = await getEventsInDb({ user: user._id.toString() });
 
     /* Act */
     // Simulate a gcal notification payload after an instance was cancelled
-    const cancelledInstance = Object.assign(gcalEvents.instances[1]!, {
+    const cancelledInstance: gSchema$Event = {
+      ...gcalEvents.instances[1],
       status: "cancelled",
-    });
+    };
 
-    const processor = new GcalSyncProcessor(repo);
+    const processor = new GcalSyncProcessor(user._id.toString());
     const changes = await processor.processEvents([cancelledInstance]);
 
     /* Assert */
@@ -95,7 +111,8 @@ describe("GcalSyncProcessor: UPSERT: BASE SPLIT", () => {
     expect(changes[0]).toEqual({
       title: cancelledInstance.summary,
       category: Categories_Recurrence.RECURRENCE_INSTANCE,
-      operation: "DELETED",
+      operation: "RECURRENCE_INSTANCE_DELETED",
+      transition: ["RECURRENCE_INSTANCE", "RECURRENCE_INSTANCE_CANCELLED"],
     });
 
     // Verify database state