make work with pnpm and git, use pnpm-lock.yaml

Author: milahu

integration-tests/runIntegrationTest.ts

@@ -7,7 +7,7 @@ import { resolveRelativeFileDependencies } from "../src/resolveRelativeFileDepen
 export const patchPackageTarballPath = resolve(
   fs
     .readdirSync(".")
-    .filter(nm => nm.match(/^patch-package\.test\.\d+\.tgz$/))[0],
+    .filter((nm) => nm.match(/^patch-package\.test\.\d+\.tgz$/))[0],
 )
 
 export function runIntegrationTest({
@@ -64,7 +64,7 @@ export function runIntegrationTest({
         expect(snapshots && snapshots.length).toBeTruthy()
       })
       if (snapshots) {
-        snapshots.forEach(snapshot => {
+        snapshots.forEach((snapshot) => {
           const snapshotDescriptionMatch = snapshot.match(/SNAPSHOT: (.*)/)
           if (snapshotDescriptionMatch) {
             it(snapshotDescriptionMatch[1], () => {

package.json

@@ -61,6 +61,7 @@
     "@types/tmp": "^0.0.34",
     "husky": "^1.3.1",
     "jest": "^24.5.0",
+    "js-yaml": "^4.0.0",
     "lint-staged": "^8.1.5",
     "np": "^7.4.0",
     "prettier": "^2.2.1",

property-based-tests/executeTestCase.ts

@@ -24,32 +24,31 @@ jest.mock("fs-extra", () => {
     setWorkingFiles,
     getWorkingFiles,
     ensureDirSync: jest.fn(),
-    readFileSync: jest.fn(path => getWorkingFiles()[path].contents),
+    readFileSync: jest.fn((filePath) => getWorkingFiles()[filePath].contents),
     writeFileSync: jest.fn(
-      (path: string, contents: string, opts?: { mode?: number }) => {
-        getWorkingFiles()[path] = {
+      (filePath: string, contents: string, opts?: { mode?: number }) => {
+        getWorkingFiles()[filePath] = {
           contents,
           mode: opts && typeof opts.mode === "number" ? opts.mode : 0o644,
         }
       },
     ),
-    unlinkSync: jest.fn(path => delete getWorkingFiles()[path]),
+    unlinkSync: jest.fn((filePath) => delete getWorkingFiles()[filePath]),
     moveSync: jest.fn((from, to) => {
       getWorkingFiles()[to] = getWorkingFiles()[from]
       delete getWorkingFiles()[from]
     }),
-    statSync: jest.fn(path => getWorkingFiles()[path]),
-    chmodSync: jest.fn((path, mode) => {
-      const { contents } = getWorkingFiles()[path]
-      getWorkingFiles()[path] = { contents, mode }
+    statSync: jest.fn((filePath) => getWorkingFiles()[filePath]),
+    chmodSync: jest.fn((filePath, mode) => {
+      const { contents } = getWorkingFiles()[filePath]
+      getWorkingFiles()[filePath] = { contents, mode }
     }),
   }
 })
 
 function writeFiles(cwd: string, files: Files): void {
   const mkdirpSync = require("fs-extra/lib/mkdirs/index.js").mkdirpSync
-  const writeFileSync = require("fs").writeFileSync
-  Object.keys(files).forEach(filePath => {
+  Object.keys(files).forEach((filePath) => {
     if (!filePath.startsWith(".git/")) {
       mkdirpSync(path.join(cwd, path.dirname(filePath)))
       writeFileSync(path.join(cwd, filePath), files[filePath].contents, {
@@ -62,7 +61,7 @@ function writeFiles(cwd: string, files: Files): void {
 function removeLeadingSpaceOnBlankLines(patchFileContents: string): string {
   return patchFileContents
     .split("\n")
-    .map(line => (line === " " ? "" : line))
+    .map((line) => (line === " " ? "" : line))
     .join("\n")
 }
 

property-based-tests/testCases.ts

@@ -121,7 +121,7 @@ function insertLinesIntoFile(file: File): File {
 function getUniqueFilename(files: Files) {
   let filename = makeFileName()
   const ks = Object.keys(files)
-  while (ks.some(k => k.startsWith(filename))) {
+  while (ks.some((k) => k.startsWith(filename))) {
     filename = makeFileName()
   }
   return filename

src/detectPackageManager.ts

@@ -4,7 +4,7 @@ import chalk from "chalk"
 import process from "process"
 import findWorkspaceRoot from "find-yarn-workspace-root"
 
-export type PackageManager = "yarn" | "npm" | "npm-shrinkwrap"
+export type PackageManager = "yarn" | "npm" | "npm-shrinkwrap" | "pnpm"
 
 function printNoYarnLockfileError() {
   console.error(`
@@ -64,6 +64,8 @@ export const detectPackageManager = (
     }
   } else if (yarnLockExists || findWorkspaceRoot()) {
     return "yarn"
+  } else if (fs.existsSync(join(appRootPath, "pnpm-lock.yaml"))) {
+    return "pnpm"
   } else {
     printNoLockfilesError()
     process.exit(1)

src/filterFiles.ts

@@ -8,10 +8,10 @@ export function removeIgnoredFiles(
   excludePaths: RegExp,
 ) {
   klawSync(dir, { nodir: true })
-    .map(item => item.path.slice(`${dir}/`.length))
+    .map((item) => item.path.slice(`${dir}/`.length))
     .filter(
-      relativePath =>
+      (relativePath) =>
         !relativePath.match(includePaths) || relativePath.match(excludePaths),
     )
-    .forEach(relativePath => removeSync(join(dir, relativePath)))
+    .forEach((relativePath) => removeSync(join(dir, relativePath)))
 }

src/getPackageResolution.ts

@@ -5,6 +5,9 @@ import { readFileSync, existsSync } from "fs-extra"
 import { parse as parseYarnLockFile } from "@yarnpkg/lockfile"
 import findWorkspaceRoot from "find-yarn-workspace-root"
 import { getPackageVersion } from "./getPackageVersion"
+import { execSync } from "child_process"
+
+const isVerbose = true // TODO expose to CLI
 
 export function getPackageResolution({
   packageDetails,
@@ -56,21 +59,69 @@ export function getPackageResolution({
       console.warn(
         `Ambigious lockfile entries for ${packageDetails.pathSpecifier}. Using version ${installedVersion}`,
       )
-      return installedVersion
+      return { version: installedVersion }
     }
 
     if (resolutions[0]) {
-      return resolutions[0]
+      return { version: resolutions[0] }
     }
 
     const resolution = entries[0][0].slice(packageDetails.name.length + 1)
 
     // resolve relative file path
     if (resolution.startsWith("file:.")) {
-      return `file:${resolve(appPath, resolution.slice("file:".length))}`
+      return {
+        version: `file:${resolve(appPath, resolution.slice("file:".length))}`,
+      }
     }
-
-    return resolution
+    return { version: resolution }
+  } else if (packageManager === "pnpm") {
+    const lockfile = require("js-yaml").load(
+      require("fs").readFileSync(join(appPath, "pnpm-lock.yaml"), "utf8"),
+    )
+    let resolvedVersion =
+      (lockfile.dependencies && lockfile.dependencies[packageDetails.name]) ||
+      (lockfile.devDependencies &&
+        lockfile.devDependencies[packageDetails.name])
+    if (resolvedVersion.startsWith("link:")) {
+      const localPath = resolve(resolvedVersion.slice(5))
+      if (isVerbose) {
+        console.log(`pnpm installed ${packageDetails.name} from ${localPath}`)
+      }
+      if (existsSync(localPath + "/.git")) {
+        // we hope that the originCommit will be available for future downloads
+        // otherwise our patch will not work ...
+        // ideally, we would use the last stable release before originCommit from npm or github
+        function exec(cmd: string) {
+          return execSync(cmd, {
+            cwd: localPath,
+            windowsHide: true,
+            encoding: "utf8",
+          }).trim()
+        }
+        const originUrl = exec("git remote get-url origin")
+        const originCommit = exec("git rev-parse origin/HEAD") // npm needs the long commit hash
+        resolvedVersion = `git+${originUrl}#${originCommit}`
+        if (isVerbose) {
+          console.log(
+            `using ${packageDetails.name} version ${resolvedVersion} from git origin/HEAD in ${localPath}`,
+          )
+        }
+        return { version: resolvedVersion, originCommit }
+      }
+      const pkgJson = localPath + "/package.json"
+      if (existsSync(pkgJson)) {
+        resolvedVersion = require(pkgJson).version
+        console.warn(
+          `warning: using ${packageDetails.name} version ${resolvedVersion} from ${pkgJson}`,
+        )
+        return { version: resolvedVersion }
+      }
+    }
+    if (isVerbose) {
+      console.log(`using ${packageDetails.name} version ${resolvedVersion}`)
+    }
+    return { version: resolvedVersion }
   } else {
     const lockfile = require(join(
       appPath,
@@ -91,7 +142,7 @@ export function getPackageResolution({
         entry.dependencies && packageDetails.name in entry.dependencies,
     )
     const pkg = relevantStackEntry.dependencies[packageDetails.name]
-    return pkg.resolved || pkg.from || pkg.version
+    return { version: pkg.resolved || pkg.from || pkg.version }
   }
 }
 

src/makePatch.ts

@@ -10,6 +10,7 @@ import {
   unlinkSync,
   mkdirpSync,
   realpathSync,
+  renameSync,
 } from "fs-extra"
 import { sync as rimraf } from "rimraf"
 import { copySync } from "fs-extra"
@@ -30,6 +31,8 @@ import {
   openIssueCreationLink,
 } from "./createIssue"
 
+const isVerbose = true // TODO expose to CLI
+
 function printNoPackageFoundError(
   packageName: string,
   packageJsonPath: string,
@@ -87,17 +90,19 @@ export function makePatch({
 
     console.info(chalk.grey("•"), "Creating temporary folder")
 
+    const resolvedVersion = getPackageResolution({
+      packageDetails,
+      packageManager,
+      appPath,
+    })
+
     // make a blank package.json
     mkdirpSync(tmpRepoNpmRoot)
     writeFileSync(
       tmpRepoPackageJsonPath,
       JSON.stringify({
         dependencies: {
-          [packageDetails.name]: getPackageResolution({
-            packageDetails,
-            packageManager,
-            appPath,
-          }),
+          [packageDetails.name]: resolvedVersion.version,
         },
         resolutions: resolveRelativeFileDependencies(
           appPath,
@@ -106,9 +111,10 @@ export function makePatch({
       }),
     )
 
-    const packageVersion = getPackageVersion(
-      join(resolve(packageDetails.path), "package.json"),
-    )
+    // originCommit is more precise than pkg.version
+    const packageVersion =
+      resolvedVersion.originCommit ||
+      getPackageVersion(join(resolve(packageDetails.path), "package.json"))
 
     // copy .npmrc/.yarnrc in case packages are hosted in private registry
     // tslint:disable-next-line:align
@@ -143,26 +149,42 @@ export function makePatch({
         )
       }
     } else {
+      const npmCmd = packageManager === "pnpm" ? "pnpm" : "npm"
       console.info(
         chalk.grey("•"),
-        `Installing ${packageDetails.name}@${packageVersion} with npm`,
+        `Installing ${packageDetails.name}@${packageVersion} with ${npmCmd}`,
       )
       try {
         // try first without ignoring scripts in case they are required
         // this works in 99.99% of cases
-        spawnSafeSync(`npm`, ["i", "--force"], {
+        if (isVerbose) {
+          console.log(`run "${npmCmd} install --force" in ${tmpRepoNpmRoot}`)
+        }
+        spawnSafeSync(npmCmd, ["install", "--force"], {
           cwd: tmpRepoNpmRoot,
           logStdErrOnError: false,
-          stdio: "ignore",
+          stdio: isVerbose ? "inherit" : "ignore",
         })
       } catch (e) {
         // try again while ignoring scripts in case the script depends on
         // an implicit context which we havn't reproduced
-        spawnSafeSync(`npm`, ["i", "--ignore-scripts", "--force"], {
+        if (isVerbose) {
+          console.log(
+            `run "${npmCmd} install --ignore-scripts --force" in ${tmpRepoNpmRoot}`,
+          )
+        }
+        spawnSafeSync(npmCmd, ["install", "--ignore-scripts", "--force"], {
           cwd: tmpRepoNpmRoot,
-          stdio: "ignore",
+          stdio: isVerbose ? "inherit" : "ignore",
         })
       }
+      if (packageManager === "pnpm") {
+        // workaround for `git diff`: replace symlink with hardlink
+        const pkgPath = tmpRepoNpmRoot + "/node_modules/" + packageDetails.name
+        const realPath = realpathSync(pkgPath)
+        unlinkSync(pkgPath) // rm symlink
+        renameSync(realPath, pkgPath)
+      }
     }
 
     const git = (...args: string[]) =>
@@ -193,8 +215,16 @@ export function makePatch({
     // replace package with user's version
     rimraf(tmpRepoPackagePath)
 
+    if (isVerbose) {
+      console.log(`copy ${realpathSync(packagePath)} to ${tmpRepoPackagePath}`)
+    }
+
     // pnpm installs packages as symlinks, copySync would copy only the symlink
-    copySync(realpathSync(packagePath), tmpRepoPackagePath)
+    copySync(realpathSync(packagePath), tmpRepoPackagePath, {
+      filter: (path) => {
+        return path.indexOf("/node_modules/") === -1
+      },
+    })
 
     // remove nested node_modules just to be safe
     rimraf(join(tmpRepoPackagePath, "node_modules"))
@@ -207,13 +237,23 @@ export function makePatch({
     // stage all files
     git("add", "-f", packageDetails.path)
 
+    // TODO allow to add more paths via CLI, to exclude cache files like 'test/stubs*/**'
+    const ignorePaths = [
+      "package-lock.json",
+      "pnpm-lock.yaml",
+      // 'test/stubs*/**',
+    ]
+
     // get diff of changes
     const diffResult = git(
       "diff",
       "--cached",
       "--no-color",
       "--ignore-space-at-eol",
       "--no-ext-diff",
+      ...ignorePaths.map(
+        (path) => `:(exclude,top)${packageDetails.path}/${path}`,
+      ),
     )
 
     if (diffResult.stdout.length === 0) {

src/packageIsDevDependency.ts

@@ -14,5 +14,7 @@ export function packageIsDevDependency({
     return false
   }
   const { devDependencies } = require(packageJsonPath)
-  return Boolean(devDependencies && devDependencies[packageDetails.packageNames[0]])
+  return Boolean(
+    devDependencies && devDependencies[packageDetails.packageNames[0]],
+  )
 }

src/patch/apply.ts

@@ -7,7 +7,7 @@ export const executeEffects = (
   effects: ParsedPatchFile,
   { dryRun }: { dryRun: boolean },
 ) => {
-  effects.forEach(eff => {
+  effects.forEach((eff) => {
     switch (eff.type) {
       case "file deletion":
         if (dryRun) {