✨ feat(sub-calendars): update backend schema and tests

Author: victor-enogwe

packages/backend/package.json

@@ -17,6 +17,7 @@
     "helmet": "^7.0.0",
     "jsonwebtoken": "^9.0.0",
     "lodash.mergewith": "^4.6.2",
+    "lodash.unset": "^4.5.2",
     "mongodb": "6.3",
     "morgan": "^1.10.0",
     "p-limit": "^7.2.0",

packages/backend/src/__tests__/backend.test.start.ts

@@ -1,7 +1,3 @@
 import { mockNodeModules } from "@backend/__tests__/helpers/mock.setup";
 
 mockNodeModules();
-
-beforeEach(() => jest.clearAllMocks());
-
-afterAll(() => jest.restoreAllMocks());

packages/backend/src/__tests__/drivers/auth.driver.ts

@@ -0,0 +1,65 @@
+import { ObjectId } from "bson";
+import { z } from "zod/v4";
+import { StringV4Schema, zObjectId } from "@core/types/type.utils";
+import { Schema_User } from "@core/types/user.types";
+import { UserDriver } from "@backend/__tests__/drivers/user.driver";
+import authController from "@backend/auth/controllers/auth.controller";
+import { getGcalClient } from "@backend/auth/services/google.auth.service";
+import mongoService from "@backend/common/services/mongo.service";
+
+export class AuthDriver {
+  static async googleSignup(): Promise<Schema_User> {
+    const { gUser, gRefreshToken } = UserDriver.createGoogleAuthUser();
+    const response = await authController.signup(gUser, gRefreshToken);
+
+    expect(zObjectId.parse(response.cUserId)).toBeInstanceOf(ObjectId);
+    expect(z.email().parse(response.email)).toBe(gUser.email);
+
+    const user = await mongoService.user.findOne({
+      _id: new ObjectId(response.cUserId),
+    });
+
+    expect(user).not.toBeNull();
+    expect(user).toBeDefined();
+
+    return user!;
+  }
+
+  static async googleLogin(userId: ObjectId): Promise<Schema_User> {
+    const user = await mongoService.user.findOne({ _id: userId });
+
+    expect(user).not.toBeNull();
+    expect(user).toBeDefined();
+
+    const _id = zObjectId.parse(user?._id);
+
+    const gRefreshToken = UserDriver.generateGoogleRefreshToken({
+      sub: StringV4Schema.parse(user?.google.googleId),
+      email: z.email().parse(user?.email),
+    });
+
+    const gcal = await getGcalClient(_id);
+
+    const { cUserId, email } = await authController.login(
+      user!,
+      gcal,
+      gRefreshToken,
+    );
+
+    expect(cUserId).toBe(_id.toString());
+    expect(z.email().safeParse(email).success).toBe(true);
+
+    const authenticatedUser = await mongoService.user.findOne({
+      _id: new ObjectId(cUserId),
+    });
+
+    expect(user).not.toBeNull();
+    expect(user).toBeDefined();
+
+    return authenticatedUser!;
+  }
+
+  static async signUpGoogleUsers(count: number): Promise<Array<Schema_User>> {
+    return Promise.all(Array.from({ length: count }, AuthDriver.googleSignup));
+  }
+}

packages/backend/src/__tests__/drivers/calendar.driver.ts

@@ -1,30 +1,101 @@
 import { ObjectId } from "mongodb";
 import { faker } from "@faker-js/faker";
-import { createMockCalendarListEntry } from "@core/__tests__/helpers/gcal.factory";
-import { UserDriver } from "@backend/__tests__/drivers/user.driver";
+import {
+  CompassCalendarSchema,
+  Schema_Calendar,
+} from "@core/types/calendar.types";
+import { gSchema$CalendarListEntry } from "@core/types/gcal";
+import { StringV4Schema } from "@core/types/type.utils";
+import { generateCalendarColorScheme } from "@core/util/color.utils";
+import { AuthDriver } from "@backend/__tests__/drivers/auth.driver";
+import { CompassGCalCalendarTestState } from "@backend/__tests__/helpers/mock.setup";
+import { mockAndCategorizeGcalEvents } from "@backend/__tests__/mocks.gcal/factories/gcal.event.batch";
+import { generateGcalId } from "@backend/__tests__/mocks.gcal/factories/gcal.event.factory";
+import calendarService from "@backend/calendar/services/calendar.service";
 import { IS_DEV } from "@backend/common/constants/env.constants";
 import mongoService from "@backend/common/services/mongo.service";
 
 export class CalendarDriver {
-  static async generateV0Data(numUsers = 3) {
-    const users = await UserDriver.createUsers(numUsers);
-
-    const data = users.map((user) => ({
-      _id: new ObjectId(),
-      user: user._id.toString(),
-      google: {
-        items: Array.from(
-          { length: faker.number.int({ min: 1, max: 5 }) },
-          (_, index) =>
-            createMockCalendarListEntry({
-              id: index === 0 ? user.email : faker.string.ulid(),
-              primary: index === 0,
-              summaryOverride:
-                index === 0 ? `${user.firstName} ${user.lastName}` : null,
-            }),
+  /**
+   * Generates a mock Google Calendar calendar entry for a user.
+   * The calendar is added to the user's mocked google calendars
+   */
+  static createGCalCalendarListEntry(
+    overrides: Partial<gSchema$CalendarListEntry> = {},
+  ): gSchema$CalendarListEntry {
+    const { backgroundColor, color } = generateCalendarColorScheme();
+
+    const calendar = {
+      kind: "calendar#calendarListEntry",
+      id: generateGcalId(),
+      primary: false,
+      etag: faker.number.hex({ min: 16, max: 16 }).toString(),
+      summary: faker.book.title(),
+      description: faker.lorem.paragraph({ min: 1, max: 3 }),
+      timeZone: faker.location.timeZone(),
+      colorId: faker.number.int({ min: 1, max: 24 }).toString(),
+      backgroundColor,
+      foregroundColor: color,
+      selected: true,
+      accessRole: faker.helpers.arrayElement(["reader", "writer", "owner"]),
+      defaultReminders: [],
+      conferenceProperties: {
+        allowedConferenceSolutionTypes: faker.helpers.arrayElements(
+          ["hangoutsMeet", "eventHangout", "eventNamedHangout"],
+          { min: 1, max: 3 },
         ),
       },
-    }));
+      ...overrides,
+    };
+
+    return calendar;
+  }
+
+  static createCalendarTestState(): Array<
+    [string, CompassGCalCalendarTestState]
+  > {
+    const length = faker.number.int({ min: 2, max: 5 });
+
+    return Array.from({ length }, (_, index) => {
+      const events = Array.from(
+        { length },
+        () => mockAndCategorizeGcalEvents(index % 2 !== 0).gcalEvents.all,
+      ).flat();
+
+      const calendar = CalendarDriver.createGCalCalendarListEntry({
+        primary: index === 0,
+      });
+
+      return [StringV4Schema.parse(calendar.id), { calendar, events }];
+    });
+  }
+
+  static async generateV0Data(numUsers = 3) {
+    const users = await AuthDriver.signUpGoogleUsers(numUsers);
+
+    const data = await Promise.all(
+      users.map(async (user) => {
+        const calendars = await calendarService.getAllByUser(user._id);
+
+        return {
+          _id: new ObjectId(),
+          user: user._id.toString(),
+          google: {
+            items: calendars.map((calendar) =>
+              CalendarDriver.createGCalCalendarListEntry({
+                ...calendar.metadata,
+                backgroundColor: calendar.backgroundColor,
+                foregroundColor: calendar.color,
+                timeZone: calendar.timezone,
+                summaryOverride: calendar.primary
+                  ? `${user.firstName} ${user.lastName}`
+                  : null,
+              }),
+            ),
+          },
+        };
+      }),
+    );
 
     const calendarListCollection = mongoService.db.collection<
       (typeof data)[number]
@@ -36,4 +107,13 @@ export class CalendarDriver {
 
     return calendars;
   }
+
+  static async getRandomUserCalendar(user: ObjectId): Promise<Schema_Calendar> {
+    const calendars = await calendarService.getAllByUser(user);
+
+    const index = faker.number.int({ min: 0, max: calendars.length - 1 });
+    const calendar = calendars[index];
+
+    return CompassCalendarSchema.parse(calendar);
+  }
 }

packages/backend/src/__tests__/drivers/email.driver.ts

@@ -1,26 +1,34 @@
 import { ObjectId } from "mongodb";
 import { z } from "zod/v4";
-import Migration from "@scripts/migrations/2025.10.18T20.01.14.migrate-events-to-new-events-collection";
+import { faker } from "@faker-js/faker";
 import { Origin, Priorities } from "@core/constants/core.constants";
-import { UserDriver } from "@backend/__tests__/drivers/user.driver";
+import {
+  Schema_Base_Event,
+  Schema_Instance_Event,
+  V0EventSchema,
+} from "@core/types/event.types";
+import { gSchema$Event } from "@core/types/gcal";
+import { createRecurrenceSeries } from "@core/util/test/ccal.event.factory";
+import { AuthDriver } from "@backend/__tests__/drivers/auth.driver";
 import { mockGcalEvents } from "@backend/__tests__/mocks.gcal/factories/gcal.event.factory";
 import { getGcalClient } from "@backend/auth/services/google.auth.service";
 import calendarService from "@backend/calendar/services/calendar.service";
+import gcalService from "@backend/common/services/gcal/gcal.service";
 import mongoService from "@backend/common/services/mongo.service";
 
 export class EventDriver {
   static async generateV0Data(count = 3) {
-    const users = await UserDriver.createUsers(count);
+    const users = await AuthDriver.signUpGoogleUsers(count);
 
     const collection = mongoService.db.collection<
-      z.infer<typeof Migration.OldEventSchema>
+      z.infer<typeof V0EventSchema>
     >(mongoService.event.collectionName);
 
     await Promise.all(
       users.map(async (user) =>
         calendarService.initializeGoogleCalendars(
           user._id,
-          await getGcalClient(user._id.toString()),
+          await getGcalClient(user._id),
         ),
       ),
     );
@@ -29,11 +37,12 @@ export class EventDriver {
       const gcalAllDayEvents = mockGcalEvents(true, { count });
       const gcalTimedEvents = mockGcalEvents(false, { count });
 
-      const somedayEvent = Migration.OldEventSchema.parse({
+      const somedayEvent = V0EventSchema.parse({
         user: user._id.toString(),
         title: "Someday Event",
         startDate: new Date().toISOString(),
         endDate: new Date().toISOString(),
+        order: faker.number.int({ min: 0, max: 10 }),
         isSomeday: true,
         isAllDay: false,
         origin: Origin.COMPASS,
@@ -64,6 +73,7 @@ export class EventDriver {
             title: gcalEvent.summary || "No Title",
             startDate: gcalEvent.start?.dateTime ?? gcalEvent.start!.date!,
             endDate: gcalEvent.end?.dateTime ?? gcalEvent.end!.date!,
+            order: faker.number.int({ min: 0, max: 10 }),
             isAllDay: !!gcalEvent.start?.date,
             isSomeday: false,
             origin: Origin.GOOGLE,
@@ -91,7 +101,7 @@ export class EventDriver {
             });
           }
 
-          return Migration.OldEventSchema.parse(event);
+          return V0EventSchema.parse(event);
         }),
       ];
     });
@@ -100,4 +110,34 @@ export class EventDriver {
 
     return events;
   }
+
+  static async getGCalEvent(
+    user: ObjectId,
+    gEventId: string,
+    gCalendarId: string,
+  ): Promise<gSchema$Event> {
+    const gcal = await getGcalClient(user);
+    const gEvent = await gcalService.getEvent(gcal, gEventId, gCalendarId);
+
+    return gEvent;
+  }
+
+  static async createSeries(
+    baseOverrides: Partial<Schema_Base_Event>,
+    instanceOverrides?: Partial<Schema_Instance_Event>,
+    instanceCount?: number,
+  ) {
+    const { base, instances } = createRecurrenceSeries(
+      baseOverrides,
+      instanceOverrides,
+      instanceCount,
+    );
+
+    const meta = await mongoService.event.insertMany([base, ...instances]);
+
+    return {
+      state: { baseEvent: base, instances },
+      meta,
+    };
+  }
 }