🐛 hotfix: someday events handle order field (#517)

* feat(web): fix typo

* hotfix(web): set order field for someday events if it is not set, add tests

the added tests should help us validate edge cases with the order being potentially missing.

* feat(web): re-enable validation

see why it was disabled here https://github.com/SwitchbackTech/compass/pull/503/files

and why it is now re-enabled here
#517

Author: that-one-arab

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

@@ -5,9 +5,11 @@ import isSameOrBefore from "dayjs/plugin/isSameOrBefore";
 import timezone from "dayjs/plugin/timezone";
 import utc from "dayjs/plugin/utc";
 import { Origin, Priorities } from "@core/constants/core.constants";
+import { Schema_Event } from "@core/types/event.types";
 import { COLUMN_MONTH, COLUMN_WEEK } from "@web/common/constants/web.constants";
 import { Schema_SomedayEvent } from "@web/common/types/web.event.types";
 import { categorizeSomedayEvents } from "../someday.util";
+import { setSomedayEventsOrder } from "../someday.util";
 
 dayjs.extend(utc);
 dayjs.extend(timezone);
@@ -191,3 +193,106 @@ describe("categorizeSomedayEvents", () => {
     });
   });
 });
+
+describe("setSomedayEventsOrder", () => {
+  const createEvent = (id: string, order?: number): Schema_Event => ({
+    _id: id,
+    ...(order !== undefined && { order }),
+  });
+
+  it("should return empty array for empty input", () => {
+    expect(setSomedayEventsOrder([])).toEqual([]);
+  });
+
+  it("should assign sequential orders starting from 0 when no events have orders", () => {
+    const events = [createEvent("1"), createEvent("2"), createEvent("3")];
+
+    const result = setSomedayEventsOrder(events);
+
+    expect(result).toEqual([
+      { ...events[0], order: 0 },
+      { ...events[1], order: 1 },
+      { ...events[2], order: 2 },
+    ]);
+  });
+
+  it("should preserve existing valid orders", () => {
+    const events = [
+      createEvent("1", 5),
+      createEvent("2", 2),
+      createEvent("3", 8),
+    ];
+
+    const result = setSomedayEventsOrder(events);
+
+    expect(result).toEqual(events);
+  });
+
+  it("should fill gaps in order sequence", () => {
+    const events = [
+      createEvent("1", 0),
+      createEvent("2"), // Should get order 1
+      createEvent("3", 3),
+      createEvent("4"), // Should get order 2
+      createEvent("5", 5),
+    ];
+
+    const result = setSomedayEventsOrder(events);
+
+    expect(result).toEqual([
+      { ...events[0], order: 0 },
+      { ...events[1], order: 1 },
+      { ...events[2], order: 3 },
+      { ...events[3], order: 2 },
+      { ...events[4], order: 5 },
+    ]);
+  });
+
+  it("should append to end when no gaps available", () => {
+    const events = [
+      createEvent("1", 0),
+      createEvent("2", 1),
+      createEvent("3"), // Should get order 3
+      createEvent("4", 2),
+      createEvent("5"), // Should get order 4
+    ];
+
+    const result = setSomedayEventsOrder(events);
+
+    expect(result).toEqual([
+      { ...events[0], order: 0 },
+      { ...events[1], order: 1 },
+      { ...events[2], order: 3 },
+      { ...events[3], order: 2 },
+      { ...events[4], order: 4 },
+    ]);
+  });
+
+  it("should handle mix of valid and invalid order values", () => {
+    const events = [
+      createEvent("1", 1),
+      { ...createEvent("2"), order: Number.NaN }, // Should get order 0
+      { ...createEvent("3"), order: undefined }, // Should get order 2
+      createEvent("4", 4),
+      { ...createEvent("5"), order: undefined }, // Should get order 3
+    ];
+
+    const result = setSomedayEventsOrder(events);
+
+    expect(result).toEqual([
+      { ...events[0], order: 1 },
+      { ...events[1], order: 0 },
+      { ...events[2], order: 2 },
+      { ...events[3], order: 4 },
+      { ...events[4], order: 3 },
+    ]);
+  });
+
+  it("should handle single event without order", () => {
+    const events = [createEvent("1")];
+
+    const result = setSomedayEventsOrder(events);
+
+    expect(result).toEqual([{ ...events[0], order: 0 }]);
+  });
+});

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

@@ -7,6 +7,7 @@ import {
   Schema_SomedayEvent,
   Schema_SomedayEventsColumn,
 } from "@web/common/types/web.event.types";
+import { validateSomedayEvents } from "@web/common/validators/someday.event.validator";
 
 export const getSomedayEventCategory = (
   event: Schema_Event,
@@ -34,7 +35,9 @@ export const categorizeSomedayEvents = (
 ): Schema_SomedayEventsColumn => {
   const { start: weekStart, end: weekEnd } = weekDates;
 
-  const events = Object.values(somedayEvents) as Schema_SomedayEvent[];
+  let events = Object.values(somedayEvents) as Schema_SomedayEvent[];
+
+  events = validateSomedayEvents(events);
 
   const sortedEvents = events.sort((a, b) => a.order - b.order);
 
@@ -85,3 +88,54 @@ export const categorizeSomedayEvents = (
   };
   return sortedData;
 };
+
+/**
+ * See https://github.com/SwitchbackTech/compass/issues/512 for more context.
+ * Should be removed after we ensure that backend sets the order field for all someday events.
+ */
+export const setSomedayEventsOrder = (
+  events: Schema_Event[],
+): Schema_Event[] => {
+  if (events.length === 0) return [];
+
+  // Get existing valid orders
+  const existingOrders = events
+    .map((e) => e.order)
+    .filter(
+      (order): order is number => typeof order === "number" && !isNaN(order),
+    )
+    .sort((a, b) => a - b);
+
+  // If no valid orders exist, assign sequential orders starting from 0
+  if (existingOrders.length === 0) {
+    return events.map((event, index) => ({ ...event, order: index }));
+  }
+
+  const lowestOrder = Math.min(0, existingOrders[0]); // Ensure we start at least from 0
+  const highestOrder = existingOrders[existingOrders.length - 1];
+
+  // Create a set of used orders for faster lookup
+  const usedOrders = new Set(existingOrders);
+
+  // Find all available orders in the range
+  const availableOrders: number[] = [];
+  for (let i = lowestOrder; i <= highestOrder; i++) {
+    if (!usedOrders.has(i)) {
+      availableOrders.push(i);
+    }
+  }
+
+  // Process each event that needs an order
+  let nextNewOrder = highestOrder + 1;
+  return events.map((event) => {
+    // Keep existing valid orders
+    if (typeof event.order === "number" && !isNaN(event.order)) {
+      return event;
+    }
+
+    // Assign next available order or append to end
+    const order =
+      availableOrders.length > 0 ? availableOrders.shift()! : nextNewOrder++;
+    return { ...event, order };
+  });
+};

…b/src/ducks/events/sagas/somday.sagas.ts …/src/ducks/events/sagas/someday.sagas.tspackages/web/src/ducks/events/sagas/somday.sagas.ts renamed to packages/web/src/ducks/events/sagas/someday.sagas.ts packages/web/src/ducks/events/sagas/somday.sagas.ts renamed to packages/web/src/ducks/events/sagas/someday.sagas.ts

@@ -8,6 +8,7 @@ import {
   handleError,
   replaceIdWithOptimisticId,
 } from "@web/common/utils/event.util";
+import { setSomedayEventsOrder } from "@web/common/utils/someday.util";
 import { validateGridEvent } from "@web/common/validators/grid.event.validator";
 import { EventApi } from "../event.api";
 import {
@@ -70,7 +71,9 @@ export function* getSomedayEvents({ payload }: Action_GetEvents) {
       endDate: payload.endDate,
     })) as Response_GetEventsSuccess;
 
-    const normalizedEvents = normalize<Schema_Event>(res.data, [
+    const events = setSomedayEventsOrder(res.data);
+
+    const normalizedEvents = normalize<Schema_Event>(events, [
       normalizedEventsSchema(),
     ]);
     yield put(

packages/web/src/store/sagas.ts

@@ -12,7 +12,7 @@ import {
   deleteSomedayEvent,
   getSomedayEvents,
   reorderSomedayEvents,
-} from "@web/ducks/events/sagas/somday.sagas";
+} from "@web/ducks/events/sagas/someday.sagas";
 import {
   createEventSlice,
   deleteEventSlice,