Feat/status-handling-refactor

.cursorrules/testing.md

@@ -73,6 +73,7 @@ const button = container.querySelector('.add-button');
 - Use async/await for asynchronous tests
 - Mock external services (Google Calendar API, MongoDB) appropriately
 - Test error handling and edge cases
+- **Do not import `mongoService` or other persistence layers directly in tests.** Use the test drivers in `packages/backend/src/__tests__/drivers/` (e.g. `UserDriver`, `WatchDriver`) so that tests stay agnostic of the backing store and switching away from Mongo later does not require test changes.
 
 **Real examples:**
 

.husky/pre-commit

@@ -1,4 +1,4 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
-yarn lint-staged
+yarn lint-staged --quiet

docs/testing-playbook.md

@@ -209,9 +209,12 @@ Preferred style:
 - realistic request flows when possible
 - mock only external services, not internal business logic
 
+**Do not import `mongoService` (or other persistence implementations) directly in tests.** Use test drivers instead (e.g. `UserDriver`, `WatchDriver` in `packages/backend/src/__tests__/drivers/`). Drivers encapsulate persistence so that switching away from Mongo (or another store) in the future does not require changing test code.
+
 Useful anchors:
 
 - `packages/backend/src/__tests__`
+- `packages/backend/src/__tests__/drivers/`
 - `packages/backend/src/event/services/*.test.ts`
 - `packages/backend/src/sync/**/*.test.ts`
 

package.json

@@ -29,7 +29,7 @@
     "postinstall": "husky install | chmod ug+x .husky/*",
     "test": "cross-env TZ=Etc/UTC ./node_modules/.bin/jest",
     "test:e2e": "playwright test",
-    "test:backend": "yarn test backend",
+    "test:backend": "cross-env TZ=Etc/UTC ./node_modules/.bin/jest --selectProjects backend",
     "test:core": "yarn test core",
     "test:web": "cross-env TZ=Etc/UTC ./node_modules/.bin/jest web",
     "test:scripts": "yarn test scripts",

packages/backend/src/__tests__/drivers/sync.controller.driver.ts

@@ -1,9 +1,5 @@
 import request from "supertest";
 import { GCAL_NOTIFICATION_ENDPOINT } from "@core/constants/core.constants";
-import {
-  IMPORT_GCAL_END,
-  IMPORT_GCAL_START,
-} from "@core/constants/websocket.constants";
 import { Status } from "@core/errors/status.codes";
 import { type Payload_Sync_Notif } from "@core/types/sync.types";
 import { type BaseDriver } from "@backend/__tests__/drivers/base.driver";
@@ -12,33 +8,6 @@ import { encodeChannelToken } from "@backend/sync/util/watch.util";
 export class SyncControllerDriver {
   constructor(private readonly baseDriver: BaseDriver) {}
 
-  async waitUntilImportGCalStart<Result = unknown[]>(
-    websocketClient: ReturnType<BaseDriver["createWebsocketClient"]>,
-    beforeEvent: () => Promise<unknown> = () => Promise.resolve(),
-    afterEvent: (...args: void[]) => Promise<Result> = (...args) =>
-      Promise.resolve(args as Result),
-  ): Promise<Result> {
-    return this.baseDriver.waitUntilWebsocketEvent<void[], Result>(
-      websocketClient,
-      IMPORT_GCAL_START,
-      beforeEvent,
-      afterEvent,
-    );
-  }
-
-  async waitUntilImportGCalEnd<Result = unknown[]>(
-    websocketClient: ReturnType<BaseDriver["createWebsocketClient"]>,
-    beforeEvent: () => Promise<unknown> = () => Promise.resolve(),
-    afterEvent: (...args: [string | undefined]) => Promise<Result> = (
-      ...args
-    ) => Promise.resolve(args as Result),
-  ): Promise<Result> {
-    return this.baseDriver.waitUntilWebsocketEvent<
-      [string | undefined],
-      Result
-    >(websocketClient, IMPORT_GCAL_END, beforeEvent, afterEvent);
-  }
-
   async handleGoogleNotification(
     {
       token,
@@ -64,12 +33,14 @@ export class SyncControllerDriver {
 
   async importGCal(
     session?: { userId: string },
+    body?: { force?: boolean },
     status: Status = Status.NO_CONTENT,
   ): Promise<
     Omit<request.Response, "body"> & { body: { id: string; status: string } }
   > {
     return request(this.baseDriver.getServerUri())
       .post("/api/sync/import-gcal")
+      .send(body)
       .use(this.baseDriver.setSessionPlugin(session))
       .expect(status);
   }

packages/backend/src/__tests__/drivers/user-metadata.service.driver.ts

@@ -0,0 +1,19 @@
+import type { JSONObject } from "supertokens-node/recipe/usermetadata";
+import { type UserMetadata } from "@core/types/user.types";
+import userMetadataService from "@backend/user/services/user-metadata.service";
+
+export class UserMetadataServiceDriver {
+  updateUserMetadata(params: {
+    userId: string;
+    data: Partial<UserMetadata>;
+  }): Promise<UserMetadata> {
+    return userMetadataService.updateUserMetadata(params);
+  }
+
+  fetchUserMetadata(
+    userId: string,
+    userContext?: Record<string, JSONObject>,
+  ): Promise<UserMetadata> {
+    return userMetadataService.fetchUserMetadata(userId, userContext);
+  }
+}

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

@@ -7,6 +7,8 @@ import userService from "../../user/services/user.service";
 
 interface CreateUserOptions {
   withGoogleRefreshToken?: boolean;
+  /** When false, creates a user with no Google data (never connected). */
+  withGoogle?: boolean;
 }
 
 export class UserDriver {
@@ -38,7 +40,7 @@ export class UserDriver {
   static async createUser(
     options: CreateUserOptions = {},
   ): Promise<WithId<Schema_User>> {
-    const { withGoogleRefreshToken = true } = options;
+    const { withGoogleRefreshToken = true, withGoogle = true } = options;
     const gUser = UserDriver.generateGoogleUser();
     const gRefreshToken = faker.internet.jwt();
 
@@ -49,6 +51,14 @@ export class UserDriver {
 
     const _id = new ObjectId(userId);
 
+    // Simulate "user never connected Google" by removing all Google data
+    if (!withGoogle) {
+      await mongoService.user.updateOne({ _id }, { $unset: { google: "" } });
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars -- intentionally omit google from returned user
+      const { google: _google, ...rest } = user;
+      return { ...rest, _id };
+    }
+
     // Remove refresh token if requested (simulates revoked token scenario)
     if (!withGoogleRefreshToken) {
       await mongoService.user.updateOne(
@@ -67,6 +77,8 @@ export class UserDriver {
   }
 
   static async createUsers(count: number): Promise<Array<WithId<Schema_User>>> {
-    return Promise.all(Array.from({ length: count }, UserDriver.createUser));
+    return Promise.all(
+      Array.from({ length: count }, () => UserDriver.createUser()),
+    );
   }
 }

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

@@ -0,0 +1,14 @@
+import mongoService from "@backend/common/services/mongo.service";
+
+/**
+ * Test driver for the watch collection.
+ * Use this instead of importing mongoService in tests so persistence can be
+ * swapped (e.g. away from Mongo) without changing test code.
+ */
+export class WatchDriver {
+  static deleteManyByUser(
+    userId: string,
+  ): ReturnType<typeof mongoService.watch.deleteMany> {
+    return mongoService.watch.deleteMany({ user: userId });
+  }
+}

packages/backend/src/auth/schemas/reconnect-google.schemas.ts

@@ -8,12 +8,12 @@ export type ParsedReconnectGoogleParams = {
 };
 
 export function parseReconnectGoogleParams(
-  sessionUserId: string,
+  compassUserId: string,
   gUser: TokenPayload,
   oAuthTokens: Pick<Credentials, "refresh_token" | "access_token">,
 ): ParsedReconnectGoogleParams {
   const cUserId = zObjectId
-    .parse(sessionUserId, { error: () => "Invalid credentials" })
+    .parse(compassUserId, { error: () => "Invalid credentials" })
     .toString();
   StringV4Schema.parse(gUser.sub, { error: () => "Invalid Google user ID" });
   const refreshToken = StringV4Schema.parse(oAuthTokens.refresh_token, {