✨ Feat: add support for UPDATING INSTANCE and STANDALONE events (#366)

* ♻️ Refactor: rename mock gcal utils for clarity

* ♻️ Refactor: skip tracking standalone events in map during full import

Tracking them in the map was unnecessary, because were won't come back again in subsequent passes (because there's only one)

* ♻️ Refactor: move mock event untils inside @backend

* ✨ Feat: add support for UPDATING and INSTANCE

* ✨ Feat: setup the EventRepository

This is similar to the RecurringEventReposity, but is focused on operations that apply to regular events

* ✨ Feat: add support for UPSERTING a new or existing standalone event

Author: tyler-dane

packages/backend/src/__tests__/helpers/mock.events.init.ts

@@ -7,8 +7,8 @@ import {
   gSchema$EventBase,
   gSchema$EventInstance,
 } from "@core/types/gcal";
-import { isBase } from "@core/util/event.util";
 import { Collections } from "@backend/common/constants/collections";
+import { isBase } from "@backend/event/util/event.util";
 import { mockGcalEvents } from "../mocks.gcal/mocks.gcal/factories/gcal.event.factory";
 
 export interface State_AfterGcalImport {
@@ -30,7 +30,7 @@ export interface State_AfterGcalImport {
  */
 export const simulateDbAfterGcalImport = async (
   db: Db,
-  userId?: string,
+  userId: string,
 ): Promise<State_AfterGcalImport> => {
   const { gcalEvents, compassEvents } = mockGcalAndCompassEvents(userId);
   await db

packages/backend/src/__tests__/mocks.ccal/ccal.event.factory.ts

@@ -1,19 +1,39 @@
+import dayjs from "dayjs";
 import { ObjectId } from "mongodb";
 import { faker } from "@faker-js/faker/.";
 import { Origin, Priorities } from "@core/constants/core.constants";
 import {
+  Schema_Event,
   Schema_Event_Recur_Base,
   Schema_Event_Recur_Instance,
+  WithCompassId,
 } from "@core/types/event.types";
 
+export const createMockStandaloneEvent = (
+  overrides: Partial<Schema_Event> = {},
+): WithCompassId<Schema_Event> => {
+  const start = faker.date.future();
+  const end = dayjs(start).add(1, "hour");
+  return {
+    _id: new ObjectId().toString(),
+    title: faker.lorem.sentence(),
+    startDate: start.toISOString(),
+    endDate: end.toISOString(),
+    user: "test-user-id",
+    origin: Origin.COMPASS,
+    priority: Priorities.WORK,
+    ...overrides,
+  };
+};
+
 /**
  * Creates a base recurring event with default values that can be overridden.
  * @param overrides - The overrides for the mock base event.
  * @returns A base recurring event.
  */
 export const createMockBaseEvent = (
   overrides: Partial<Schema_Event_Recur_Base> = {},
-): Schema_Event_Recur_Base => {
+): WithCompassId<Schema_Event_Recur_Base> => {
   const now = new Date();
   return {
     _id: new ObjectId().toString(),
@@ -43,7 +63,7 @@ export const createMockBaseEvent = (
 export const createMockInstance = (
   baseEventId: string,
   overrides: Partial<Schema_Event_Recur_Instance> = {},
-): Schema_Event_Recur_Instance => {
+): WithCompassId<Schema_Event_Recur_Instance> => {
   const now = new Date();
   return {
     _id: new ObjectId().toString(),
@@ -76,8 +96,8 @@ export const createMockInstances = (
   baseEvent: Schema_Event_Recur_Base,
   count: number,
   overrides: Partial<Schema_Event_Recur_Instance> = {},
-): Schema_Event_Recur_Instance[] => {
-  const instances: Schema_Event_Recur_Instance[] = [];
+): WithCompassId<Schema_Event_Recur_Instance>[] => {
+  const instances: WithCompassId<Schema_Event_Recur_Instance>[] = [];
   const baseDate = new Date(baseEvent.startDate || "2024-03-20T10:00:00Z");
 
   for (let i = 0; i < count; i++) {

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

@@ -1,22 +1,22 @@
 import { gSchema$EventBase } from "@core/types/gcal";
 import {
-  mockRecurringBaseEvent,
-  mockRecurringInstances,
+  mockRecurringGcalBaseEvent,
+  mockRecurringGcalInstances,
   mockRegularGcalEvent,
 } from "./gcal.event.factory";
 
 /* Sets of events, pre-organized as a convenience for testing */
 
 export const mockGcalEvents = () => {
   // Create a base recurring event
-  const baseRecurringEvent = mockRecurringBaseEvent({
+  const baseRecurringEvent = mockRecurringGcalBaseEvent({
     id: "recurring-1",
     summary: "Recurrence",
     recurrence: ["RRULE:FREQ=WEEKLY"],
   }) as gSchema$EventBase;
 
   // Create instances of the recurring event
-  const instances = mockRecurringInstances(baseRecurringEvent, 2, 7);
+  const instances = mockRecurringGcalInstances(baseRecurringEvent, 2, 7);
 
   // Create a regular event
   const regularEvent = mockRegularGcalEvent({

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

@@ -1,40 +1,40 @@
 import { gSchema$EventInstance } from "@core/types/gcal";
 import {
-  mockRecurringBaseEvent,
-  mockRecurringInstances,
+  mockRecurringGcalBaseEvent,
+  mockRecurringGcalInstances,
 } from "./gcal.event.factory";
 
 describe("mockRecurringInstances", () => {
   it("should not include 'recurrence'", () => {
-    const base = mockRecurringBaseEvent();
-    const instances = mockRecurringInstances(base, 2, 7);
+    const base = mockRecurringGcalBaseEvent();
+    const instances = mockRecurringGcalInstances(base, 2, 7);
     instances.forEach((instance) => {
       expect(instance).not.toHaveProperty("recurrence");
     });
   });
   it("should create the correct number of instances", () => {
-    const base = mockRecurringBaseEvent();
-    const instances = mockRecurringInstances(base, 2, 7);
+    const base = mockRecurringGcalBaseEvent();
+    const instances = mockRecurringGcalInstances(base, 2, 7);
     expect(instances).toHaveLength(2);
   });
   it("should include 'recurringEventId' that points to the base event", () => {
-    const base = mockRecurringBaseEvent();
-    const instances = mockRecurringInstances(base, 2, 7);
+    const base = mockRecurringGcalBaseEvent();
+    const instances = mockRecurringGcalInstances(base, 2, 7);
     instances.forEach((instance) => {
       expect(instance.recurringEventId).toBe(base.id);
     });
   });
   it("should make the first instance start and end at the same time as the base event", () => {
-    const base = mockRecurringBaseEvent();
-    const instances = mockRecurringInstances(base, 2, 7);
+    const base = mockRecurringGcalBaseEvent();
+    const instances = mockRecurringGcalInstances(base, 2, 7);
     const firstInstance = instances[0] as gSchema$EventInstance;
 
     expect(firstInstance.start?.dateTime).toBe(base.start?.dateTime);
     expect(firstInstance.end?.dateTime).toBe(base.end?.dateTime);
   });
   it("should make instances start and end in the future from the base time (except for the first one)", () => {
-    const base = mockRecurringBaseEvent();
-    const instances = mockRecurringInstances(base, 2, 7);
+    const base = mockRecurringGcalBaseEvent();
+    const instances = mockRecurringGcalInstances(base, 2, 7);
     const baseStart = new Date(base.start?.dateTime as string);
     instances.forEach((instance, index) => {
       if (index === 0) return; // first instance is the same as the base

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

@@ -7,38 +7,34 @@ import {
   gSchema$EventInstance,
 } from "@core/types/gcal";
 
-export const mockRegularEvent = (): WithGcalId<gSchema$Event> => ({
-  id: faker.string.nanoid(),
-  summary: faker.lorem.sentence(),
-  start: { dateTime: faker.date.future().toISOString() },
-  end: { dateTime: faker.date.future().toISOString() },
-  status: "confirmed",
-});
-
 /**
  * Returns a base event and its instances
  * @param count - The number of instances to create
  * @param repeatIntervalInDays - The interval between instances
  * @returns An array containing the base event and its instances
  */
-export const mockRecurringEvents = (
+export const mockRecurringGcalEvents = (
   count: number,
   repeatIntervalInDays: number,
 ): (gSchema$EventBase | gSchema$EventInstance)[] => {
-  const base = mockRecurringBaseEvent();
-  const instances = mockRecurringInstances(base, count, repeatIntervalInDays);
+  const base = mockRecurringGcalBaseEvent();
+  const instances = mockRecurringGcalInstances(
+    base,
+    count,
+    repeatIntervalInDays,
+  );
   return [base, ...instances];
 };
 
-export const mockRecurringBaseEvent = (
+export const mockRecurringGcalBaseEvent = (
   overrides: Partial<gSchema$EventBase> = {},
 ): gSchema$EventBase => ({
-  ...mockRegularEvent(),
+  ...mockRegularGcalEvent(),
   recurrence: ["RRULE:FREQ=WEEKLY"],
   ...overrides,
 });
 
-export const mockRecurringInstances = (
+export const mockRecurringGcalInstances = (
   base: gSchema$EventBase,
   count: number,
   repeatIntervalInDays: number,
@@ -90,9 +86,10 @@ export const mockRecurringInstances = (
 };
 
 export const mockRegularGcalEvent = (
-  overrides: Partial<gSchema$Event> = {},
-): gSchema$Event => {
-  const id = faker.string.uuid();
+  overrides: Partial<WithGcalId<gSchema$Event>> = {},
+): WithGcalId<gSchema$Event> => {
+  const id = faker.string.nanoid();
+  const tz = faker.location.timeZone();
   return {
     id,
     summary: faker.lorem.sentence(),
@@ -102,11 +99,11 @@ export const mockRegularGcalEvent = (
     updated: faker.date.recent().toISOString(),
     start: {
       dateTime: faker.date.future().toISOString(),
-      timeZone: "America/Chicago",
+      timeZone: tz,
     },
     end: {
       dateTime: faker.date.future().toISOString(),
-      timeZone: "America/Chicago",
+      timeZone: tz,
     },
     iCalUID: faker.string.uuid() + "@google.com",
     sequence: 0,

packages/backend/src/event/services/event.find.test.ts

@@ -1,17 +1,17 @@
 import { Collection, Db, MongoClient } from "mongodb";
 import { MapEvent } from "@core/mappers/map.event";
 import { Schema_Event } from "@core/types/event.types";
-import { isBase, isExistingInstance } from "@core/util/event.util";
 import {
-  mockRecurringBaseEvent,
-  mockRecurringInstances,
+  mockRecurringGcalBaseEvent,
+  mockRecurringGcalInstances,
 } from "@backend/__tests__/mocks.gcal/factories/gcal.event.factory";
 import { mockEventSetJan22 } from "../../../../core/src/__mocks__/events/events.22jan";
 import { mockEventSetSomeday1 } from "../../../../core/src/__mocks__/events/events.someday.1";
+import { isBase, isExistingInstance } from "../util/event.util";
 import { getReadAllFilter } from "./event.service.util";
 
-const gBase = mockRecurringBaseEvent();
-const gInstances = mockRecurringInstances(gBase, 10, 7);
+const gBase = mockRecurringGcalBaseEvent();
+const gInstances = mockRecurringGcalInstances(gBase, 10, 7);
 
 const base = MapEvent.toCompass("user1", [gBase])[0];
 const instances = MapEvent.toCompass("user1", gInstances);

packages/backend/src/event/services/recur/repo/event.repo.ts

@@ -0,0 +1,32 @@
+/**
+ * Event DB operations repo for Compass's Event collection
+ */
+import { ObjectId } from "mongodb";
+import { Event_Core } from "@core/types/event.types";
+import { Collections } from "@backend/common/constants/collections";
+import mongoService from "@backend/common/services/mongo.service";
+import { Ids_Event } from "@backend/event/queries/event.queries";
+
+export class EventRepository {
+  constructor(private userId: string) {}
+
+  /**
+   * Update an event, creating it if it doesn't exist
+   */
+  async updateById(key: Ids_Event, event: Event_Core) {
+    const _id = event?._id ? new ObjectId(event._id) : new ObjectId();
+    if (!event?._id) {
+      console.log("upserting event with new id:", _id);
+    } else {
+      console.log("upserting event with existing id:", event._id);
+    }
+    const result = await mongoService.db
+      .collection(Collections.EVENT)
+      .updateOne(
+        { [key]: event[key], user: this.userId },
+        { $set: event },
+        { upsert: true },
+      );
+    return result;
+  }
+}

packages/backend/src/event/services/recur/repo/recur.event.repo.ts

@@ -1,4 +1,5 @@
 import { ObjectId } from "mongodb";
+import { Event_Core } from "@core/types/event.types";
 import { Collections } from "@backend/common/constants/collections";
 import mongoService from "@backend/common/services/mongo.service";
 import { Ids_Event } from "../../../queries/event.queries";
@@ -50,4 +51,21 @@ export class RecurringEventRepository {
       });
     return result;
   }
+
+  /**
+   * Update an instance by its gEventId
+   * @param updatedInstance - The updated instance
+   * @returns The result of the update operation
+   */
+  async updateInstance(updatedInstance: Event_Core) {
+    const gEventId = updatedInstance.gEventId;
+
+    const result = await mongoService.db
+      .collection(Collections.EVENT)
+      .updateOne(
+        { gEventId: gEventId, user: this.userId },
+        { $set: updatedInstance },
+      );
+    return result;
+  }
 }

packages/backend/src/event/util/event.util.test.ts

@@ -0,0 +1,21 @@
+import {
+  createMockInstance,
+  createMockStandaloneEvent,
+} from "@backend/__tests__/mocks.ccal/ccal.event.factory";
+import { createMockBaseEvent } from "@backend/__tests__/mocks.ccal/ccal.event.factory";
+import { categorizeEvents } from "./event.util";
+
+describe("categorizeEvents", () => {
+  it("should categorize events correctly", () => {
+    const standalone = createMockStandaloneEvent();
+    const base = createMockBaseEvent();
+    const instance = createMockInstance(base._id);
+    const events = [base, instance, standalone];
+
+    const { baseEvents, instances, regularEvents } = categorizeEvents(events);
+
+    expect(baseEvents).toEqual([base]);
+    expect(instances).toEqual([instance]);
+    expect(regularEvents).toEqual([standalone]);
+  });
+});

packages/core/src/util/event.util.ts …ges/backend/src/event/util/event.util.tspackages/core/src/util/event.util.ts renamed to packages/backend/src/event/util/event.util.ts packages/core/src/util/event.util.ts renamed to packages/backend/src/event/util/event.util.ts

@@ -6,6 +6,15 @@ import {
 } from "@core/types/event.types";
 import { gSchema$Event } from "@core/types/gcal";
 
+export const categorizeEvents = (events: Schema_Event[]) => {
+  const baseEvents = events.filter(isBase);
+  const instances = events.filter(isExistingInstance);
+  const regularEvents = events.filter(
+    (e) => !isBase(e) && !isExistingInstance(e),
+  );
+  return { baseEvents, instances, regularEvents };
+};
+
 export const categorizeRecurringEvents = (events: Recurrence[]) => {
   const baseEvent = events.find(isBase) as Schema_Event_Recur_Base;
   const instances = events.filter(