fix(perf): improve require perf by speeding up resolver some more

Author: zkat

lib/ensure-package.js

@@ -242,7 +242,7 @@ async function ensurePackage (cache, name, dep, opts) {
     if (!integrity) { integrity = mani._integrity }
   }
   if (integrity && !opts.restore) {
-    const info = await cacache.get.info(cache, pkglock.depKey(spec, dep))
+    const info = await cacache.get.info(cache, pkglock.depKey(name, dep))
     if (info) {
       return JSON.parse(info.metadata)
     }
@@ -270,7 +270,7 @@ async function ensurePackage (cache, name, dep, opts) {
     unpacker.on('metadata', (m) => { metadata = m })
     unpacker.on('finish', async () => {
       try {
-        const key = pkglock.depKey(spec, dep)
+        const key = pkglock.depKey(name, dep)
         const doc = Object.assign({}, metadata, {
           name: name,
           version: dep.version,

lib/pkglock.js

@@ -4,13 +4,9 @@ const { get: ccGet } = require('cacache')
 const ccPath = require('cacache/lib/content/path.js')
 const cp = require('child_process')
 const fs = require('fs')
-const npa = require('npm-package-arg')
 const path = require('path')
 const ssri = require('ssri')
 
-// warm up npa
-npa('idk')
-
 const INDEX_VERSION = module.exports.INDEX_VERSION = '2.0.0'
 
 const pkgLockName = 'package-lock.json'
@@ -72,37 +68,38 @@ function resolve (...p) {
 }
 
 module.exports.depKey = depKey
-function depKey (spec, dep) {
-  const prefix = `tinked-package:${INDEX_VERSION}`
-  if (spec.registry) {
-    return `${prefix}:${dep.integrity || dep.resolved || spec.raw}`
-  } else if (spec.type === 'git') {
-    return `${prefix}:git:${dep.version}`
-  } else if (spec.type === 'remote') {
-    return `${prefix}:${dep.integrity || dep.version}`
-  } else {
-    return `${prefix}:${spec.name}:${dep.version}:${dep.resolved}:${dep.integrity}`
-  }
+function depKey (pkgName, dep) {
+  return `tinked-package:${
+    INDEX_VERSION
+  }:${
+    pkgName
+  }:${
+    dep.version
+  }:${
+    dep.resolved
+  }:${
+    dep.integrity
+  }`
 }
 
 module.exports.resolveEntity = resolveEntity
 function resolveEntity (cache, scope, pkgName, filePath) {
-  const spec = npa(pkgName, scope.version)
+  // const spec = npa(pkgName, scope.version)
   if (!(scope && scope.dependencies && scope.dependencies[pkgName])) {
     return false
   }
   let pkg
   const tink = process.tink
   try {
     process.tink = null
-    pkg = getPkg(cache, spec, scope, pkgName)
+    pkg = getPkg(cache, scope, pkgName)
   } catch (e) {
     if (e.code === 'ENOENT') {
       const dep = scope.dependencies[pkgName]
       if (dep) {
         dep.name = pkgName
         fetchPackageSync(cache, dep, dep.integrity)
-        pkg = getPkg(cache, spec, scope, pkgName)
+        pkg = getPkg(cache, scope, pkgName)
       } else {
         return null
       }
@@ -137,13 +134,12 @@ function resolveEntity (cache, scope, pkgName, filePath) {
 }
 
 module.exports.readPkgLock = readPkgLock
-function readPkgLock (...p) {
-  const resolved = path.resolve(...p)
-  let modulesIdx = resolved.lastIndexOf('node_modules')
-  while (modulesIdx !== -1) {
+function readPkgLock (resolved) {
+  let modulesIdx = resolved.indexOf('node_modules')
+  let pkgLock
+  while (!pkgLock && modulesIdx !== -1) {
     let substr = resolved.substr(0, modulesIdx - 1)
     const pkgLockPath = path.join(substr, pkgLockName)
-    let pkgLock
     if (pkgLockCache.has(pkgLockPath)) {
       pkgLock = pkgLockCache.get(pkgLockPath)
     } else {
@@ -154,13 +150,15 @@ function readPkgLock (...p) {
       } catch (e) {
         if (e.code !== 'ENOENT') {
           throw e
+        } else {
+          pkgLockCache.set(pkgLockPath, null)
         }
       }
     }
     if (pkgLock) {
       return { pkgLock, subPath: resolved.substr(modulesIdx - 1) }
     } else {
-      modulesIdx = substr.lastIndexOf('node_modules')
+      modulesIdx = substr.indexOf('node_modules', modulesIdx)
     }
   }
   return null
@@ -288,9 +286,17 @@ function statSync ({ cache, hash, pkg, resolvedPath, isDir }, verify) {
   })
 }
 
-function getPkg (cache, spec, scope, pkgName) {
-  const { metadata } = ccGet.sync(cache, depKey(spec, scope.dependencies[pkgName]), { memoize: true })
-  return JSON.parse(metadata)
+const pkgCache = new Map()
+function getPkg (cache, scope, pkgName) {
+  const key = depKey(pkgName, scope.dependencies[pkgName])
+  if (pkgCache.has(key)) {
+    return pkgCache.get(key)
+  } else {
+    const { metadata } = ccGet.sync(cache, key)
+    const ret = JSON.parse(metadata)
+    pkgCache.set(key, ret)
+    return ret
+  }
 }
 
 let ensurePkg