🐛 fix(duplicate-event): fix event duplication - web (#1001)

Author: victor-enogwe

packages/core/src/mappers/map.event.ts

@@ -38,14 +38,20 @@ export namespace MapEvent {
 
   export const removeProviderData = (
     event: WithId<Omit<Schema_Event, "_id">> | Schema_Event,
-  ): Omit<Schema_Event, "_id" | "gEventId" | "gRecurringEventId"> => {
+  ): Omit<
+    WithId<Omit<Schema_Event, "_id">> | Schema_Event,
+    "gEventId" | "gRecurringEventId"
+  > => {
     const {
       gEventId, // eslint-disable-line @typescript-eslint/no-unused-vars
       gRecurringEventId, // eslint-disable-line @typescript-eslint/no-unused-vars
+      recurrence, // eslint-disable-line @typescript-eslint/no-unused-vars
       ...coreEvent
     } = event;
 
-    delete coreEvent.recurrence?.eventId;
+    if (event.recurrence?.rule) {
+      Object.assign(coreEvent, { recurrence: { rule: event.recurrence.rule } });
+    }
 
     return coreEvent;
   };

packages/core/src/types/event.types.ts

@@ -185,9 +185,7 @@ export const EventUpdateSchema = z.object({
   description: z.string().nullable().optional(),
   priority: z.nativeEnum(Priorities).optional(),
   recurrence: z.union([
-    CompassEventRecurrence.omit({ rule: true }).extend({
-      rule: z.null(),
-    }),
+    CompassEventRecurrence.extend({ rule: z.null() }),
     CompassEventRecurrence,
   ]),
   startDate: eventDateSchema.optional(),
@@ -196,15 +194,11 @@ export const EventUpdateSchema = z.object({
   isSomeday: z.boolean().optional(),
 });
 
-export const CompassCoreEventSchema = CoreEventSchema.omit({
-  recurrence: true,
-}).extend({
+export const CompassCoreEventSchema = CoreEventSchema.extend({
   _id: idSchema,
-  recurrence: CompassEventRecurrence.omit({ rule: true })
-    .extend({
-      rule: z.union([z.null(), z.array(z.string())]),
-    })
-    .optional(),
+  recurrence: CompassEventRecurrence.extend({
+    rule: z.union([z.null(), z.array(z.string())]),
+  }).optional(),
 });
 
 export const CompassCoreCalendarEventSchema = CompassCoreEventSchema.extend({
@@ -230,9 +224,7 @@ export const CompassThisEventSchema = BaseCompassEventSchema.merge(
         z.object({
           recurrence: z
             .union([
-              CompassEventRecurrence.omit({ rule: true }).extend({
-                rule: z.null(),
-              }),
+              CompassEventRecurrence.extend({ rule: z.null() }),
               CompassEventRecurrence,
             ])
             .optional(),
@@ -247,9 +239,7 @@ export const CompassThisAndFollowingEventSchema = BaseCompassEventSchema.merge(
     applyTo: z.literal(RecurringEventUpdateScope.THIS_AND_FOLLOWING_EVENTS),
     payload: CompassCoreEventSchema.merge(
       z.object({ recurrence: CompassEventRecurrence }),
-    )
-      .omit({ isSomeday: true })
-      .extend({ isSomeday: z.literal(false) }),
+    ).extend({ isSomeday: z.literal(false) }),
   }),
 );
 
@@ -258,9 +248,7 @@ export const CompassAllEventsSchema = BaseCompassEventSchema.merge(
     applyTo: z.literal(RecurringEventUpdateScope.ALL_EVENTS),
     payload: CompassCoreEventSchema.merge(
       z.object({ recurrence: CompassEventRecurrence }),
-    )
-      .omit({ isSomeday: true })
-      .extend({ isSomeday: z.literal(false) }),
+    ).extend({ isSomeday: z.literal(false) }),
   }),
 );
 

packages/web/src/common/types/web.event.types.ts

@@ -9,12 +9,6 @@ import {
 } from "@core/types/event.types";
 import { SelectOption } from "@web/common/types/component.types";
 
-export enum Recurrence_Selection {
-  NONE = "none",
-  WEEK = "week",
-  MONTH = "month",
-}
-
 export const optimisticIdSchema = z
   .string()
   .refine(
@@ -29,41 +23,37 @@ const WebEventRecurrence = z.union([
   CompassEventRecurrence,
 ]);
 
-const WebCoreEventSchema = CompassCoreEventSchema.omit({
-  recurrence: true,
-}).extend({
+const WebCoreEventSchema = CompassCoreEventSchema.extend({
+  _id: z.union([idSchema, optimisticIdSchema]),
   recurrence: WebEventRecurrence,
+  order: z.number().optional(),
 });
 
 export const GridEventSchema = WebCoreEventSchema.extend({
   hasFlipped: z.boolean().optional(),
   isOpen: z.boolean().optional(),
   row: z.number().optional(),
   order: z.number().optional(), // allow carry over from Someday events
+  position: z.object({
+    isOverlapping: z.boolean(),
+    widthMultiplier: z.number(), // EG: 0.5 for half width
+    horizontalOrder: z.number(),
+    dragOffset: z.object({ y: z.number() }),
+    initialX: z.number().nullable(),
+    initialY: z.number().nullable(),
+  }),
 });
 
 export const SomedayEventSchema = WebCoreEventSchema.extend({
-  _id: z.union([idSchema, optimisticIdSchema]),
   isSomeday: z.literal(true),
   order: z.number(),
 });
 
 export type Schema_WebEvent = z.infer<typeof WebCoreEventSchema>;
+
 export type Schema_SomedayEvent = z.infer<typeof SomedayEventSchema>;
 
-export interface Schema_GridEvent extends Schema_Event {
-  hasFlipped?: boolean;
-  isOpen?: boolean;
-  row?: number;
-  position: {
-    isOverlapping: boolean;
-    widthMultiplier: number; // EG: 0.5 for half width
-    horizontalOrder: number;
-    dragOffset: { y: number };
-    initialX: number | null;
-    initialY: number | null;
-  };
-}
+export type Schema_GridEvent = z.infer<typeof GridEventSchema>;
 
 export interface Schema_OptimisticEvent extends Schema_GridEvent {
   _id: string; // We guarantee that we have an _id for optimistic events, unlike `Schema_Event`

packages/web/src/common/utils/event.util.ts

@@ -7,17 +7,22 @@ import {
 } from "@core/constants/core.constants";
 import { YEAR_MONTH_DAY_COMPACT_FORMAT } from "@core/constants/date.constants";
 import { Status } from "@core/errors/status.codes";
-import { Categories_Event, Schema_Event } from "@core/types/event.types";
+import {
+  Categories_Event,
+  Schema_Event,
+  Schema_Event_Recur_Base,
+} from "@core/types/event.types";
 import dayjs, { Dayjs } from "@core/util/date/dayjs";
-import { validateEvent } from "@core/validators/event.validator";
 import { getUserId } from "@web/auth/auth.util";
 import { DATA_EVENT_ELEMENT_ID } from "@web/common/constants/web.constants";
 import { PartialMouseEvent } from "@web/common/types/util.types";
 import {
   Schema_GridEvent,
   Schema_OptimisticEvent,
+  Schema_WebEvent,
 } from "@web/common/types/web.event.types";
 import { validateSomedayEvent } from "@web/common/validators/someday.event.validator";
+import { validateGridEvent } from "../validators/grid.event.validator";
 
 const gridEventDefaultPosition = {
   isOverlapping: false,
@@ -63,11 +68,17 @@ export const assembleDefaultEvent = async (
     case Categories_Event.TIMED: {
       const defaultTimed: Schema_GridEvent = {
         ...baseEvent,
+        _id: baseEvent._id!,
         isAllDay: false,
         isSomeday: false,
-        startDate,
-        endDate,
+        startDate: startDate!,
+        endDate: endDate!,
         position: gridEventDefaultPosition,
+        origin: baseEvent.origin ?? Origin.COMPASS,
+        priority: baseEvent.priority ?? Priorities.UNASSIGNED,
+        user: baseEvent.user!,
+        recurrence:
+          baseEvent.recurrence as Schema_Event_Recur_Base["recurrence"],
       };
       return defaultTimed;
     }
@@ -77,10 +88,18 @@ export const assembleDefaultEvent = async (
 };
 
 export const assembleGridEvent = (event: Schema_Event): Schema_GridEvent => {
-  const gridEvent = {
+  const gridEvent: Schema_GridEvent = {
     ...event,
     position: gridEventDefaultPosition,
+    _id: event._id!,
+    startDate: event.startDate!,
+    endDate: event.endDate!,
+    origin: event.origin ?? Origin.COMPASS,
+    priority: event.priority ?? Priorities.UNASSIGNED,
+    user: event.user!,
+    recurrence: event.recurrence as Schema_Event_Recur_Base["recurrence"],
   };
+
   return gridEvent;
 };
 
@@ -188,27 +207,36 @@ export const prepEvtBeforeSubmit = (
   draft: Schema_Event | Schema_GridEvent,
   userId: string,
 ) => {
-  const _event = {
+  const _event: Omit<Schema_Event | Schema_GridEvent, "recurrence"> = {
     ...draft,
     origin: Origin.COMPASS,
     user: userId,
   };
 
-  const event = validateEvent(_event);
+  if (draft.recurrence) Object.assign(_event, { recurrence: draft.recurrence });
+
+  const event = validateGridEvent(_event);
   return event;
 };
 
 export const prepSomedayEventBeforeSubmit = (
   draft: Schema_Event | Schema_GridEvent,
   userId: string,
 ) => {
-  const _event = {
+  const _event: Omit<Schema_WebEvent, "recurrence"> = {
     ...draft,
     origin: Origin.COMPASS,
     user: userId,
+    _id: draft._id!,
+    startDate: draft.startDate!,
+    endDate: draft.endDate!,
+    priority: draft.priority ?? Priorities.UNASSIGNED,
   };
 
+  if (draft.recurrence) Object.assign(_event, { recurrence: draft.recurrence });
+
   const event = validateSomedayEvent(_event);
+
   return event;
 };
 
@@ -229,8 +257,8 @@ const _assembleBaseEvent = (
 ): Schema_Event => {
   const baseEvent = {
     _id: event._id,
-    title: event.title || "",
-    description: event.description || "",
+    title: event.title ?? "",
+    description: event.description ?? "",
     startDate: event.startDate,
     endDate: event.endDate,
     user: userId,

packages/web/src/common/utils/web.date.util.ts

@@ -1,5 +1,4 @@
 import dayjs, { Dayjs } from "dayjs";
-import { RRULE } from "@core/constants/core.constants";
 import {
   HOURS_AM_FORMAT,
   HOURS_AM_SHORT_FORMAT,
@@ -13,10 +12,7 @@ import { GRID_TIME_STEP } from "@web/views/Calendar/layout.constants";
 import { roundToNext } from ".";
 import { ACCEPTED_TIMES } from "../constants/web.constants";
 import { theme } from "../styles/theme";
-import {
-  Recurrence_Selection,
-  Schema_SelectedDates,
-} from "../types/web.event.types";
+import { Schema_SelectedDates } from "../types/web.event.types";
 
 export const dateIsValid = (date: string) => {
   const notNaN = !Number.isNaN(new Date(date).getTime());
@@ -121,19 +117,6 @@ export const getNextIntervalTimes = () => {
   return { startDate, endDate };
 };
 
-export const getRecurrenceRule = (selection: Recurrence_Selection) => {
-  switch (selection) {
-    case Recurrence_Selection.WEEK:
-      return [RRULE.WEEK];
-      break;
-    case Recurrence_Selection.MONTH:
-      return [RRULE.MONTH];
-      break;
-    default:
-      throw Error("Invalid selection");
-  }
-};
-
 export const getTimeLabel = (value: string) => value.replace(":00", "");
 
 export const getTimeOptionByValue = (date: Dayjs): Option_Time => {

packages/web/src/common/validators/grid.event.validator.test.ts

@@ -13,13 +13,22 @@ describe("validateGridEvent", () => {
       priority: Priorities.RELATIONS,
       user: "user123",
       unexpectedProperty: "unexpectedValue",
+      position: {
+        dragOffset: { y: 0 },
+        horizontalOrder: 0,
+        initialX: 0,
+        initialY: 0,
+        isOverlapping: false,
+        widthMultiplier: 1,
+      },
     };
 
     const parsedEvent = validateGridEvent(event);
     expect(parsedEvent).not.toHaveProperty("unexpectedProperty");
   });
+
   it("validates a correct event", () => {
-    const event: Schema_GridEvent = {
+    const event: Omit<Schema_GridEvent, "recurrence"> = {
       _id: new ObjectId().toString(),
       endDate: "2023-01-02",
       hasFlipped: true,
@@ -29,21 +38,37 @@ describe("validateGridEvent", () => {
       origin: Origin.COMPASS,
       priority: Priorities.RELATIONS,
       user: "user123",
+      position: {
+        dragOffset: { y: 0 },
+        horizontalOrder: 0,
+        initialX: 0,
+        initialY: 0,
+        isOverlapping: false,
+        widthMultiplier: 1,
+      },
     };
 
     const parsedEvent = validateGridEvent(event);
     expect(parsedEvent).toEqual(event);
   });
 
   it("invalidates when types are incorrect", () => {
-    const event = {
+    const event: Omit<Partial<Schema_GridEvent>, "recurrence"> = {
       startDate: "2022-10-22",
       endDate: "2023-01-02",
       origin: Origin.UNSURE,
       priority: Priorities.SELF,
       user: "user1",
-      hasFlipped: "true", // invalid
-    } as unknown as Schema_GridEvent;
+      hasFlipped: "true" as unknown as boolean, // invalid
+      position: {
+        dragOffset: { y: 0 },
+        horizontalOrder: 0,
+        initialX: 0,
+        initialY: 0,
+        isOverlapping: false,
+        widthMultiplier: 1,
+      },
+    };
 
     expect(() => validateGridEvent(event)).toThrow();
   });