remove lodash from config, result, user, config, redis

fehmer · fehmer · commit fd0959cc882f · 2025-09-22T19:53:26.000+05:30
diff --git a/backend/__tests__/__integration__/dal/config.spec.ts b/backend/__tests__/__integration__/dal/config.spec.ts
@@ -0,0 +1,42 @@
+import { ObjectId } from "mongodb";
+import { describe, expect, it } from "vitest";
+import * as ConfigDal from "../../../src/dal/config";
+
+const getConfigCollection = ConfigDal.__testing.getConfigCollection;
+
+describe("ConfigDal", () => {
+  describe("saveConfig", () => {
+    it("should save and update user configuration correctly", async () => {
+      //GIVEN
+      const uid = new ObjectId().toString();
+      await getConfigCollection().insertOne({
+        uid,
+        config: {
+          ads: "on",
+          time: 60,
+          quickTab: true, //legacy value
+        },
+      } as any);
+
+      //WHEN
+      await ConfigDal.saveConfig(uid, {
+        ads: "on",
+        difficulty: "normal",
+      } as any);
+
+      //WHEN
+      await ConfigDal.saveConfig(uid, { ads: "off" });
+
+      //THEN
+      const savedConfig = (await ConfigDal.getConfig(
+        uid
+      )) as ConfigDal.DBConfig;
+
+      expect(savedConfig.config.ads).toBe("off");
+      expect(savedConfig.config.time).toBe(60);
+
+      //should remove legacy values
+      expect((savedConfig.config as any)["quickTab"]).toBeUndefined();
+    });
+  });
+});
diff --git a/backend/__tests__/__integration__/dal/result.spec.ts b/backend/__tests__/__integration__/dal/result.spec.ts
@@ -50,7 +50,7 @@ async function createDummyData(
         tags: [],
         consistency: 100,
         keyConsistency: 100,
-        chartData: { wpm: [], raw: [], err: [] },
+        chartData: { wpm: [], burst: [], err: [] },
         uid,
         keySpacingStats: { average: 0, sd: 0 },
         keyDurationStats: { average: 0, sd: 0 },
diff --git a/backend/__tests__/__integration__/dal/user.spec.ts b/backend/__tests__/__integration__/dal/user.spec.ts
@@ -1180,7 +1180,6 @@ describe("UserDal", () => {
         discordId: "discordId",
         discordAvatar: "discordAvatar",
       });
-
       //when
       await UserDAL.linkDiscord(uid, "newId", "newAvatar");
 
@@ -1189,6 +1188,21 @@ describe("UserDal", () => {
       expect(read.discordId).toEqual("newId");
       expect(read.discordAvatar).toEqual("newAvatar");
     });
+    it("should update without avatar", async () => {
+      //given
+      const { uid } = await UserTestData.createUser({
+        discordId: "discordId",
+        discordAvatar: "discordAvatar",
+      });
+
+      //when
+      await UserDAL.linkDiscord(uid, "newId");
+
+      //then
+      const read = await UserDAL.getUser(uid, "read");
+      expect(read.discordId).toEqual("newId");
+      expect(read.discordAvatar).toEqual("discordAvatar");
+    });
   });
   describe("unlinkDiscord", () => {
     it("throws for nonexisting user", async () => {
diff --git a/backend/__tests__/utils/misc.spec.ts b/backend/__tests__/utils/misc.spec.ts
@@ -453,4 +453,46 @@ describe("Misc Utils", () => {
       });
     });
   });
+
+  describe("isPlainObject", () => {
+    it("should return true for plain objects", () => {
+      expect(Misc.isPlainObject({})).toBe(true);
+      expect(Misc.isPlainObject({ a: 1, b: 2 })).toBe(true);
+      expect(Misc.isPlainObject(Object.create(Object.prototype))).toBe(true);
+    });
+
+    it("should return false for arrays", () => {
+      expect(Misc.isPlainObject([])).toBe(false);
+      expect(Misc.isPlainObject([1, 2, 3])).toBe(false);
+    });
+
+    it("should return false for null", () => {
+      expect(Misc.isPlainObject(null)).toBe(false);
+    });
+
+    it("should return false for primitives", () => {
+      expect(Misc.isPlainObject(123)).toBe(false);
+      expect(Misc.isPlainObject("string")).toBe(false);
+      expect(Misc.isPlainObject(true)).toBe(false);
+      expect(Misc.isPlainObject(undefined)).toBe(false);
+      expect(Misc.isPlainObject(Symbol("sym"))).toBe(false);
+    });
+
+    it("should return false for objects with different prototypes", () => {
+      // oxlint-disable-next-line no-extraneous-class
+      class MyClass {}
+      expect(Misc.isPlainObject(new MyClass())).toBe(false);
+      expect(Misc.isPlainObject(Object.create(null))).toBe(false);
+      expect(Misc.isPlainObject(new Date())).toBe(false);
+      expect(Misc.isPlainObject(new Map())).toBe(false);
+      expect(Misc.isPlainObject(new Set())).toBe(false);
+    });
+
+    it("should return false for functions", () => {
+      // oxlint-disable-next-line no-empty-function
+      expect(Misc.isPlainObject(function () {})).toBe(false);
+      // oxlint-disable-next-line no-empty-function
+      expect(Misc.isPlainObject(() => {})).toBe(false);
+    });
+  });
 });
diff --git a/backend/src/dal/config.ts b/backend/src/dal/config.ts
@@ -1,51 +1,47 @@
 import { Collection, ObjectId, UpdateResult } from "mongodb";
 import * as db from "../init/db";
-import _ from "lodash";
 import { Config, PartialConfig } from "@monkeytype/schemas/configs";
 
-const configLegacyProperties = [
-  "swapEscAndTab",
-  "quickTab",
-  "chartStyle",
-  "chartAverage10",
-  "chartAverage100",
-  "alwaysShowCPM",
-  "resultFilters",
-  "chartAccuracy",
-  "liveSpeed",
-  "extraTestColor",
-  "savedLayout",
-  "showTimerBar",
-  "showDiscordDot",
-  "maxConfidence",
-  "capsLockBackspace",
-  "showAvg",
-  "enableAds",
-];
-
-type DBConfig = {
+const configLegacyProperties: Record<string, ""> = {
+  "config.swapEscAndTab": "",
+  "config.quickTab": "",
+  "config.chartStyle": "",
+  "config.chartAverage10": "",
+  "config.chartAverage100": "",
+  "config.alwaysShowCPM": "",
+  "config.resultFilters": "",
+  "config.chartAccuracy": "",
+  "config.liveSpeed": "",
+  "config.extraTestColor": "",
+  "config.savedLayout": "",
+  "config.showTimerBar": "",
+  "config.showDiscordDot": "",
+  "config.maxConfidence": "",
+  "config.capsLockBackspace": "",
+  "config.showAvg": "",
+  "config.enableAds": "",
+};
+
+export type DBConfig = {
   _id: ObjectId;
   uid: string;
   config: PartialConfig;
 };
 
-// Export for use in tests
-export const getConfigCollection = (): Collection<DBConfig> =>
+const getConfigCollection = (): Collection<DBConfig> =>
   db.collection<DBConfig>("configs");
 
 export async function saveConfig(
   uid: string,
   config: Partial<Config>
 ): Promise<UpdateResult> {
-  const configChanges = _.mapKeys(config, (_value, key) => `config.${key}`);
-
-  const unset = _.fromPairs(
-    _.map(configLegacyProperties, (key) => [`config.${key}`, ""])
-  ) as Record<string, "">;
+  const configChanges = Object.fromEntries(
+    Object.entries(config).map(([key, value]) => [`config.${key}`, value])
+  );
 
   return await getConfigCollection().updateOne(
     { uid },
-    { $set: configChanges, $unset: unset },
+    { $set: configChanges, $unset: configLegacyProperties },
     { upsert: true }
   );
 }
@@ -58,3 +54,7 @@ export async function getConfig(uid: string): Promise<DBConfig | null> {
 export async function deleteConfig(uid: string): Promise<void> {
   await getConfigCollection().deleteOne({ uid });
 }
+
+export const __testing = {
+  getConfigCollection,
+};
diff --git a/backend/src/dal/result.ts b/backend/src/dal/result.ts
@@ -1,7 +1,7 @@
-import _ from "lodash";
 import {
   Collection,
   type DeleteResult,
+  Filter,
   ObjectId,
   type UpdateResult,
 } from "mongodb";
@@ -111,24 +111,21 @@ export async function getResults(
   opts?: GetResultsOpts
 ): Promise<DBResult[]> {
   const { onOrAfterTimestamp, offset, limit } = opts ?? {};
+
+  const condition: Filter<DBResult> = { uid };
+  if (onOrAfterTimestamp !== undefined && !isNaN(onOrAfterTimestamp)) {
+    condition.timestamp = { $gte: onOrAfterTimestamp };
+  }
+
   let query = getResultCollection()
-    .find(
-      {
-        uid,
-        ...(!_.isNil(onOrAfterTimestamp) &&
-          !_.isNaN(onOrAfterTimestamp) && {
-            timestamp: { $gte: onOrAfterTimestamp },
-          }),
+    .find(condition, {
+      projection: {
+        chartData: 0,
+        keySpacingStats: 0,
+        keyDurationStats: 0,
+        name: 0,
       },
-      {
-        projection: {
-          chartData: 0,
-          keySpacingStats: 0,
-          keyDurationStats: 0,
-          name: 0,
-        },
-      }
-    )
+    })
     .sort({ timestamp: -1 });
 
   if (limit !== undefined) {
diff --git a/backend/src/dal/user.ts b/backend/src/dal/user.ts
@@ -9,7 +9,7 @@ import {
   type UpdateFilter,
   type Filter,
 } from "mongodb";
-import { flattenObjectDeep, WithObjectId } from "../utils/misc";
+import { flattenObjectDeep, isPlainObject, WithObjectId } from "../utils/misc";
 import { getCachedConfiguration } from "../init/configuration";
 import { getDayOfYear } from "date-fns";
 import { UTCDate } from "@date-fns/utc";
@@ -601,10 +601,10 @@ export async function linkDiscord(
   discordId: string,
   discordAvatar?: string
 ): Promise<void> {
-  const updates: Partial<DBUser> = _.pickBy(
-    { discordId, discordAvatar },
-    _.identity
-  );
+  const updates: Partial<DBUser> = { discordId };
+  if (discordAvatar !== undefined && discordAvatar !== null)
+    updates.discordAvatar = discordAvatar;
+
   await updateUser({ uid }, { $set: updates }, { stack: "link discord" });
 }
 
@@ -907,8 +907,7 @@ export async function updateProfile(
 ): Promise<void> {
   const profileUpdates = _.omitBy(
     flattenObjectDeep(profileDetailUpdates, "profileDetails"),
-    (value) =>
-      value === undefined || (_.isPlainObject(value) && _.isEmpty(value))
+    (value) => value === undefined || (isPlainObject(value) && _.isEmpty(value))
   );
 
   const updates = {
diff --git a/backend/src/init/configuration.ts b/backend/src/init/configuration.ts
@@ -2,7 +2,7 @@ import _ from "lodash";
 import * as db from "./db";
 import { ObjectId } from "mongodb";
 import Logger from "../utils/logger";
-import { identity, omit } from "../utils/misc";
+import { identity, isPlainObject, omit } from "../utils/misc";
 import { BASE_CONFIGURATION } from "../constants/base-configuration";
 import { Configuration } from "@monkeytype/schemas/configuration";
 import { addLog } from "../dal/logs";
@@ -26,10 +26,7 @@ function mergeConfigurations(
   baseConfiguration: Configuration,
   liveConfiguration: PartialConfiguration
 ): void {
-  if (
-    !_.isPlainObject(baseConfiguration) ||
-    !_.isPlainObject(liveConfiguration)
-  ) {
+  if (!isPlainObject(baseConfiguration) || !isPlainObject(liveConfiguration)) {
     return;
   }
 
@@ -40,8 +37,8 @@ function mergeConfigurations(
       const baseValue = base[key] as object;
       const sourceValue = source[key] as object;
 
-      const isBaseValueObject = _.isPlainObject(baseValue);
-      const isSourceValueObject = _.isPlainObject(sourceValue);
+      const isBaseValueObject = isPlainObject(baseValue);
+      const isSourceValueObject = isPlainObject(sourceValue);
 
       if (isBaseValueObject && isSourceValueObject) {
         merge(baseValue, sourceValue);
diff --git a/backend/src/init/redis.ts b/backend/src/init/redis.ts
@@ -1,5 +1,4 @@
 import fs from "fs";
-import _ from "lodash";
 import { join } from "path";
 import IORedis, { Redis } from "ioredis";
 import Logger from "../utils/logger";
@@ -50,10 +49,14 @@ const REDIS_SCRIPTS_DIRECTORY_PATH = join(__dirname, "../../redis-scripts");
 function loadScripts(client: IORedis.Redis): void {
   const scriptFiles = fs.readdirSync(REDIS_SCRIPTS_DIRECTORY_PATH);
 
+  const toCamelCase = (kebab: string): string => {
+    return kebab.replace(/-([a-z])/g, (_, char: string) => char.toUpperCase());
+  };
+
   scriptFiles.forEach((scriptFile) => {
     const scriptPath = join(REDIS_SCRIPTS_DIRECTORY_PATH, scriptFile);
     const scriptSource = fs.readFileSync(scriptPath, "utf-8");
-    const scriptName = _.camelCase(scriptFile.split(".")[0]);
+    const scriptName = toCamelCase(scriptFile.split(".")[0] as string);
 
     client.defineCommand(scriptName, {
       lua: scriptSource,
diff --git a/backend/src/utils/misc.ts b/backend/src/utils/misc.ts
@@ -1,6 +1,5 @@
 import { MILLISECONDS_IN_DAY } from "@monkeytype/util/date-and-time";
 import { roundTo2 } from "@monkeytype/util/numbers";
-import _ from "lodash";
 import uaparser from "ua-parser-js";
 import { MonkeyRequest } from "../api/types";
 import { ObjectId } from "mongodb";
@@ -97,7 +96,7 @@ export function flattenObjectDeep(
 
     const newPrefix = prefix.length > 0 ? `${prefix}.${key}` : key;
 
-    if (_.isPlainObject(value)) {
+    if (isPlainObject(value)) {
       const flattened = flattenObjectDeep(value as Record<string, unknown>);
       const flattenedKeys = Object.keys(flattened);
 
@@ -252,3 +251,11 @@ export function omit<T extends object, K extends keyof T>(
   }
   return result;
 }
+
+export function isPlainObject(value: unknown): boolean {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    Object.getPrototypeOf(value) === Object.prototype
+  );
+}
