✨ feat(sub-calendars): create calendar collection and schema (#1067)

Author: victor-enogwe

packages/backend/package.json

@@ -23,8 +23,7 @@
     "saslprep": "^1.0.3",
     "socket.io": "^4.7.5",
     "supertokens-node": "^20.0.5",
-    "tslib": "^2.4.0",
-    "zod": "^3.24.1"
+    "tslib": "^2.4.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^9.6.0",

packages/backend/src/calendar/services/calendar.service.ts

@@ -9,7 +9,7 @@ class CalendarService {
   ) => {
     const payload = calendarList.google.items;
 
-    const response = await mongoService.calendar.updateOne(
+    const response = await mongoService.calendarList.updateOne(
       { user: userId },
       { $push: { [`${integration}.items`]: payload } },
       { upsert: true },
@@ -19,18 +19,18 @@ class CalendarService {
   };
 
   create = async (calendarList: Schema_CalendarList) => {
-    return await mongoService.calendar.insertOne(calendarList);
+    return await mongoService.calendarList.insertOne(calendarList);
   };
 
   async deleteAllByUser(userId: string) {
     const filter = { user: userId };
-    const response = await mongoService.calendar.deleteMany(filter);
+    const response = await mongoService.calendarList.deleteMany(filter);
 
     return response;
   }
 
   deleteByIntegrateion = async (integration: "google", userId: string) => {
-    const response = await mongoService.calendar.updateOne(
+    const response = await mongoService.calendarList.updateOne(
       { user: userId },
       { $unset: { [`${integration}.items`]: "" } },
     );

packages/backend/src/common/constants/collections.ts

@@ -1,6 +1,7 @@
-import { IS_DEV } from "./env.constants";
+import { IS_DEV } from "@backend/common/constants/env.constants";
 
 export const Collections = {
+  CALENDAR: IS_DEV ? "_dev.calendar" : "calendar",
   CALENDARLIST: IS_DEV ? "_dev.calendarlist" : "calendarlist",
   EVENT: IS_DEV ? "_dev.event" : "event",
   OAUTH: IS_DEV ? "_dev.oauth" : "oauth",

packages/backend/src/common/services/mongo.service.ts

@@ -10,21 +10,25 @@ import {
   ObjectId,
 } from "mongodb";
 import { Logger } from "@core/logger/winston.logger";
-import { Schema_CalendarList as Schema_Calendar } from "@core/types/calendar.types";
+import {
+  CompassCalendar,
+  Schema_CalendarList as Schema_Calendar,
+} from "@core/types/calendar.types";
 import { Schema_Event } from "@core/types/event.types";
 import { Schema_Sync } from "@core/types/sync.types";
 import { Schema_User } from "@core/types/user.types";
 import { Schema_Waitlist } from "@core/types/waitlist/waitlist.types";
+import { Collections } from "@backend/common/constants/collections";
+import { ENV } from "@backend/common/constants/env.constants";
 import { waitUntilEvent } from "@backend/common/helpers/common.util";
-import { Collections } from "../constants/collections";
-import { ENV } from "../constants/env.constants";
 
 const logger = Logger("app:mongo.service");
 
 interface InternalClient {
   db: Db;
   client: MongoClient;
-  calendar: Collection<Schema_Calendar>;
+  calendar: Collection<CompassCalendar>;
+  calendarList: Collection<Schema_Calendar>;
   event: Collection<Omit<Schema_Event, "_id">>;
   sync: Collection<Schema_Sync>;
   user: Collection<Schema_User>;
@@ -47,6 +51,15 @@ class MongoService {
     return this.#accessInternalCollectionProps("calendar");
   }
 
+  /**
+   * calendarList
+   *
+   * mongo collection
+   */
+  get calendarList(): InternalClient["calendarList"] {
+    return this.#accessInternalCollectionProps("calendarList");
+  }
+
   /**
    * event
    *
@@ -114,7 +127,8 @@ class MongoService {
     return {
       db,
       client,
-      calendar: db.collection<Schema_Calendar>(Collections.CALENDARLIST),
+      calendar: db.collection<CompassCalendar>(Collections.CALENDAR),
+      calendarList: db.collection<Schema_Calendar>(Collections.CALENDARLIST),
       event: db.collection<Omit<Schema_Event, "_id">>(Collections.EVENT),
       sync: db.collection<Schema_Sync>(Collections.SYNC),
       user: db.collection<Schema_User>(Collections.USER),
@@ -206,6 +220,10 @@ class MongoService {
     const r = await this.db.collection(collection).findOne(filter);
     return r !== null;
   }
+
+  async collectionExists(name: string): Promise<boolean> {
+    return this.db.listCollections({ name }).hasNext();
+  }
 }
 
 export default new MongoService();

packages/core/package.json

@@ -13,6 +13,7 @@
   "dependencies": {
     "bson": "^6.10.4",
     "tinycolor2": "^1.6.0",
-    "winston": "^3.8.1"
+    "winston": "^3.8.1",
+    "zod": "^3.25.76"
   }
 }

packages/core/src/__mocks__/v1/calendarlist/gcal.calendarlist.ts

@@ -1,4 +1,6 @@
-export const gcalCalendarList = {
+import { gSchema$CalendarList } from "@core/types/gcal";
+
+export const gcalCalendarList: gSchema$CalendarList = {
   kind: "calendar#calendarList",
   etag: '"p32g9nb5bt6fva0g"',
   nextSyncToken: "CKCbrKvpn_UCEhh0eWxlci5oaXR6ZW1hbkBnbWFpbC5jb20=",

packages/core/src/types/calendar.types.ts

@@ -1,7 +1,11 @@
-import { z } from "zod";
+import { z } from "zod/v4";
+import { CalendarProvider } from "@core/types/event.types";
 import { gSchema$CalendarListEntry } from "@core/types/gcal";
-import { IDSchema, RGBHexSchema, TimezoneSchema } from "@core/types/type.utils";
-import { CalendarProvider } from "./event.types";
+import {
+  IDSchemaV4,
+  RGBHexSchema,
+  TimezoneSchema,
+} from "@core/types/type.utils";
 
 // @deprecated - will be replaced by Schema_Calendar
 export interface Schema_CalendarList {
@@ -20,7 +24,7 @@ export const GoogleCalendarMetadataSchema = z.object({
   description: z.string().nullable().optional(),
   location: z.string().nullable().optional(),
   accessRole: z.enum(["freeBusyReader", "reader", "writer", "owner"]),
-  primary: z.boolean().default(false),
+  primary: z.boolean().default(false).optional(),
   conferenceProperties: z.object({
     allowedConferenceSolutionTypes: z.array(
       z.enum(["hangoutsMeet", "eventHangout", "eventNamedHangout"]),
@@ -51,15 +55,15 @@ export const GoogleCalendarMetadataSchema = z.object({
 });
 
 export const CompassCalendarSchema = z.object({
-  _id: IDSchema,
-  user: IDSchema,
+  _id: IDSchemaV4,
+  user: IDSchemaV4,
   backgroundColor: RGBHexSchema,
   color: RGBHexSchema,
   selected: z.boolean().default(true),
   primary: z.boolean().default(false),
-  timezone: TimezoneSchema.optional(),
+  timezone: TimezoneSchema.nullable().optional(),
   createdAt: z.date().default(() => new Date()),
-  updatedAt: z.date().optional(),
+  updatedAt: z.date().nullable().optional(),
   metadata: GoogleCalendarMetadataSchema, // use union when other providers present
 });
 

packages/core/src/types/type.utils.test.ts

@@ -1,6 +1,12 @@
-import { ZodError } from "zod";
+import { ZodError as ZodErrorV3 } from "zod";
+import { ZodError, z } from "zod/v4";
 import { faker } from "@faker-js/faker";
-import { IDSchema, RGBHexSchema, TimezoneSchema } from "@core/types/type.utils";
+import {
+  IDSchema,
+  IDSchemaV4,
+  RGBHexSchema,
+  TimezoneSchema,
+} from "@core/types/type.utils";
 
 describe("IDSchema", () => {
   it("validates a correct ObjectId string", () => {
@@ -13,11 +19,30 @@ describe("IDSchema", () => {
     const invalidId = faker.string.ulid();
     const result = IDSchema.safeParse(invalidId);
 
+    expect(result.success).toBe(false);
+    expect(result.error).toBeInstanceOf(ZodErrorV3);
+    expect(result.error?.errors).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ message: "Invalid id" }),
+      ]),
+    );
+  });
+});
+
+describe("IDSchemaV4", () => {
+  it("validates a correct ObjectId string", () => {
+    const validId = faker.database.mongodbObjectId();
+
+    expect(IDSchemaV4.safeParse(validId).success).toBe(true);
+  });
+
+  it("rejects an invalid ObjectId string", () => {
+    const invalidId = faker.string.ulid();
+    const result = IDSchemaV4.safeParse(invalidId);
+
     expect(result.success).toBe(false);
     expect(result.error).toBeInstanceOf(ZodError);
-    expect(result.error?.errors).toEqual([
-      { message: "Invalid id", path: [], code: "custom" },
-    ]);
+    expect(z.treeifyError(result.error!).errors).toEqual(["Invalid id"]);
   });
 });
 
@@ -34,9 +59,7 @@ describe("TimezoneSchema", () => {
 
     expect(result.success).toBe(false);
     expect(result.error).toBeInstanceOf(ZodError);
-    expect(result.error?.errors).toEqual([
-      { message: "Invalid timezone", path: [], code: "custom" },
-    ]);
+    expect(z.treeifyError(result.error!).errors).toEqual(["Invalid timezone"]);
   });
 
   describe("RGBHexSchema", () => {
@@ -58,13 +81,8 @@ describe("TimezoneSchema", () => {
 
       expect(result.success).toBe(false);
       expect(result.error).toBeInstanceOf(ZodError);
-      expect(result.error?.errors).toEqual([
-        {
-          message: "Invalid color. Must be a 7-character hex color code.",
-          path: [],
-          code: "invalid_string",
-          validation: "regex",
-        },
+      expect(z.treeifyError(result.error!).errors).toEqual([
+        "Invalid color. Must be a 7-character hex color code.",
       ]);
     });
 
@@ -74,13 +92,8 @@ describe("TimezoneSchema", () => {
 
       expect(result.success).toBe(false);
       expect(result.error).toBeInstanceOf(ZodError);
-      expect(result.error?.errors).toEqual([
-        {
-          message: "Invalid color. Must be a 7-character hex color code.",
-          path: [],
-          code: "invalid_string",
-          validation: "regex",
-        },
+      expect(z.treeifyError(result.error!).errors).toEqual([
+        "Invalid color. Must be a 7-character hex color code.",
       ]);
     });
 
@@ -90,13 +103,8 @@ describe("TimezoneSchema", () => {
 
       expect(result.success).toBe(false);
       expect(result.error).toBeInstanceOf(ZodError);
-      expect(result.error?.errors).toEqual([
-        {
-          message: "Invalid color. Must be a 7-character hex color code.",
-          path: [],
-          code: "invalid_string",
-          validation: "regex",
-        },
+      expect(z.treeifyError(result.error!).errors).toEqual([
+        "Invalid color. Must be a 7-character hex color code.",
       ]);
     });
   });

packages/core/src/types/type.utils.ts

@@ -1,5 +1,6 @@
 import { ObjectId } from "bson";
 import { z } from "zod";
+import { z as zod4 } from "zod/v4";
 
 export type KeyOfType<T, V> = keyof {
   [P in keyof T as T[P] extends V ? P : never]: unknown;
@@ -14,7 +15,11 @@ export const IDSchema = z.string().refine(ObjectId.isValid, {
   message: "Invalid id",
 });
 
-export const TimezoneSchema = z.string().refine(
+export const IDSchemaV4 = zod4.string().refine(ObjectId.isValid, {
+  message: "Invalid id",
+});
+
+export const TimezoneSchema = zod4.string().refine(
   (timeZone) => {
     try {
       new Intl.DateTimeFormat("en-US", { timeZone });
@@ -28,6 +33,6 @@ export const TimezoneSchema = z.string().refine(
   { message: "Invalid timezone" },
 );
 
-export const RGBHexSchema = z.string().regex(/^#[0-9a-f]{6}$/i, {
+export const RGBHexSchema = zod4.string().regex(/^#[0-9a-f]{6}$/i, {
   message: "Invalid color. Must be a 7-character hex color code.",
 });