Enhance performance of get peer deps (#1554)

Author: rbnayax

src/lib/cache.ts

@@ -2,7 +2,9 @@ import fs from 'fs'
 import os from 'os'
 import path from 'path'
 import { CacheData, Cacher } from '../types/Cacher'
+import { Index } from '../types/IndexType'
 import { Options } from '../types/Options'
+import { Version } from '../types/Version'
 import { print } from './logging'
 
 export const CACHE_DELIMITER = '___'
@@ -55,7 +57,7 @@ export default async function cacher(options: Omit<Options, 'cacher'>): Promise<
 
   const cacheFile = resolveCacheFile(options.cacheFile)
   let cacheData: CacheData = {}
-  const cacheUpdates: Record<string, string> = {}
+  const cacheHits = new Set<string>()
 
   try {
     cacheData = JSON.parse(await fs.promises.readFile(cacheFile, 'utf-8'))
@@ -76,32 +78,53 @@ export default async function cacher(options: Omit<Options, 'cacher'>): Promise<
   if (!cacheData.packages) {
     cacheData.packages = {}
   }
+  if (!cacheData.peers) {
+    cacheData.peers = {}
+  }
 
   return {
     get: (name: string, target: string) => {
+      if (!cacheData.packages) return
       const key = `${name}${CACHE_DELIMITER}${target}`
-      if (!key || !cacheData.packages) return
       const cached = cacheData.packages[key]
       if (cached && !key.includes(cached)) {
-        const [name] = key.split(CACHE_DELIMITER)
-        cacheUpdates[name] = cached
+        cacheHits.add(name)
       }
       return cached
     },
     set: (name: string, target: string, version: string) => {
+      if (!cacheData.packages) return
       const key = `${name}${CACHE_DELIMITER}${target}`
-      if (!key || !cacheData.packages) return
       cacheData.packages[key] = version
     },
+    getPeers: (name: string, version: Version) => {
+      if (!cacheData.peers) return
+      const key = `${name}${CACHE_DELIMITER}${version}`
+      const cached = cacheData.peers[key]
+      if (cached) {
+        cacheHits.add(name)
+      }
+      return cached
+    },
+    setPeers: (name: string, version: Version, peers: Index<string>) => {
+      const key = `${name}${CACHE_DELIMITER}${version}`
+      if (!cacheData.peers) return
+      cacheData.peers[key] = peers
+    },
     save: async () => {
       await fs.promises.writeFile(cacheFile, JSON.stringify(cacheData))
     },
-    log: () => {
-      const cacheCount = Object.keys(cacheUpdates).length
+    log: (peers?: boolean) => {
+      const cacheCount = cacheHits.size
       if (cacheCount === 0) return
 
-      print(options, `\nUsing ${cacheCount} cached package version${cacheCount > 1 ? 's' : ''}`, 'warn')
-      print(options, cacheUpdates, 'verbose')
+      print(
+        options,
+        `\nUsing ${cacheCount} cached package ${peers ? 'peer' : 'version'}${cacheCount > 1 ? 's' : ''}`,
+        'warn',
+      )
+      print(options, cacheHits, 'verbose')
+      cacheHits.clear()
     },
-  } as Cacher
+  } satisfies Cacher
 }

src/lib/getPeerDependenciesFromRegistry.ts

@@ -1,3 +1,4 @@
+import pMap from 'p-map'
 import ProgressBar from 'progress'
 import { Index } from '../types/IndexType'
 import { Options } from '../types/Options'
@@ -59,19 +60,47 @@ async function getPeerDependenciesFromRegistry(packageMap: Index<Version>, optio
     bar.render()
   }
 
-  return Object.entries(packageMap).reduce(async (accumPromise, [pkg, version]) => {
-    const dep = await packageManager.getPeerDependencies!(pkg, version, { cwd: options.cwd })
+  const packageEntries = Object.entries(packageMap)
+
+  /**
+   * Fetches peer dependencies for a package
+   * @param pkg - The package name
+   * @param version - The package version
+   * @returns Promise that resolves to package name and its peer dependencies
+   */
+  const getPeerDepsForPackage = async ([pkg, version]: [string, Version]): Promise<{
+    pkg: string
+    dependencies: Index<string>
+  }> => {
+    let dependencies: Index<string>
+    const cached = options.cacher?.getPeers(pkg, version)
+    if (cached) {
+      dependencies = cached
+    } else {
+      dependencies = await packageManager.getPeerDependencies!(pkg, version, { cwd: options.cwd })
+      options.cacher?.setPeers(pkg, version, dependencies)
+    }
     if (bar) {
       bar.tick()
     }
-    const accum = await accumPromise
-    const newAcc: Index<Index<string>> = { ...accum, [pkg]: dep }
-    const circularData = isCircularPeer(newAcc, pkg)
+    return { pkg, dependencies }
+  }
+
+  const results = await pMap(packageEntries, getPeerDepsForPackage, { concurrency: options.concurrency })
+
+  const accum: Index<Index<string>> = {}
+  for (const { pkg, dependencies } of results) {
+    accum[pkg] = dependencies
+    const circularData = isCircularPeer(accum, pkg)
     if (circularData.isCircular) {
-      delete newAcc[pkg][circularData.offendingPackage]
+      delete accum[pkg][circularData.offendingPackage]
     }
-    return newAcc
-  }, Promise.resolve<Index<Index<string>>>({}))
+  }
+
+  await options.cacher?.save()
+  options.cacher?.log(true)
+
+  return accum
 }
 
 export default getPeerDependenciesFromRegistry

src/types/Cacher.ts

@@ -1,11 +1,17 @@
+import { Index } from './IndexType'
+import { Version } from './Version'
+
 export interface CacheData {
   timestamp?: number
   packages?: Record<string, string | undefined>
+  peers?: Record<string, Index<string> | undefined>
 }
 
 export type Cacher = {
   get(name: string, target: string): string | undefined
   set(name: string, target: string, version: string): void
+  getPeers(name: string, version: Version): Index<string> | undefined
+  setPeers(name: string, version: Version, peers: Index<string>): void
   save(): Promise<void>
-  log(): void
+  log(peers?: boolean): void
 }

test/cache.test.ts

@@ -24,7 +24,7 @@ describe('cache', () => {
         },
       }
 
-      await ncu({ packageData, cache: true })
+      await ncu({ packageData, cache: true, peer: true })
 
       const cacheData: CacheData = await fs.readFile(resolvedDefaultCacheFile, 'utf-8').then(JSON.parse)
 
@@ -34,6 +34,13 @@ describe('cache', () => {
         [`ncu-test-tag${CACHE_DELIMITER}latest`]: '1.1.0',
         [`ncu-test-alpha${CACHE_DELIMITER}latest`]: '1.0.0',
       })
+      expect(cacheData.peers).deep.eq({
+        [`ncu-test-alpha${CACHE_DELIMITER}1.0.0`]: {},
+        [`ncu-test-tag${CACHE_DELIMITER}1.0.0`]: {},
+        [`ncu-test-tag${CACHE_DELIMITER}1.1.0`]: {},
+        [`ncu-test-v2${CACHE_DELIMITER}1.0.0`]: {},
+        [`ncu-test-v2${CACHE_DELIMITER}2.0.0`]: {},
+      })
     } finally {
       await fs.rm(resolvedDefaultCacheFile, { recursive: true, force: true })
       stub.restore()
@@ -75,6 +82,7 @@ describe('cache', () => {
         [`ncu-test-tag${CACHE_DELIMITER}latest`]: '1.1.0',
         [`ncu-test-alpha${CACHE_DELIMITER}latest`]: '1.0.0',
       })
+      expect(cacheData1.peers).deep.eq({})
 
       // second run has a different target so should not use the cache
       const result2 = await ncu({ packageData, cache: true, target: 'greatest' })