✨ feat(edit-recurrence): WIP

Author: victor-enogwe

packages/backend/src/event/classes/compass.event.parser.test.ts

@@ -0,0 +1,243 @@
+import { ClientSession, ObjectId, WithId } from "mongodb";
+import { Logger } from "@core/logger/winston.logger";
+import {
+  CalendarProvider,
+  Categories_Recurrence,
+  CompassEvent,
+  Schema_Event,
+  Schema_Event_Core,
+  TransitionCategoriesRecurrence,
+  TransitionStatus,
+} from "@core/types/event.types";
+import { gSchema$Event } from "@core/types/gcal";
+import {
+  isBase,
+  isInstance,
+  isRegularEvent,
+} from "@core/util/event/event.util";
+import { GenericError } from "@backend/common/errors/generic/generic.errors";
+import { error } from "@backend/common/errors/handlers/error.handler";
+import mongoService from "@backend/common/services/mongo.service";
+import { CompassEventRRule } from "@backend/event/classes/compass.event.rrule";
+import {
+  _createGcalEvent,
+  _updateGcal,
+} from "@backend/event/services/event.service";
+import { Event_Transition, Operation_Sync } from "@backend/sync/sync.types";
+
+export class CompassEventParser {
+  #logger = Logger("app.event.classes.compass.event.parser");
+  #_event: CompassEvent;
+  #event!: WithId<Omit<Schema_Event, "_id">>;
+  #title!: string;
+  #dbEvent!: WithId<Omit<Schema_Event, "_id">> | null;
+  #isInstance!: boolean;
+  #isBase!: boolean;
+  #isStandalone!: boolean;
+  #isDbInstance!: boolean;
+  #isDbBase!: boolean;
+  #isDbStandalone!: boolean;
+  #rrule!: CompassEventRRule | null;
+  #dbRrule!: CompassEventRRule | null;
+  #transition!: Event_Transition["transition"];
+  #summary!: Omit<Event_Transition, "operation">;
+
+  constructor(event: CompassEvent) {
+    this.#_event = event;
+
+    this.#event = {
+      ...event.payload,
+      _id: new ObjectId(event.eventId ?? event.payload._id),
+    };
+  }
+
+  get isInstance(): boolean {
+    return this.#ensureInitInvoked(this.#isInstance);
+  }
+
+  get isBase(): boolean {
+    return this.#ensureInitInvoked(this.#isBase);
+  }
+
+  get isStandalone(): boolean {
+    return this.#ensureInitInvoked(this.#isStandalone);
+  }
+
+  get isDbInstance(): boolean {
+    return this.#ensureInitInvoked(this.#isDbInstance);
+  }
+
+  get isDbBase(): boolean {
+    return this.#ensureInitInvoked(this.#isDbBase);
+  }
+
+  get isDbStandalone(): boolean {
+    return this.#ensureInitInvoked(this.#isDbStandalone);
+  }
+
+  get rrule(): CompassEventRRule | null {
+    return this.#ensureInitInvoked(this.#rrule);
+  }
+
+  get dbRrule(): CompassEventRRule | null {
+    return this.#ensureInitInvoked(this.#dbRrule);
+  }
+
+  get transition(): Event_Transition["transition"] {
+    return this.#ensureInitInvoked(this.#transition);
+  }
+
+  get category(): Categories_Recurrence {
+    return this.#transition?.[0] ?? this.#getCategory();
+  }
+
+  get summary(): Omit<Event_Transition, "operation"> {
+    return this.#ensureInitInvoked(this.#summary);
+  }
+
+  getTransitionString(): `${Categories_Recurrence | "NIL"}->>${TransitionCategoriesRecurrence}` {
+    return `${this.#transition[0] ?? "NIL"}->>${this.#transition[1]}`;
+  }
+
+  /**
+   * init
+   *
+   * we need to fetch the compass event first to properly discriminate
+   * the event types since they can be ambiguous if interpreted from
+   * gcal sync watch  updates
+   */
+  async init(session?: ClientSession): Promise<void> {
+    if (this.#dbEvent === null || !!this.#dbEvent) return;
+
+    this.#title = this.#event.title ?? this.#_event.eventId ?? "unknown";
+
+    const status: TransitionStatus = this.#_event.status;
+    const filter = this.getBaseEventFilter();
+
+    const cEvent = await mongoService.event.findOne(filter, { session });
+
+    this.#dbEvent = cEvent ?? null;
+
+    this.#isInstance = isInstance(this.#event);
+    this.#isDbInstance = cEvent ? isInstance(cEvent) : false;
+
+    this.#isBase = isBase(this.#event);
+    this.#isDbBase = cEvent ? isBase(cEvent) : false;
+
+    this.#isStandalone = isRegularEvent(this.#event);
+    this.#isDbStandalone = cEvent ? isRegularEvent(cEvent) : false;
+
+    this.#rrule = this.#isBase ? new CompassEventRRule(this.#event) : null;
+
+    this.#dbRrule = this.#isDbBase
+      ? new CompassEventRRule(this.#dbEvent!)
+      : null;
+
+    this.#transition = [
+      this.#getDbCategory(),
+      `${this.#getCategory()}_${status}`,
+    ];
+
+    this.#summary = {
+      title: this.#title,
+      transition: this.#transition,
+      category: this.category,
+    };
+  }
+
+  private getBaseEventFilter(): { _id: ObjectId; user: string } {
+    const _id = this.#event._id;
+    const user = this.#event.user ?? this.#_event.userId;
+
+    return { _id, user };
+  }
+
+  async createEvent(operation: Operation_Sync): Promise<Event_Transition[]> {
+    this.#logger.info(
+      `CREATING ${this.getTransitionString()}: ${this.#event._id} (Compass)`,
+    );
+    // create series in calendar providers
+    const calendarProvider = CalendarProvider.GOOGLE;
+    const userId = this.getBaseEventFilter().user;
+    const baseEvent = this.rrule!.base() as unknown as Schema_Event_Core;
+
+    switch (calendarProvider) {
+      case CalendarProvider.GOOGLE: {
+        const event = await _createGcalEvent(userId, baseEvent);
+
+        return event ? [this.#getOperationSummary(operation)] : [];
+      }
+      default:
+        return [];
+    }
+  }
+
+  async updateEvent(
+    operation: Operation_Sync,
+    extras?: Pick<gSchema$Event, "status" | "recurrence">,
+  ): Promise<Event_Transition[]> {
+    this.#logger.info(
+      `UPDATING ${this.getTransitionString()}: ${this.#event._id} (Compass)`,
+    );
+
+    const calendarProvider = CalendarProvider.GOOGLE;
+    const userId = this.getBaseEventFilter().user;
+    const baseEvent = this.rrule!.base() as unknown as Schema_Event_Core;
+
+    switch (calendarProvider) {
+      case CalendarProvider.GOOGLE: {
+        const event = await _updateGcal(userId, baseEvent, extras);
+
+        return event ? [this.#getOperationSummary(operation)] : [];
+      }
+      default:
+        return [];
+    }
+  }
+
+  async deleteEvent(operation: Operation_Sync): Promise<Event_Transition[]> {
+    this.#logger.info(
+      `DELETING ${this.getTransitionString()}: ${this.#event._id} (Compass)`,
+    );
+
+    return this.updateEvent(operation, { status: "cancelled" });
+  }
+
+  #getCategory(): Categories_Recurrence {
+    switch (true) {
+      case this.isStandalone:
+        return Categories_Recurrence.STANDALONE;
+      case this.isBase:
+        return Categories_Recurrence.RECURRENCE_BASE;
+      case this.isInstance:
+        return Categories_Recurrence.RECURRENCE_INSTANCE;
+      default:
+        throw new Error("could not determine event category");
+    }
+  }
+
+  #getDbCategory(): Categories_Recurrence | null {
+    switch (true) {
+      case this.#isDbStandalone:
+        return Categories_Recurrence.STANDALONE;
+      case this.#isDbBase:
+        return Categories_Recurrence.RECURRENCE_BASE;
+      case this.#isDbInstance:
+        return Categories_Recurrence.RECURRENCE_INSTANCE;
+      default:
+        return null;
+    }
+  }
+
+  #getOperationSummary(operation: Operation_Sync): Event_Transition {
+    return this.#ensureInitInvoked({ ...this.summary, operation });
+  }
+
+  #ensureInitInvoked<T = unknown>(value: T) {
+    if (this.#dbEvent === undefined) {
+      throw error(GenericError.DeveloperError, "did you call `init` yet");
+    }
+
+    return value;
+  }
+}

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

@@ -79,7 +79,9 @@ export class CompassEventRRule extends RRule {
    * @description Returns all instances of the event based on the recurrence rule.
    * @note **This is a test-only method for now, it is not to be used in production.**
    */
-  instances(): WithId<Omit<Schema_Event_Recur_Instance, "_id">>[] {
+  instances(
+    baseEventId?: string,
+  ): WithId<Omit<Schema_Event_Recur_Instance, "_id">>[] {
     return this.all().map((date) => {
       const timezone = dayjs.tz.guess();
       const startDate = dayjs(date).tz(timezone);
@@ -92,7 +94,7 @@ export class CompassEventRRule extends RRule {
         _id: new ObjectId(),
         startDate: startDate.format(this.#dateFormat),
         endDate: endDate.format(this.#dateFormat),
-        recurrence: { eventId: this.base()._id.toString() },
+        recurrence: { eventId: baseEventId ?? this.base()._id.toString() },
       };
     });
   }