✨ feat(edit-recurrence): WIP

Author: victor-enogwe

packages/backend/src/__tests__/mocks.gcal/factories/gcal.factory.ts

@@ -20,7 +20,6 @@ import {
   isRegularGCalEvent,
 } from "@core/util/event/gcal.event.util";
 import { compassTestState } from "@backend/__tests__/helpers/mock.setup";
-import { mockRecurringGcalEvents } from "@backend/__tests__/mocks.gcal/factories/gcal.event.factory";
 
 /**
  * Generates a paginated items for the Google Calendar API.
@@ -156,6 +155,38 @@ export const mockGcal = ({
           });
         },
       ),
+      update: jest.fn(
+        async (
+          params: calendar_v3.Params$Resource$Events$Update,
+          options: MethodOptions = {},
+        ): GaxiosPromise<gSchema$Event> => {
+          const testState = compassTestState();
+          const { all: events } = testState.events.gcalEvents;
+          const { eventId } = params;
+          const eventIndex = events.findIndex((e) => e.id === eventId);
+
+          if (eventIndex === -1) {
+            throw new Error(`Event with id ${eventId} not found`);
+          }
+
+          const updatedEvent = { ...events[eventIndex], ...params.requestBody };
+
+          events.splice(
+            eventIndex,
+            1,
+            updatedEvent as WithGcalId<gSchema$Event>,
+          );
+
+          return Promise.resolve({
+            config: options,
+            statusText: "OK",
+            status: 200,
+            data: updatedEvent,
+            headers: options.headers!,
+            request: { responseURL: updatedEvent.id! },
+          });
+        },
+      ),
       delete: jest.fn(
         async (params: calendar_v3.Params$Resource$Events$Delete) => {
           const testState = compassTestState();
@@ -167,8 +198,23 @@ export const mockGcal = ({
             throw new Error(`Event with id ${eventId} not found`);
           }
 
+          const event = events[eventIndex]!;
+          const isRecurring = isBaseGCalEvent(event);
+
           events.splice(eventIndex, 1);
 
+          if (isRecurring) {
+            // Also delete all instances of the recurring event
+            const instanceEvents = events.filter(isInstanceGCalEvent);
+
+            instanceEvents.forEach((instance) => {
+              const index = events.findIndex((e) => e.id === instance.id);
+              if (index !== -1) {
+                events.splice(index, 1);
+              }
+            });
+          }
+
           return Promise.resolve({
             statusText: "OK",
             status: 204,
@@ -211,6 +257,7 @@ export const mockGcal = ({
           params.maxResults ?? pageSize,
           params.pageToken,
         );
+
         return {
           statusText: "OK",
           status: 200,
@@ -227,7 +274,9 @@ export const mockGcal = ({
 
           if (!baseEvent) throw new Error(`Event with id ${id} not found`);
 
-          const { instances } = mockRecurringGcalEvents({ ...baseEvent, id });
+          const instances = events.filter(
+            ({ recurringEventId }) => recurringEventId === id,
+          );
 
           const eventsPage = generatePaginatedGcalItems(
             instances,

packages/backend/src/event/classes/compass.event.generator.ts

@@ -0,0 +1,146 @@
+import { ClientSession, Filter, ObjectId, WithId } from "mongodb";
+import {
+  CompassEvent,
+  EventUpdateSchema,
+  Event_Core,
+  RecurringEventUpdateScope,
+  Schema_Event,
+} from "@core/types/event.types";
+import { parseCompassEventDate } from "@core/util/event/event.util";
+import mongoService from "@backend/common/services/mongo.service";
+import { CompassEventRRule } from "@backend/event/classes/compass.event.rrule";
+import { MapEvent } from "../../../../core/src/mappers/map.event";
+
+export class CompassEventFactory {
+  private static async findCompassEvent(
+    { eventId, userId: user }: Pick<CompassEvent, "userId" | "eventId">,
+    session?: ClientSession,
+    throwIfNotFound = true,
+  ): Promise<WithId<Omit<Schema_Event, "_id">> | null> {
+    const _id = new ObjectId(eventId);
+    const filter: Filter<Omit<Schema_Event, "_id">> = { _id, user };
+
+    const event = await mongoService.event.findOne(filter, { session });
+
+    if (throwIfNotFound && !event) {
+      throw new Error(`Compass event not found for id: ${eventId}`);
+    }
+
+    return event;
+  }
+
+  private static async findCompassBaseAndInstanceEvent(
+    event: Pick<CompassEvent, "userId" | "eventId">,
+    session?: ClientSession,
+  ): Promise<{
+    baseEvent: WithId<Omit<Schema_Event, "_id">>;
+    instanceEvent: WithId<Omit<Schema_Event, "_id">>;
+  }> {
+    const { userId } = event;
+
+    // get instance event or throw
+    const instanceEvent = await CompassEventFactory.findCompassEvent(
+      event,
+      session,
+    );
+
+    const baseEventId = instanceEvent!.recurrence!.eventId!.toString();
+
+    if (!baseEventId) throw new Error("event is not a recurring instance");
+
+    // get base event in series or throw
+    const baseEvent = await CompassEventFactory.findCompassEvent(
+      { userId, eventId: baseEventId },
+      session,
+    );
+
+    return { baseEvent: baseEvent!, instanceEvent: instanceEvent! };
+  }
+
+  private static async genThisAndFollowingEvents(
+    event: CompassEvent,
+    session?: ClientSession,
+  ): Promise<CompassEvent[]> {
+    const { baseEvent, instanceEvent } =
+      await CompassEventFactory.findCompassBaseAndInstanceEvent(event, session);
+
+    const rruleOldSeries = new CompassEventRRule(baseEvent, {
+      until: parseCompassEventDate(instanceEvent.startDate!)
+        .subtract(1, baseEvent.isAllDay ? "day" : "milliseconds")
+        .toDate(),
+    });
+
+    const baseEventId = baseEvent._id.toString();
+
+    const compassBaseEventWithUntil: CompassEvent = {
+      ...event,
+      eventId: baseEventId,
+      payload: { ...rruleOldSeries.base(), _id: baseEventId } as Event_Core,
+    };
+
+    const payload = EventUpdateSchema.parse(event.payload);
+
+    const rruleNewSeries = new CompassEventRRule({
+      ...MapEvent.removeIdentifyingData(instanceEvent),
+      ...payload,
+      _id: instanceEvent._id,
+    });
+
+    const newBase = rruleNewSeries.base();
+
+    // new series
+    const compassEvent: CompassEvent = {
+      ...event,
+      payload: { ...newBase, _id: newBase._id.toString() } as Event_Core,
+    };
+
+    return [compassBaseEventWithUntil, compassEvent];
+  }
+
+  private static async genAllEvents(
+    event: CompassEvent,
+    session?: ClientSession,
+  ): Promise<CompassEvent[]> {
+    const { baseEvent } =
+      await CompassEventFactory.findCompassBaseAndInstanceEvent(event, session);
+
+    const payload = EventUpdateSchema.parse(event.payload);
+    const eventId = baseEvent._id.toString();
+
+    const compassEvent: CompassEvent = {
+      ...event,
+      eventId,
+      payload: { ...baseEvent, ...payload, _id: eventId } as Event_Core,
+    };
+
+    return [compassEvent];
+  }
+
+  private static async genThisEvent(
+    event: CompassEvent,
+  ): Promise<CompassEvent[]> {
+    const { recurrence } = event.payload;
+    const hasRule = Array.isArray(recurrence?.rule);
+    const hasRecurringEvent = typeof recurrence?.eventId === "string";
+    const isExistingInstanceUpdate = !hasRule && hasRecurringEvent;
+
+    if (isExistingInstanceUpdate) delete event.payload.recurrence?.rule;
+
+    return Promise.resolve([event]);
+  }
+
+  static async generateEvents(
+    event: CompassEvent,
+    session?: ClientSession,
+  ): Promise<CompassEvent[]> {
+    switch (event.applyTo) {
+      case RecurringEventUpdateScope.ALL_EVENTS:
+        return CompassEventFactory.genAllEvents(event, session);
+      case RecurringEventUpdateScope.THIS_AND_FOLLOWING_EVENTS:
+        return CompassEventFactory.genThisAndFollowingEvents(event, session);
+      case RecurringEventUpdateScope.THIS_EVENT:
+      default:
+        return CompassEventFactory.genThisEvent(event);
+    }
+  }
+}