chore: replace lodash.mergewith with ts-deepmerge

* refactor: remove lodash.mergewith dependency from package.json and bun.lock
* feat: update merge logic in user-metadata.service.ts and mock.setup.ts to use ts-deepmerge
* refactor: adjust mock setup in tests to eliminate lodash.mergewith usage

Author: tyler-dane

bun.lock

@@ -11,13 +11,13 @@
     "exponential-backoff": "^3.1.2",
     "express": "^4.17.1",
     "helmet": "^7.0.0",
-    "lodash.mergewith": "^4.6.2",
     "mongodb": "6.3",
     "morgan": "^1.10.0",
     "p-limit": "^7.2.0",
     "rrule": "^2.7.2",
     "saslprep": "^1.0.3",
     "supertokens-node": "^23.0.1",
+    "ts-deepmerge": "^7.0.3",
     "tslib": "^2.4.0"
   },
   "devDependencies": {
@@ -27,7 +27,6 @@
     "@types/cors": "^2.8.12",
     "@types/express": "^4.17.13",
     "@types/jest": "^29.0.0",
-    "@types/lodash.mergewith": "^4.6.9",
     "@types/morgan": "^1.9.4",
     "@types/node": "^22.13.10",
     "@types/supertest": "^6.0.3",

packages/backend/package.json

@@ -1,5 +1,4 @@
 import { type Handler, type NextFunction, type Response } from "express";
-import mergeWith from "lodash.mergewith";
 import { randomUUID } from "node:crypto";
 import { type SessionRequest } from "supertokens-node/framework/express";
 import {
@@ -211,12 +210,20 @@ function mockSuperTokens() {
   mockModule(
     "supertokens-node",
     (superTokens: typeof import("supertokens-node")) => {
-      const superTokensModule = mergeWith(superTokens, {
+      const mock = {
         getUserIdMapping: jest.fn(getUserIdMapping),
         createUserIdMapping: jest.fn(createUserIdMapping),
-      });
+        default: superTokens,
+      };
 
-      return mergeWith(superTokensModule, { default: superTokensModule });
+      for (const key in mock) {
+        try {
+          (superTokens as any)[key] = (mock as any)[key];
+        } catch (e) {
+          // skip read-only
+        }
+      }
+      return superTokens;
     },
   );
 
@@ -225,13 +232,19 @@ function mockSuperTokens() {
     (
       frameworkExpress: typeof import("supertokens-node/recipe/session/framework/express"),
     ) => {
-      const frameworkExpressModule = mergeWith(frameworkExpress, {
+      const mock = {
         verifySession: jest.fn(verifySession),
-      });
+        default: frameworkExpress,
+      };
 
-      return mergeWith(frameworkExpressModule, {
-        default: frameworkExpressModule,
-      });
+      for (const key in mock) {
+        try {
+          (frameworkExpress as any)[key] = (mock as any)[key];
+        } catch (e) {
+          // skip read-only
+        }
+      }
+      return frameworkExpress;
     },
   );
 
@@ -240,12 +253,20 @@ function mockSuperTokens() {
     (
       recipeUserMetadata: typeof import("supertokens-node/recipe/usermetadata"),
     ) => {
-      const userMetadataModule = mergeWith(recipeUserMetadata, {
+      const mock = {
         updateUserMetadata: jest.fn(updateUserMetadata),
         getUserMetadata: jest.fn(getUserMetadata),
-      });
+        default: recipeUserMetadata,
+      };
 
-      return mergeWith(userMetadataModule, { default: userMetadataModule });
+      for (const key in mock) {
+        try {
+          (recipeUserMetadata as any)[key] = (mock as any)[key];
+        } catch (e) {
+          // skip read-only
+        }
+      }
+      return recipeUserMetadata;
     },
   );
 
@@ -257,34 +278,35 @@ function mockSuperTokens() {
       const getInstanceOrThrowError =
         session.default.getInstanceOrThrowError.bind(session.default);
 
-      const sessionModule = mergeWith(session, {
-        default: mergeWith(session.default, {
-          getInstanceOrThrowError: jest.fn(() => {
-            const instance = getInstanceOrThrowError();
-
-            return mergeWith(instance, {
-              apiImpl: mergeWith(instance.apiImpl, {
-                verifySession: jest.fn(
-                  async (input: {
-                    verifySessionOptions: VerifySessionOptions | undefined;
-                    options: APIOptions;
-                    userContext: UserContext;
-                  }) => {
-                    const req = input.options.req as ExpressRequest;
-                    const res = input.options.res as ExpressResponse;
-
-                    verifySession(input)(req.original, res.original);
-
-                    return Promise.resolve(req.original.session);
-                  },
-                ),
-              }),
-            });
-          }),
-        }),
-      });
-
-      return sessionModule;
+      try {
+        session.default.getInstanceOrThrowError = jest.fn(() => {
+          const instance = getInstanceOrThrowError();
+
+          try {
+            instance.apiImpl.verifySession = jest.fn(
+              async (input: {
+                verifySessionOptions: VerifySessionOptions | undefined;
+                options: APIOptions;
+                userContext: UserContext;
+              }) => {
+                const req = input.options.req as ExpressRequest;
+                const res = input.options.res as ExpressResponse;
+
+                verifySession(input)(req.original, res.original);
+
+                return Promise.resolve(req.original.session);
+              },
+            );
+          } catch (e) {
+            // ignore
+          }
+          return instance;
+        });
+      } catch (e) {
+        // ignore
+      }
+
+      return session;
     },
   );
 }

packages/backend/src/__tests__/helpers/mock.setup.ts

@@ -1,7 +1,7 @@
-import mergeWith from "lodash.mergewith";
 import SupertokensUserMetadata, {
   type JSONObject,
 } from "supertokens-node/recipe/usermetadata";
+import { merge } from "ts-deepmerge";
 import { Resource_Sync } from "@core/types/sync.types";
 import {
   type GoogleConnectionState,
@@ -126,7 +126,7 @@ class UserMetadataService {
     data: Partial<UserMetadata>;
   }): Promise<UserMetadata> => {
     const value = await this.getStoredUserMetadata(userId);
-    const update = mergeWith(value, data) as UserMetadata;
+    const update = merge(value, data) as UserMetadata;
 
     const result = (await SupertokensUserMetadata.updateUserMetadata(
       userId,

packages/backend/src/user/services/user-metadata.service.ts

@@ -16,6 +16,7 @@
     "eventemitter2": "^6.4.9",
     "rxjs": "^7.8.2",
     "tinycolor2": "^1.6.0",
+    "ts-deepmerge": "^7.0.3",
     "winston": "^3.8.1",
     "zod": "^3.25.76"
   }

packages/core/package.json

@@ -1,4 +1,3 @@
-import { default as mockMergeWith } from "lodash.mergewith";
 import { faker as mockFaker } from "@faker-js/faker";
 
 export const mockBSON = () => {
@@ -32,11 +31,23 @@ export function mockModule<T>(
 ) {
   const mockedModule = jest.requireActual(mockPath);
 
-  jest.mock<T>(mockPath, () =>
-    mockMergeWith(
-      { __esModule: mockAsEsModule },
-      mockedModule,
-      mockFactory(mockedModule),
-    ),
-  );
+  jest.mock<T>(mockPath, () => {
+    const mock = mockFactory(mockedModule);
+    for (const key in mock) {
+      try {
+        (mockedModule as any)[key] = (mock as any)[key];
+      } catch (e) {
+        // skip read-only
+      }
+    }
+    try {
+      Object.defineProperty(mockedModule, "__esModule", {
+        value: mockAsEsModule,
+        configurable: true,
+      });
+    } catch (e) {
+      // ignore
+    }
+    return mockedModule as T;
+  });
 }

packages/core/src/__tests__/mock.setup.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-namespace */
-import mergeWith from "lodash.mergewith";
+import { merge } from "ts-deepmerge";
 import { Origin, Priorities } from "@core/constants/core.constants";
 import { BaseError } from "@core/errors/errors.base";
 import {
@@ -200,11 +200,10 @@ export const gEventToCompassEvent = (
     );
   }
 
-  const event: WithGcalId<gSchema$Event> = mergeWith(
-    {},
+  const event: WithGcalId<gSchema$Event> = merge(
     gEventDefaults,
     gEvent,
-  );
+  ) as WithGcalId<gSchema$Event>;
 
   const { id: gEventId, description } = event;
   const title = event.summary!;