refactor: remove lodash omit from backend (@fehmer)

Author: fehmer

backend/__tests__/utils/misc.spec.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, afterAll, vi } from "vitest";
 import _ from "lodash";
-import * as misc from "../../src/utils/misc";
+import * as Misc from "../../src/utils/misc";
 import { ObjectId } from "mongodb";
 
 describe("Misc Utils", () => {
@@ -32,7 +32,7 @@ describe("Misc Utils", () => {
     _.each(testCases, (testCase, pattern) => {
       const { cases, expected } = testCase;
       _.each(cases, (caseValue, index) => {
-        expect(misc.matchesAPattern(caseValue, pattern)).toBe(expected[index]);
+        expect(Misc.matchesAPattern(caseValue, pattern)).toBe(expected[index]);
       });
     });
   });
@@ -80,7 +80,7 @@ describe("Misc Utils", () => {
     ];
 
     _.each(testCases, ({ wpm, acc, timestamp, expectedScore }) => {
-      expect(misc.kogascore(wpm, acc, timestamp)).toBe(expectedScore);
+      expect(Misc.kogascore(wpm, acc, timestamp)).toBe(expectedScore);
     });
   });
 
@@ -109,7 +109,7 @@ describe("Misc Utils", () => {
     ];
 
     _.each(testCases, ({ input, expected }) => {
-      expect(misc.identity(input)).toEqual(expected);
+      expect(Misc.identity(input)).toEqual(expected);
     });
   });
 
@@ -178,7 +178,7 @@ describe("Misc Utils", () => {
     ];
 
     _.each(testCases, ({ obj, expected }) => {
-      expect(misc.flattenObjectDeep(obj)).toEqual(expected);
+      expect(Misc.flattenObjectDeep(obj)).toEqual(expected);
     });
   });
 
@@ -215,7 +215,7 @@ describe("Misc Utils", () => {
     ];
 
     testCases.forEach(({ input, expected }) => {
-      expect(misc.sanitizeString(input)).toEqual(expected);
+      expect(Misc.sanitizeString(input)).toEqual(expected);
     });
   });
 
@@ -284,7 +284,7 @@ describe("Misc Utils", () => {
     ];
 
     testCases.forEach(({ input, output }) => {
-      expect(misc.getOrdinalNumberString(input)).toEqual(output);
+      expect(Misc.getOrdinalNumberString(input)).toEqual(output);
     });
   });
   it("formatSeconds", () => {
@@ -298,45 +298,45 @@ describe("Misc Utils", () => {
         expected: "1.08 minutes",
       },
       {
-        seconds: misc.HOUR_IN_SECONDS,
+        seconds: Misc.HOUR_IN_SECONDS,
         expected: "1 hour",
       },
       {
-        seconds: misc.DAY_IN_SECONDS,
+        seconds: Misc.DAY_IN_SECONDS,
         expected: "1 day",
       },
       {
-        seconds: misc.WEEK_IN_SECONDS,
+        seconds: Misc.WEEK_IN_SECONDS,
         expected: "1 week",
       },
       {
-        seconds: misc.YEAR_IN_SECONDS,
+        seconds: Misc.YEAR_IN_SECONDS,
         expected: "1 year",
       },
       {
-        seconds: 2 * misc.YEAR_IN_SECONDS,
+        seconds: 2 * Misc.YEAR_IN_SECONDS,
         expected: "2 years",
       },
       {
-        seconds: 4 * misc.YEAR_IN_SECONDS,
+        seconds: 4 * Misc.YEAR_IN_SECONDS,
         expected: "4 years",
       },
       {
-        seconds: 3 * misc.WEEK_IN_SECONDS,
+        seconds: 3 * Misc.WEEK_IN_SECONDS,
         expected: "3 weeks",
       },
       {
-        seconds: misc.MONTH_IN_SECONDS * 4,
+        seconds: Misc.MONTH_IN_SECONDS * 4,
         expected: "4 months",
       },
       {
-        seconds: misc.MONTH_IN_SECONDS * 11,
+        seconds: Misc.MONTH_IN_SECONDS * 11,
         expected: "11 months",
       },
     ];
 
     testCases.forEach(({ seconds, expected }) => {
-      expect(misc.formatSeconds(seconds)).toBe(expected);
+      expect(Misc.formatSeconds(seconds)).toBe(expected);
     });
   });
 
@@ -347,14 +347,14 @@ describe("Misc Utils", () => {
         test: "test",
         number: 1,
       };
-      expect(misc.replaceObjectId(fromDatabase)).toStrictEqual({
+      expect(Misc.replaceObjectId(fromDatabase)).toStrictEqual({
         _id: fromDatabase._id.toHexString(),
         test: "test",
         number: 1,
       });
     });
     it("ignores null values", () => {
-      expect(misc.replaceObjectId(null)).toBeNull();
+      expect(Misc.replaceObjectId(null)).toBeNull();
     });
   });
 
@@ -371,7 +371,7 @@ describe("Misc Utils", () => {
         number: 2,
       };
       expect(
-        misc.replaceObjectIds([fromDatabase, fromDatabase2])
+        Misc.replaceObjectIds([fromDatabase, fromDatabase2])
       ).toStrictEqual([
         {
           _id: fromDatabase._id.toHexString(),
@@ -386,7 +386,56 @@ describe("Misc Utils", () => {
       ]);
     });
     it("handles undefined", () => {
-      expect(misc.replaceObjectIds(undefined as any)).toBeUndefined();
+      expect(Misc.replaceObjectIds(undefined as any)).toBeUndefined();
+    });
+  });
+
+  describe("omit()", () => {
+    it("should omit a single key", () => {
+      const input = { a: 1, b: 2, c: 3 };
+      const result = Misc.omit(input, "b");
+      expect(result).toEqual({ a: 1, c: 3 });
+    });
+
+    it("should omit multiple keys", () => {
+      const input = { a: 1, b: 2, c: 3, d: 4 };
+      const result = Misc.omit(input, "a", "d");
+      expect(result).toEqual({ b: 2, c: 3 });
+    });
+
+    it("should return the same object if no keys are omitted", () => {
+      const input = { x: 1, y: 2 };
+      const result = Misc.omit(input);
+      expect(result).toEqual({ x: 1, y: 2 });
+    });
+
+    it("should not mutate the original object", () => {
+      const input = { foo: "bar", baz: "qux" };
+      const copy = { ...input };
+      Misc.omit(input, "baz");
+      expect(input).toEqual(copy);
+    });
+
+    it("should ignore keys that do not exist", () => {
+      const input = { a: 1, b: 2 };
+      const result = Misc.omit(input, "c" as any); // allow a non-existing key
+      expect(result).toEqual({ a: 1, b: 2 });
+    });
+
+    it("should work with different value types", () => {
+      const input = {
+        str: "hello",
+        num: 123,
+        bool: true,
+        obj: { x: 1 },
+        arr: [1, 2, 3],
+      };
+      const result = Misc.omit(input, "bool", "arr");
+      expect(result).toEqual({
+        str: "hello",
+        num: 123,
+        obj: { x: 1 },
+      });
     });
   });
 });

backend/src/api/controllers/ape-key.ts

@@ -1,10 +1,9 @@
-import _ from "lodash";
 import { randomBytes } from "crypto";
 import { hash } from "bcrypt";
 import * as ApeKeysDAL from "../../dal/ape-keys";
 import MonkeyError from "../../utils/error";
 import { MonkeyResponse } from "../../utils/monkey-response";
-import { base64UrlEncode } from "../../utils/misc";
+import { base64UrlEncode, omit } from "../../utils/misc";
 import { ObjectId } from "mongodb";
 
 import {
@@ -18,7 +17,7 @@ import { ApeKey } from "@monkeytype/schemas/ape-keys";
 import { MonkeyRequest } from "../types";
 
 function cleanApeKey(apeKey: ApeKeysDAL.DBApeKey): ApeKey {
-  return _.omit(apeKey, "hash", "_id", "uid", "useCount");
+  return omit(apeKey, "hash", "_id", "uid", "useCount") as ApeKey;
 }
 
 export async function getApeKeys(
@@ -27,7 +26,9 @@ export async function getApeKeys(
   const { uid } = req.ctx.decodedToken;
 
   const apeKeys = await ApeKeysDAL.getApeKeys(uid);
-  const cleanedKeys = _(apeKeys).keyBy("_id").mapValues(cleanApeKey).value();
+  const cleanedKeys: Record<string, ApeKey> = Object.fromEntries(
+    apeKeys.map((item) => [String(item._id), cleanApeKey(item)])
+  );
 
   return new MonkeyResponse("ApeKeys retrieved", cleanedKeys);
 }

backend/src/api/controllers/leaderboard.ts

@@ -1,4 +1,3 @@
-import _ from "lodash";
 import { MonkeyResponse } from "../../utils/monkey-response";
 import * as LeaderboardsDAL from "../../dal/leaderboards";
 import MonkeyError from "../../utils/error";
@@ -26,6 +25,7 @@ import {
   MILLISECONDS_IN_DAY,
 } from "@monkeytype/util/date-and-time";
 import { MonkeyRequest } from "../types";
+import { omit } from "../../utils/misc";
 
 export async function getLeaderboard(
   req: MonkeyRequest<GetLeaderboardQuery>
@@ -57,7 +57,7 @@ export async function getLeaderboard(
   }
 
   const count = await LeaderboardsDAL.getCount(mode, mode2, language);
-  const normalizedLeaderboard = leaderboard.map((it) => _.omit(it, ["_id"]));
+  const normalizedLeaderboard = leaderboard.map((it) => omit(it, "_id"));
 
   return new MonkeyResponse("Leaderboard retrieved", {
     count,

backend/src/api/controllers/user.ts

@@ -9,6 +9,7 @@ import * as DiscordUtils from "../../utils/discord";
 import {
   buildAgentLog,
   getFrontendUrl,
+  omit,
   replaceObjectId,
   replaceObjectIds,
   sanitizeString,
@@ -511,7 +512,8 @@ type RelevantUserInfo = Omit<
 >;
 
 function getRelevantUserInfo(user: UserDAL.DBUser): RelevantUserInfo {
-  return _.omit(user, [
+  return omit(
+    user,
     "bananas",
     "lbPersonalBests",
     "inbox",
@@ -522,8 +524,8 @@ function getRelevantUserInfo(user: UserDAL.DBUser): RelevantUserInfo {
     "note",
     "ips",
     "testActivity",
-    "suspicious",
-  ]) as RelevantUserInfo;
+    "suspicious"
+  ) as RelevantUserInfo;
 }
 
 export async function getUser(req: MonkeyRequest): Promise<GetUserResponse> {

backend/src/dal/leaderboards.ts

@@ -44,18 +44,18 @@ export async function get(
   const limit = pageSize;
 
   try {
-    const preset = await getCollection({ language, mode, mode2 })
+    const result = await getCollection({ language, mode, mode2 })
       .find()
       .sort({ rank: 1 })
       .skip(skip)
       .limit(limit)
       .toArray();
 
     if (!premiumFeaturesEnabled) {
-      return preset.map((it) => omit(it, "isPremium"));
+      return result.map((it) => omit(it, "isPremium"));
     }
 
-    return preset;
+    return result;
   } catch (e) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     if (e.error === 175) {

backend/src/dal/user.ts

@@ -54,11 +54,13 @@ export type DBUser = Omit<
   inbox?: MonkeyMail[];
   ips?: string[];
   canReport?: boolean;
+  nameHistory?: string[];
   lastNameChange?: number;
   canManageApeKeys?: boolean;
   bananas?: number;
   testActivity?: CountByYearAndDay;
   suspicious?: boolean;
+  note?: string;
 };
 
 const SECONDS_PER_HOUR = 3600;

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 } from "../utils/misc";
+import { identity, omit } from "../utils/misc";
 import { BASE_CONFIGURATION } from "../constants/base-configuration";
 import { Configuration } from "@monkeytype/schemas/configuration";
 import { addLog } from "../dal/logs";
@@ -81,9 +81,9 @@ export async function getLiveConfiguration(): Promise<Configuration> {
     const liveConfiguration = await configurationCollection.findOne();
 
     if (liveConfiguration) {
-      const baseConfiguration = _.cloneDeep(BASE_CONFIGURATION);
+      const baseConfiguration = structuredClone(BASE_CONFIGURATION);
 
-      const liveConfigurationWithoutId = _.omit(
+      const liveConfigurationWithoutId = omit(
         liveConfiguration,
         "_id"
       ) as Configuration;
@@ -129,7 +129,7 @@ export async function patchConfiguration(
   configurationUpdates: PartialConfiguration
 ): Promise<boolean> {
   try {
-    const currentConfiguration = _.cloneDeep(configuration);
+    const currentConfiguration = structuredClone(configuration);
     mergeConfigurations(currentConfiguration, configurationUpdates);
 
     await db

backend/src/utils/misc.ts

@@ -1,6 +1,6 @@
 import { MILLISECONDS_IN_DAY } from "@monkeytype/util/date-and-time";
 import { roundTo2 } from "@monkeytype/util/numbers";
-import _, { omit } from "lodash";
+import _ from "lodash";
 import uaparser from "ua-parser-js";
 import { MonkeyRequest } from "../api/types";
 import { ObjectId } from "mongodb";
@@ -220,8 +220,8 @@ export function replaceObjectId<T extends { _id: ObjectId }>(
     return null;
   }
   const result = {
+    ...data,
     _id: data._id.toString(),
-    ...omit(data, "_id"),
   } as T & { _id: string };
   return result;
 }
@@ -240,3 +240,15 @@ export function replaceObjectIds<T extends { _id: ObjectId }>(
 export type WithObjectId<T extends { _id: string }> = Omit<T, "_id"> & {
   _id: ObjectId;
 };
+
+export function omit<T extends object, K extends keyof T>(
+  obj: T,
+  ...keys: K[]
+): Omit<T, K> {
+  const result = { ...obj };
+  for (const key of keys) {
+    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+    delete result[key];
+  }
+  return result;
+}