:sparkles feat(sub-calendars): sub calendars WIP

Author: victor-enogwe

packages/backend/src/__tests__/mocks.gcal/factories/gcal.factory.ts

@@ -15,6 +15,7 @@ import type {
   gSchema$EventBase,
   gSchema$Events,
 } from "@core/types/gcal";
+import { Resource_Sync } from "@core/types/sync.types";
 import {
   isBaseGCalEvent,
   isInstanceGCalEvent,
@@ -390,6 +391,23 @@ export const mockGcal = ({
           });
         },
       ),
+      watch: jest.fn(
+        async (
+          params: calendar_v3.Params$Resource$Calendarlist$Watch,
+          options: MethodOptions = {},
+        ): GaxiosPromise<gSchema$Channel> =>
+          Promise.resolve({
+            config: options,
+            statusText: "OK",
+            status: 200,
+            data: {
+              ...params.requestBody,
+              resourceId: Resource_Sync.CALENDAR,
+            },
+            headers: options.headers!,
+            request: { responseURL: params.requestBody!.address! },
+          }),
+      ),
     },
     channels: {
       ...calendar.channels,

packages/backend/src/auth/middleware/auth.middleware.ts

@@ -6,6 +6,8 @@ import { error } from "@backend/common/errors/handlers/error.handler";
 import { GcalError } from "@backend/common/errors/integration/gcal/gcal.errors";
 import { SReqBody } from "@backend/common/types/express.types";
 import { hasGoogleHeaders } from "@backend/sync/util/sync.util";
+import { COMPASS_RESOURCE_HEADER } from "../../../../core/src/constants/core.constants";
+import { decodeChannelToken } from "../../sync/util/watch.util";
 
 class AuthMiddleware {
   verifyIsDev = (_req: Request, res: Response, next: NextFunction) => {
@@ -35,19 +37,22 @@ class AuthMiddleware {
   };
 
   verifyIsFromGoogle = (req: Request, res: Response, next: NextFunction) => {
-    const tokenIsInvalid =
-      (req.headers["x-goog-channel-token"] as string) !==
-      ENV.TOKEN_GCAL_NOTIFICATION;
-    const isMissingHeaders = !hasGoogleHeaders(req.headers);
+    try {
+      const isMissingHeaders = !hasGoogleHeaders(req.headers);
 
-    if (isMissingHeaders || tokenIsInvalid) {
-      res
-        .status(Status.FORBIDDEN)
-        .send({ error: error(GcalError.Unauthorized, "Notification Failed") });
-      return;
-    }
+      if (isMissingHeaders) {
+        throw error(GcalError.Unauthorized, "Notification Failed");
+      }
 
-    next();
+      const token = req.headers["x-goog-channel-token"] as string;
+      const { resource } = decodeChannelToken(token);
+
+      res.set(COMPASS_RESOURCE_HEADER, resource);
+
+      next();
+    } catch (e) {
+      next(e);
+    }
   };
 
   verifyGoogleOauthCode = (

packages/backend/src/common/errors/sync/sync.errors.ts

@@ -3,7 +3,6 @@ import { ErrorMetadata } from "@backend/common/types/error.types";
 
 interface SyncErrors {
   AccessRevoked: ErrorMetadata;
-  CalendarWatchExists: ErrorMetadata;
   NoGCalendarId: ErrorMetadata;
   NoResourceId: ErrorMetadata;
   NoSyncToken: ErrorMetadata;
@@ -17,11 +16,6 @@ export const SyncError: SyncErrors = {
     status: Status.GONE,
     isOperational: true,
   },
-  CalendarWatchExists: {
-    description: "Watch already exists",
-    status: Status.BAD_REQUEST,
-    isOperational: true,
-  },
   NoGCalendarId: {
     description: "No gCalendarId",
     status: Status.NO_CONTENT,

packages/backend/src/common/errors/sync/watch.errors.ts

@@ -0,0 +1,20 @@
+import { Status } from "@core/errors/status.codes";
+import { ErrorMetadata } from "@backend/common/types/error.types";
+
+interface WatchErrors {
+  EventWatchExists: ErrorMetadata;
+  CalendarWatchExists: ErrorMetadata;
+}
+
+export const WatchError: WatchErrors = {
+  EventWatchExists: {
+    description: "Event watch already exists",
+    status: Status.BAD_REQUEST,
+    isOperational: true,
+  },
+  CalendarWatchExists: {
+    description: "Calendar watch already exists",
+    status: Status.BAD_REQUEST,
+    isOperational: true,
+  },
+};

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

@@ -6,12 +6,17 @@ import type {
   gSchema$Event,
   gSchema$Events,
 } from "@core/types/gcal";
-import type { Params_WatchEvents } from "@core/types/sync.types";
+import {
+  type Params_WatchEvents,
+  Resource_Sync,
+  SyncDetails,
+} from "@core/types/sync.types";
+import { IDSchemaV4 } from "@core/types/type.utils";
 import { GCAL_PRIMARY } from "@backend/common/constants/backend.constants";
-import { ENV } from "@backend/common/constants/env.constants";
 import { error } from "@backend/common/errors/handlers/error.handler";
 import { GcalError } from "@backend/common/errors/integration/gcal/gcal.errors";
 import { getBaseURL } from "@backend/servers/ngrok/ngrok.utils";
+import { encodeChannelToken } from "@backend/sync/util/watch.util";
 
 class GCalService {
   private validateGCalResponse<T>(
@@ -31,22 +36,25 @@ class GCalService {
     gcal: gCalendar,
     gcalEventId: string,
     calendarId = GCAL_PRIMARY,
-  ) {
+  ): Promise<gSchema$Event> {
     const response = await gcal.events.get({
       calendarId,
       eventId: gcalEventId,
     });
 
-    return response.data;
+    return this.validateGCalResponse(response).data;
   }
 
-  async createEvent(gcal: gCalendar, event: gSchema$Event) {
+  async createEvent(
+    gcal: gCalendar,
+    event: gSchema$Event,
+  ): Promise<gSchema$Event> {
     const response = await gcal.events.insert({
       calendarId: GCAL_PRIMARY,
       requestBody: event,
     });
 
-    return response.data;
+    return this.validateGCalResponse(response).data;
   }
 
   async deleteEvent(gcal: gCalendar, gcalEventId: string) {
@@ -55,6 +63,7 @@ class GCalService {
       eventId: gcalEventId,
       sendUpdates: "all",
     });
+
     return response;
   }
 
@@ -75,12 +84,14 @@ class GCalService {
       pageToken,
       maxResults,
     });
-    return response;
+
+    return this.validateGCalResponse(response);
   }
 
   async getEvents(gcal: gCalendar, params: gParamsEventsList) {
     const response = await gcal.events.list(params);
-    return response;
+
+    return this.validateGCalResponse(response);
   }
 
   async *getBaseRecurringEventInstances({
@@ -181,8 +192,14 @@ class GCalService {
     } while (hasNextPage || !isLastPage);
   }
 
-  async getCalendarlist(gcal: gCalendar) {
-    const response = await gcal.calendarList.list();
+  async getCalendarlist(
+    gcal: gCalendar,
+    {
+      nextSyncToken: syncToken,
+      nextPageToken: pageToken,
+    }: Partial<Pick<SyncDetails, "nextSyncToken" | "nextPageToken">> = {},
+  ) {
+    const response = await gcal.calendarList.list({ syncToken, pageToken });
 
     if (!response.data.nextSyncToken) {
       throw error(
@@ -203,24 +220,64 @@ class GCalService {
       eventId: gEventId,
       requestBody: event,
     });
-    return response.data;
+
+    return this.validateGCalResponse(response).data;
   }
 
-  watchEvents = async (gcal: gCalendar, params: Params_WatchEvents) => {
-    const { data } = await gcal.events.watch({
+  watchCalendars = async (
+    gcal: gCalendar,
+    params: Omit<Params_WatchEvents, "gCalendarId" | "resourceId">,
+  ) => {
+    const response = await gcal.calendarList.watch({
+      quotaUser: params.quotaUser,
+      requestBody: {
+        // reminder: address always needs to be HTTPS
+        address: getBaseURL() + GCAL_NOTIFICATION_ENDPOINT,
+        expiration: params.expiration,
+        id: IDSchemaV4.parse(params.channelId),
+        token: encodeChannelToken({ resource: Resource_Sync.CALENDAR }),
+        type: "web_hook",
+      },
+    });
+
+    return { watch: this.validateGCalResponse(response).data };
+  };
+
+  watchEvents = async (
+    gcal: gCalendar,
+    params: Omit<Params_WatchEvents, "resourceId">,
+  ) => {
+    const response = await gcal.events.watch({
       calendarId: params.gCalendarId,
+      quotaUser: params.quotaUser,
       requestBody: {
         // reminder: address always needs to be HTTPS
         address: getBaseURL() + GCAL_NOTIFICATION_ENDPOINT,
         expiration: params.expiration,
-        id: params.channelId,
-        token: ENV.TOKEN_GCAL_NOTIFICATION,
+        id: IDSchemaV4.parse(params.channelId),
+        token: encodeChannelToken({ resource: Resource_Sync.EVENTS }),
         type: "web_hook",
       },
-      syncToken: params.nextSyncToken,
     });
 
-    return { watch: data };
+    return { watch: this.validateGCalResponse(response).data };
+  };
+
+  stopWatch = async (
+    gcal: gCalendar,
+    params: Pick<Params_WatchEvents, "channelId" | "quotaUser"> & {
+      resourceId: string;
+    },
+  ) => {
+    const response = await gcal.channels.stop({
+      quotaUser: params.quotaUser,
+      requestBody: {
+        id: params.channelId,
+        resourceId: params.resourceId,
+      },
+    });
+
+    return this.validateGCalResponse(response);
   };
 }
 

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

@@ -34,7 +34,7 @@ interface InternalClient {
   sync: Collection<Schema_Sync>;
   user: Collection<Schema_User>;
   waitlist: Collection<Schema_Waitlist>;
-  watch: Collection<Omit<Schema_Watch, "_id">>;
+  watch: Collection<Schema_Watch>;
 }
 
 class MongoService {
@@ -144,7 +144,7 @@ class MongoService {
       sync: db.collection<Schema_Sync>(Collections.SYNC),
       user: db.collection<Schema_User>(Collections.USER),
       waitlist: db.collection<Schema_Waitlist>(Collections.WAITLIST),
-      watch: db.collection<Omit<Schema_Watch, "_id">>(Collections.WATCH),
+      watch: db.collection<Schema_Watch>(Collections.WATCH),
     };
   }
 

packages/backend/src/common/types/sync.types.ts

@@ -1,16 +1,16 @@
-import { DeleteResult, UpdateResult } from "mongodb";
+import { DeleteResult, InsertOneResult, UpdateResult } from "mongodb";
 import { Result_Watch_Stop } from "@core/types/sync.types";
 
 export interface Summary_Resync {
   _delete: {
     calendarlist?: UpdateResult;
     events?: DeleteResult;
-    eventWatches?: Result_Watch_Stop;
+    watches?: Result_Watch_Stop;
     sync?: UpdateResult;
   };
   recreate: {
     calendarlist?: UpdateResult;
-    eventWatches?: UpdateResult[];
+    watches?: InsertOneResult[];
     events?: "success";
     sync?: UpdateResult;
   };

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

@@ -528,7 +528,7 @@ export const _deleteGcal = async (
 
     const response = await gcalService.deleteEvent(gcal, gEventId);
 
-    return response.status < 300;
+    return response.status < 400;
   } catch (e) {
     const error = e as GaxiosError<gSchema$Event>;