feat: replace lodash with stdlib

Author: joakimen

package-lock.json

@@ -32,10 +32,10 @@
     "find-up": "^5.0.0",
     "js-yaml": "^4.1.0",
     "keytar": "^7.9.0",
-    "lodash-es": "^4.17.21",
     "node-fetch": "^2.6.7",
     "p-limit": "^3.0.0",
     "p-map": "^4.0.0",
+    "process": "0.11.10",
     "read": "^1.0.7",
     "rimraf": "^4.0.0",
     "semver": "^7.6.2",
@@ -74,7 +74,6 @@
     "eslint-plugin-prettier": "5.2.1",
     "husky": "9.1.7",
     "jest": "^29.6.1",
-    "lodash": "4.17.21",
     "prettier": "3.4.2",
     "rollup": "2.79.2",
     "rollup-plugin-typescript2": "0.36.0",

package.json

@@ -1,6 +1,5 @@
 import fs from "fs"
 import yaml from "js-yaml"
-import { keyBy } from "lodash-es"
 import pMap from "p-map"
 import { CommandModule } from "yargs"
 import { Config } from "../../../config"
@@ -196,7 +195,9 @@ async function getProjects(
   const repos = await getReposFromGitHub(github, orgs)
   const snykRepos = await snykReposPromise
 
-  const definitionRepos = keyBy(getRepos(definition), (it) => it.id)
+  const definitionRepos = Object.fromEntries(
+    getRepos(definition).map((repo: GetReposResponse) => [repo.id, repo]),
+  )
 
   const projectGroups = Object.values(
     repos.reduce<{

src/cli/commands/definition/dump-setup.ts

@@ -1,4 +1,4 @@
-import { groupBy, repeat, sortBy, sumBy } from "lodash-es"
+import { sumBy } from "../../../collections/collections"
 import { sprintf } from "sprintf-js"
 import { CommandModule } from "yargs"
 import { DefinitionFile, getRepos } from "../../../definition"
@@ -14,6 +14,7 @@ import {
   definitionFileOptionValue,
   getDefinitionFile,
 } from "../../util"
+import { groupBy, sortBy } from "../../../collections/collections"
 
 function totalSeverityCount(project: SnykProject) {
   return (
@@ -26,7 +27,7 @@ function totalSeverityCount(project: SnykProject) {
 
 function buildStatsLine(stats: SnykProject["issueCountsBySeverity"]) {
   function item(num: number, str: string) {
-    return num === 0 ? repeat(" ", str.length + 4) : sprintf("%3d %s", num, str)
+    return num === 0 ? " ".repeat(str.length + 4) : sprintf("%3d %s", num, str)
   }
 
   return sprintf(

src/cli/commands/snyk/report.ts

@@ -0,0 +1,186 @@
+import { groupBy, uniq, sortBy, sumBy } from "./collections"
+
+describe("collections", () => {
+  describe("groupBy", () => {
+    type TestCase<T> = {
+      description: string
+      got: T[]
+      iteratee: (item: T) => string
+      want: Record<string, T[]>
+    }
+    const tests: TestCase<{ id: number }>[] = [
+      {
+        description: "groups items by id",
+        got: [{ id: 1 }, { id: 2 }, { id: 1 }],
+        iteratee: (item) => item.id.toString(),
+        want: { "1": [{ id: 1 }, { id: 1 }], "2": [{ id: 2 }] },
+      },
+      {
+        description: "groups items by id with duplicates",
+        got: [{ id: 1 }, { id: 2 }, { id: 1 }],
+        iteratee: (item) => item.id.toString(),
+        want: { "1": [{ id: 1 }, { id: 1 }], "2": [{ id: 2 }] },
+      },
+      {
+        description: "handles empty array",
+        got: [],
+        iteratee: (item) => item.id.toString(),
+        want: {},
+      },
+      {
+        description: "handles single item",
+        got: [{ id: 1 }],
+        iteratee: (item) => item.id.toString(),
+        want: { "1": [{ id: 1 }] },
+      },
+      {
+        description: "handles multiple unique items",
+        got: [{ id: 1 }, { id: 2 }, { id: 3 }],
+        iteratee: (item) => item.id.toString(),
+        want: { "1": [{ id: 1 }], "2": [{ id: 2 }], "3": [{ id: 3 }] },
+      },
+    ]
+
+    test.each(tests)(
+      "$description",
+      ({ got, iteratee, want }: TestCase<{ id: number }>) => {
+        expect(groupBy(got, iteratee)).toEqual(want)
+      },
+    )
+  })
+
+  describe("uniq", () => {
+    type TestCase<T> = {
+      description: string
+      got: T[]
+      want: T[]
+    }
+    const tests: TestCase<number>[] = [
+      {
+        description: "removes duplicates from array",
+        got: [1, 2, 2, 3, 4, 4, 5],
+        want: [1, 2, 3, 4, 5],
+      },
+      {
+        description: "removes duplicates from array with duplicates",
+        got: [1, 2, 2, 3, 4, 4, 5],
+        want: [1, 2, 3, 4, 5],
+      },
+      {
+        description: "handles empty array",
+        got: [],
+        want: [],
+      },
+      {
+        description: "handles array with all same elements",
+        got: [1, 1, 1, 1],
+        want: [1],
+      },
+      {
+        description: "handles array with all unique elements",
+        got: [1, 2, 3, 4, 5],
+        want: [1, 2, 3, 4, 5],
+      },
+    ]
+
+    test.each(tests)("$description", ({ got, want }: TestCase<number>) => {
+      expect(uniq(got)).toEqual(want)
+    })
+  })
+
+  describe("sortBy", () => {
+    type TestCase<T> = {
+      description: string
+      got: T[]
+      getKey: (item: T) => string
+      want: T[]
+    }
+    const tests: TestCase<{ name: string }>[] = [
+      {
+        description: "sorts items by name",
+        got: [{ name: "b" }, { name: "a" }, { name: "c" }],
+        getKey: (item) => item.name,
+        want: [{ name: "a" }, { name: "b" }, { name: "c" }],
+      },
+      {
+        description: "sorts items by numeric string",
+        got: [{ name: "30" }, { name: "20" }, { name: "40" }],
+        getKey: (item) => item.name,
+        want: [{ name: "20" }, { name: "30" }, { name: "40" }],
+      },
+      {
+        description: "handles empty array",
+        got: [],
+        getKey: (item) => item.name,
+        want: [],
+      },
+      {
+        description: "sorts items by numeric string with two elements",
+        got: [{ name: "2" }, { name: "1" }],
+        getKey: (item) => item.name,
+        want: [{ name: "1" }, { name: "2" }],
+      },
+      {
+        description: "sorts items by name with multiple elements",
+        got: [{ name: "z" }, { name: "x" }, { name: "y" }],
+        getKey: (item) => item.name,
+        want: [{ name: "x" }, { name: "y" }, { name: "z" }],
+      },
+    ]
+
+    test.each(tests)(
+      "$description",
+      ({ got, getKey, want }: TestCase<{ name: string }>) => {
+        expect(sortBy(got, getKey)).toEqual(want)
+      },
+    )
+  })
+
+  describe("sumBy", () => {
+    type TestCase<T> = {
+      description: string
+      got: T[]
+      iteratee: (item: T) => number
+      want: number
+    }
+    const cases: TestCase<{ value: number }>[] = [
+      {
+        description: "sums values in array",
+        got: [{ value: 1 }, { value: 2 }, { value: 3 }],
+        iteratee: (item) => item.value,
+        want: 6,
+      },
+      {
+        description: "sums values in array with two elements",
+        got: [{ value: 10 }, { value: 20 }],
+        iteratee: (item) => item.value,
+        want: 30,
+      },
+      {
+        description: "handles empty array",
+        got: [],
+        iteratee: (item) => item.value,
+        want: 0,
+      },
+      {
+        description: "sums values in array with negative and positive elements",
+        got: [{ value: -1 }, { value: 1 }],
+        iteratee: (item) => item.value,
+        want: 0,
+      },
+      {
+        description: "sums values in array with same elements",
+        got: [{ value: 5 }, { value: 5 }, { value: 5 }],
+        iteratee: (item) => item.value,
+        want: 15,
+      },
+    ]
+
+    test.each(cases)(
+      "$description",
+      ({ got, iteratee, want }: TestCase<{ value: number }>) => {
+        expect(sumBy(got, iteratee)).toEqual(want)
+      },
+    )
+  })
+})

src/collections/collections.test.ts

@@ -0,0 +1,28 @@
+export function groupBy<T>(
+  array: T[],
+  iteratee: (item: T) => string,
+): Record<string, T[]> {
+  return array.reduce(
+    (result, item) => {
+      const key = iteratee(item)
+      if (!result[key]) {
+        result[key] = []
+      }
+      result[key].push(item)
+      return result
+    },
+    {} as Record<string, T[]>,
+  )
+}
+
+export function uniq<T>(array: T[]): T[] {
+  return Array.from(new Set(array))
+}
+
+export function sortBy<T>(arr: T[], getKey: (item: T) => string): T[] {
+  return [...arr].sort((a, b) => getKey(a).localeCompare(getKey(b)))
+}
+
+export function sumBy<T>(array: T[], iteratee: (item: T) => number): number {
+  return array.reduce((sum, item) => sum + iteratee(item), 0)
+}

src/collections/collections.ts

@@ -1,9 +1,9 @@
 import AJV from "ajv"
 import fs from "fs"
 import yaml from "js-yaml"
-import { uniq } from "lodash-es"
 import schema from "../definition-schema.json"
 import { Definition, GetReposResponse } from "./types"
+import { uniq } from "../collections/collections"
 
 export { schema }
 
@@ -162,9 +162,8 @@ export function getRepos(definition: Definition): GetReposResponse[] {
 }
 
 export function getGitHubOrgs(definition: Definition): string[] {
-  return uniq(
-    definition.projects.flatMap((project) =>
-      project.github.map((it) => it.organization),
-    ),
+  const githubOrganizations = definition.projects.flatMap((project) =>
+    project.github.map((it) => it.organization),
   )
+  return uniq(githubOrganizations)
 }

src/definition/definition.ts

@@ -1,4 +1,3 @@
-import { sortBy } from "lodash-es"
 import pMap from "p-map"
 import { getGitHubOrgs, getRepos } from "../../definition"
 import {
@@ -11,6 +10,7 @@ import {
 import { GitHubService } from "../service"
 import { OrgsGetResponse, Permission, ReposGetResponse } from "../types"
 import { ChangeSetItem, RepoAttribUpdateItem } from "./types"
+import { sortBy } from "../../collections/collections"
 
 function getChangedRepoAttribs(
   definitionRepo: DefinitionRepo,
@@ -59,14 +59,17 @@ async function getUnknownRepos(
     (orgName) => limitToOrg === undefined || limitToOrg === orgName,
   )
 
+  const orgRepoList = await pMap(orgs, (orgName) =>
+    github.getOrgRepoList({ org: orgName }),
+  )
+
   return sortBy(
-    (await pMap(orgs, (orgName) => github.getOrgRepoList({ org: orgName })))
+    orgRepoList
       .flat()
       .filter((it) => !knownRepos.includes(`${it.owner.login}/${it.name}`)),
     (it) => `${it.owner.login}/${it.name}`,
   )
 }
-
 /**
  * Get teams from both the project level and the repository level
  * and ensure that repository level override project level.