:bug fix(someday-events): event categorization - weekly recurrence in month 1087 (#1095)

Author: victor-enogwe

packages/core/package.json

@@ -7,11 +7,13 @@
   "main": "",
   "devDependencies": {
     "@faker-js/faker": "^9.6.0",
+    "@types/lodash.uniqby": "^4.7.9",
     "@types/tinycolor2": "^1.4.6",
     "typescript": "^5.1.6"
   },
   "dependencies": {
     "bson": "^6.10.4",
+    "lodash.uniqby": "^4.7.0",
     "tinycolor2": "^1.6.0",
     "winston": "^3.8.1",
     "zod": "^3.25.76"

packages/core/src/util/test/ccal.event.factory.ts

@@ -10,6 +10,7 @@ import {
 } from "@core/types/event.types";
 import dayjs from "@core/util/date/dayjs";
 import { isAllDay, parseCompassEventDate } from "@core/util/event/event.util";
+import { CompassEventRRule } from "../event/compass.event.rrule";
 
 export const createMockStandaloneEvent = (
   overrides: Partial<Omit<Schema_Event, "endDate">> = {},
@@ -117,23 +118,12 @@ export const createMockInstances = (
   count: number,
   overrides: Partial<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");
+  const _id = new ObjectId(baseEvent._id);
+  const rrule = new CompassEventRRule({ ...baseEvent, _id }, { count });
 
-  for (let i = 0; i < count; i++) {
-    const instanceDate = new Date(baseDate);
-    instanceDate.setDate(instanceDate.getDate() + (i + 1) * 7); // Weekly recurrence
-
-    instances.push(
-      createMockInstance(baseEvent._id || "", baseEvent.gEventId as string, {
-        startDate: instanceDate.toISOString(),
-        endDate: new Date(instanceDate.getTime() + 3600000).toISOString(), // 1 hour later
-        ...overrides,
-      }),
-    );
-  }
-
-  return instances;
+  return rrule
+    .instances()
+    .map((i) => ({ ...i, ...overrides, _id: i._id.toString() }));
 };
 
 export const generateCompassEventDates = ({

packages/scripts/package.json

@@ -10,13 +10,11 @@
     "commander": "^10.0.0",
     "dotenv": "^16.0.1",
     "inquirer": "^8.0.0",
-    "lodash.uniqby": "^4.7.0",
     "shelljs": "^0.8.5",
     "umzug": "^3.8.2"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.1",
-    "@types/lodash.uniqby": "^4.7.9",
     "@types/node": "^24.7.2",
     "@types/shelljs": "^0.8.15",
     "ts-node-dev": "^2.0.0",

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

@@ -1,13 +1,23 @@
 import { ObjectId } from "bson";
+import { faker } from "@faker-js/faker";
 import {
   ID_OPTIMISTIC_PREFIX,
   Origin,
   Priorities,
+  RRULE,
+  RRULE_COUNT_WEEKS,
 } from "@core/constants/core.constants";
 import { Schema_Event } from "@core/types/event.types";
 import dayjs from "@core/util/date/dayjs";
+import {
+  createMockBaseEvent,
+  createMockInstances,
+} from "@core/util/test/ccal.event.factory";
 import { COLUMN_MONTH, COLUMN_WEEK } from "@web/common/constants/web.constants";
-import { Schema_SomedayEvent } from "@web/common/types/web.event.types";
+import {
+  Schema_SomedayEvent,
+  Schema_SomedayEventsColumn,
+} from "@web/common/types/web.event.types";
 import {
   categorizeSomedayEvents,
   setSomedayEventsOrder,
@@ -28,10 +38,8 @@ describe("categorizeSomedayEvents", () => {
     endDate: "2024-03-20",
   };
 
-  const weekDates = {
-    start: dayjs("2024-03-17"),
-    end: dayjs("2024-03-23"),
-  };
+  const startOfWeek = dayjs("2024-03-17").startOf("week");
+  const weekDates = { start: startOfWeek, end: startOfWeek.endOf("week") };
 
   describe("Week vs Month categorization", () => {
     it("should categorize event within current week to week column", () => {
@@ -97,13 +105,13 @@ describe("categorizeSomedayEvents", () => {
           ...baseEvent,
           _id: _idA,
           startDate: "2024-03-17",
-          endDate: "2024-03-23",
+          endDate: "2024-03-17",
         },
         [_idB]: {
           ...baseEvent,
           _id: _idB,
           startDate: "2024-03-01",
-          endDate: "2024-03-31",
+          endDate: "2024-03-01",
         },
       };
 
@@ -471,5 +479,39 @@ describe("computeRelativeEventDateRange", () => {
         { ...events[2], order: 3 },
       ]);
     });
+
+    // Recurrence deduplication tests
+    it("should not duplicate a recurring event into the month column when a week occurrence exists", () => {
+      const isSomeday = true;
+      const referenceDate = dayjs(faker.date.anytime());
+      const startDate = referenceDate.toRFC3339OffsetString();
+      const week = faker.number.int({ min: 0, max: RRULE_COUNT_WEEKS - 1 });
+      const startOfWeek = referenceDate.startOf("week").add(week, "weeks");
+      const endOfWeek = startOfWeek.endOf("week");
+      const weekDates = { start: startOfWeek, end: endOfWeek };
+      const recurrence = { rule: [RRULE.WEEK] };
+      const base = createMockBaseEvent({ recurrence, startDate, isSomeday });
+      const instances = createMockInstances(base, RRULE_COUNT_WEEKS, {
+        isSomeday,
+        order: 0,
+      });
+
+      const events: Schema_SomedayEventsColumn["events"] = instances.reduce(
+        (acc, instance) => ({
+          ...acc,
+          [instance._id]: {
+            ...instance,
+            recurrence: { ...recurrence, ...instance.recurrence },
+          },
+        }),
+        {},
+      );
+
+      const result = categorizeSomedayEvents(events, weekDates);
+      const weekOccurrenceId = instances[week]._id;
+
+      expect(result.columns[COLUMN_MONTH].eventIds).toHaveLength(0);
+      expect(result.columns[COLUMN_WEEK].eventIds).toContain(weekOccurrenceId);
+    });
   });
 });

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

@@ -1,4 +1,4 @@
-import { RRULE } from "@core/constants/core.constants";
+import uniqby from "lodash.uniqby";
 import { Categories_Event, Schema_Event } from "@core/types/event.types";
 import dayjs, { Dayjs } from "@core/util/date/dayjs";
 import {
@@ -32,63 +32,63 @@ export const getSomedayEventCategory = (
   return Categories_Event.SOMEDAY_WEEK;
 };
 
+export function eventsBetweenDates(
+  events: Schema_SomedayEvent[],
+  start: Dayjs,
+  end: Dayjs,
+): Schema_SomedayEvent[] {
+  return events.filter((event) => {
+    return dayjs(event.startDate).isBetween(start, end, null, "[]");
+  });
+}
+
 export const categorizeSomedayEvents = (
-  somedayEvents: Schema_SomedayEventsColumn["events"],
+  events: Schema_SomedayEventsColumn["events"],
   weekDates: { start: Dayjs; end: Dayjs },
 ): Schema_SomedayEventsColumn => {
   const { start: weekStart, end: weekEnd } = weekDates;
-
-  let events = Object.values(somedayEvents) as Schema_SomedayEvent[];
-
-  events = validateSomedayEvents(events);
-
-  const sortedEvents = events.sort((a, b) => a.order - b.order);
-
-  const weekIds: string[] = [];
-  const monthIds: string[] = [];
-
-  sortedEvents.forEach((e) => {
-    const eventStart = dayjs(e.startDate);
-    const eventEnd = dayjs(e.endDate);
-    const isWeek =
-      eventStart.isSameOrAfter(weekStart) && eventEnd.isSameOrBefore(weekEnd);
-
-    if (isWeek) {
-      const isMonthRepeat = e?.recurrence?.rule?.includes(RRULE.MONTH);
-      if (!isMonthRepeat) {
-        weekIds.push(e._id!);
-        return;
-      }
-    }
-
-    const isFutureWeekThisMonth = e?.recurrence?.rule?.includes(RRULE.WEEK);
-    if (isFutureWeekThisMonth) {
-      return;
-    }
-
-    const monthStart = weekStart.startOf("month");
-    const monthEnd = weekStart.endOf("month");
-    const isMonth = eventStart.isBetween(monthStart, monthEnd, null, "[]");
-
-    if (isMonth) {
-      monthIds.push(e._id!);
-    }
-  });
+  const monthStart = weekStart.startOf("month");
+  const monthEnd = weekStart.endOf("month");
+  const _events = Object.values(events) as Schema_SomedayEvent[];
+  const somedayEvents = validateSomedayEvents(_events);
+  const _weekEvents = eventsBetweenDates(somedayEvents, weekStart, weekEnd);
+  const _monthEvents = eventsBetweenDates(somedayEvents, monthStart, monthEnd);
+  const weekEvents = uniqby(_weekEvents, (e) => e.recurrence?.eventId ?? e._id);
+
+  const otherMonthEvents = _monthEvents.filter(
+    ({ _id, recurrence }) =>
+      !weekEvents.some(
+        (e) =>
+          e._id === _id ||
+          (typeof e.recurrence?.eventId === "string" &&
+            e.recurrence?.eventId === recurrence?.eventId),
+      ),
+  );
+
+  const monthEvents = uniqby(
+    otherMonthEvents,
+    (e) => e.recurrence?.eventId ?? e._id,
+  );
 
   const sortedData = {
     columns: {
       [COLUMN_WEEK]: {
         id: `${COLUMN_WEEK}`,
-        eventIds: weekIds,
+        eventIds: weekEvents
+          .sort((a, b) => a.order - b.order)
+          .map((e) => e._id!),
       },
       [COLUMN_MONTH]: {
         id: `${COLUMN_MONTH}`,
-        eventIds: monthIds,
+        eventIds: monthEvents
+          .sort((a, b) => a.order - b.order)
+          .map((e) => e._id!),
       },
     },
     columnOrder: [COLUMN_WEEK, COLUMN_MONTH],
-    events: somedayEvents,
+    events,
   };
+
   return sortedData;
 };
 

packages/web/src/ducks/events/sagas/someday.sagas.ts

@@ -15,6 +15,7 @@ import {
   _assembleGridEvent,
   _createOptimisticGridEvent,
   _editEvent,
+  getEventById,
   normalizedEventsSchema,
   replaceOptimisticId,
 } from "@web/ducks/events/sagas/saga.util";
@@ -55,14 +56,29 @@ export function* convertSomedayToCalendarEvent({
 }
 
 export function* deleteSomedayEvent({ payload }: Action_DeleteEvent) {
+  const event = yield* getEventById(payload._id);
+
+  if (!event) {
+    console.error(`Event with ID ${payload._id} not found for deletion.`);
+    return;
+  }
+
   try {
     yield put(eventsEntitiesSlice.actions.delete(payload));
 
     yield call(EventApi.delete, payload._id, payload.applyTo);
   } catch (error) {
-    yield put(getSomedayEventsSlice.actions.error());
+    yield put(
+      getSomedayEventsSlice.actions.error({
+        __context: { reason: (error as Error).message },
+      }),
+    );
     handleError(error as Error);
-    yield put(getSomedayEventsSlice.actions.request());
+    yield put(
+      eventsEntitiesSlice.actions.insert({
+        [payload._id]: event as Schema_Event,
+      }),
+    );
   }
 }
 
@@ -92,17 +108,24 @@ export function* getSomedayEvents({ payload }: Action_GetEvents) {
         offset: res.offset,
       }),
     );
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
   } catch (error) {
-    yield put(getSomedayEventsSlice.actions.error());
+    yield put(
+      getSomedayEventsSlice.actions.error({
+        __context: { reason: (error as Error).message },
+      }),
+    );
   }
 }
 
 export function* reorderSomedayEvents({ payload }: Action_Someday_Reorder) {
   try {
     yield call(EventApi.reorder, payload);
   } catch (error) {
-    yield put(getSomedayEventsSlice.actions.error());
+    yield put(
+      getSomedayEventsSlice.actions.error({
+        __context: { reason: (error as Error).message },
+      }),
+    );
     handleError(error as Error);
   }
 }

packages/web/src/ducks/events/slices/view.slice.ts

@@ -30,7 +30,7 @@ interface Action_ReminderChange extends Action {
 
 const initialState: State_View = {
   dates: {
-    start: dayjs().format(),
+    start: dayjs().startOf("week").format(),
     end: dayjs().endOf("week").format(),
   },
   sidebar: { tab: "tasks", isOpen: true },

packages/web/src/views/Calendar/components/Sidebar/SomedayTab/SomedayEvents/SomedayEventContainer/SomedayEventRectangle.tsx

@@ -1,8 +1,10 @@
-import React from "react";
 import { Categories_Event, Schema_Event } from "@core/types/event.types";
 import { Flex } from "@web/components/Flex";
-import { AlignItems, JustifyContent } from "@web/components/Flex/styled";
-import { FlexDirections } from "@web/components/Flex/styled";
+import {
+  AlignItems,
+  FlexDirections,
+  JustifyContent,
+} from "@web/components/Flex/styled";
 import { Text } from "@web/components/Text";
 import { Props_DraftForm } from "@web/views/Calendar/components/Draft/context/DraftContext";
 import { Actions_Sidebar } from "@web/views/Calendar/components/Draft/sidebar/hooks/useSidebarActions";

packages/web/src/views/Calendar/hooks/useRefresh.ts

@@ -41,9 +41,10 @@ export const useRefresh = () => {
           break;
         }
         case Sync_AsyncStateContextReason.SOCKET_SOMEDAY_EVENT_CHANGED: {
+          const dateStart = dayjs(start);
           const { startDate, endDate } = computeSomedayEventsRequestFilter(
-            dayjs(start),
-            dayjs(end),
+            dateStart,
+            dateStart.endOf("month"),
           );
 
           dispatch(

packages/web/src/views/Calendar/hooks/useWeek.ts

@@ -42,8 +42,8 @@ export const useWeek = (today: Dayjs) => {
   }, [dispatch, end, start]);
 
   const somedayEventsRequestFilter = useMemo(() => {
-    return computeSomedayEventsRequestFilter(start, end);
-  }, [end, start]);
+    return computeSomedayEventsRequestFilter(start, start.endOf("month"));
+  }, [start]);
 
   useEffect(() => {
     dispatch(