isolate-package 1.13.2 → 1.14.0

package/README.md

@@ -68,10 +68,9 @@ integrated, check out [mono-ts](https://github.com/0x80/mono-ts)
 
 Run `pnpm install isolate-package --dev` or the equivalent for `npm` or `yarn`.
 
-I recommend using `pnpm` for
-[a number of reasons](https://pnpm.io/feature-comparison). In my experience it
-is the best package manager, especially for monorepo setups, but any other
-package manager should work.
+It is recommended to use `pnpm` over `npm` or `yarn`. Apart from being fast and
+efficient, PNPM has better support for monorepos, and the the lockfile isolation
+code is solid and works in parallel for multiple packages, [unlike NPM](#npm)
 
 ## Usage
 
@@ -210,30 +209,6 @@ Because the configuration loader depends on this setting, its output is not
 affected by this setting. If you want to debug the configuration set
 `DEBUG_ISOLATE_CONFIG=true` before you run `isolate`
 
-### forceNpm
-
-Type: `boolean`, default: `false`
-
-By default the isolate process will generate output based on the package manager
-that you are using for your monorepo. But your deployment target might not be
-compatible with that package manager, or it might not be the best choice given
-the available tooling.
-
-Also, it should not really matter what package manager is used in de deployment
-as long as the versions match your original lockfile.
-
-By setting this option to `true` you are forcing the isolate output to use NPM.
-A package-lock file will be generated based on the contents of node_modules and
-therefore should match the versions in your original lockfile.
-
-This way you can enjoy using PNPM or Yarn for your monorepo, while your
-deployment uses NPM with modules locked to the same versions.
-
-> !! Warning: Generating an NPM lockfile currently requires moving the
-> node_modules from the root of the monorepo temporarily into the isolate
-> directory. This will not be compatible with setups that run multiple isolation
-> processes in parallel.
-
 ### buildDirName
 
 Type: `string | undefined`, default: `undefined`
@@ -341,13 +316,8 @@ When you use the `targetPackagePath` option, this setting will be ignored.
 ## Lockfiles
 
 The isolate process tries to generate an isolated / pruned lockfile for the
-package manager that you use in your monorepo. If the package manager is not
-supported (modern Yarn versions), it can still generate a matching NPM lockfile
-based on the installed versions in node_modules.
-
-In case your package manager is not supported by your deployment target you can
-also choose NPM to be used by setting the `makeNpmLockfile` to `true` in your
-configuration.
+package manager that you use in your monorepo. The strategy is different for
+each package manager, with NPM currently being the least attractive.
 
 ### NPM
 
@@ -366,13 +336,8 @@ after Arborist has finished doing its thing.
 
 ### PNPM
 
-The PNPM lockfile format is very readable (YAML) but getting it adapted to the
-isolate output was a bit of a trip.
-
-It turns out, at least up to v10, that the isolated output has to be formatted
-as a workspace itself, otherwise dependencies of internally linked packages are
-not installed by PNPM. Therefore, the output looks a bit different from other
-package managers:
+For PNPM, the isolated output will be formatted as a workspace itself, otherwise
+dependencies of internally linked packages are not installed by PNPM.
 
 - Links are preserved
 - Versions specifiers like "workspace:\*" are preserved

package/dist/index.mjs

@@ -5,9 +5,9 @@ import path19 from "node:path";
 import { unique } from "remeda";
 
 // src/lib/config.ts
-import fs6 from "fs-extra";
-import assert from "node:assert";
-import path3 from "node:path";
+import fs8 from "fs-extra";
+import assert2 from "node:assert";
+import path6 from "node:path";
 import { isEmpty } from "remeda";
 
 // src/lib/logger.ts
@@ -137,16 +137,120 @@ async function readTypedJson(filePath) {
 
 // src/lib/utils/pack.ts
 import { exec } from "node:child_process";
-import fs3 from "node:fs";
+import fs5 from "node:fs";
+import path5 from "node:path";
+
+// src/lib/package-manager/index.ts
+import path4 from "node:path";
+
+// src/lib/package-manager/helpers/infer-from-files.ts
+import fs3 from "fs-extra";
+import { execSync } from "node:child_process";
 import path2 from "node:path";
-async function pack(srcDir, dstDir, usePnpmPack) {
+
+// src/lib/utils/get-major-version.ts
+function getMajorVersion(version) {
+  return parseInt(version.split(".")[0], 10);
+}
+
+// src/lib/package-manager/names.ts
+var supportedPackageManagerNames = ["pnpm", "yarn", "npm"];
+function getLockfileFileName(name) {
+  switch (name) {
+    case "pnpm":
+      return "pnpm-lock.yaml";
+    case "yarn":
+      return "yarn.lock";
+    case "npm":
+      return "package-lock.json";
+  }
+}
+
+// src/lib/package-manager/helpers/infer-from-files.ts
+function inferFromFiles(workspaceRoot) {
+  for (const name of supportedPackageManagerNames) {
+    const lockfileName = getLockfileFileName(name);
+    const version = getVersion(name);
+    if (fs3.existsSync(path2.join(workspaceRoot, lockfileName))) {
+      return { name, version, majorVersion: getMajorVersion(version) };
+    }
+  }
+  if (fs3.existsSync(path2.join(workspaceRoot, "npm-shrinkwrap.json"))) {
+    const version = getVersion("npm");
+    return { name: "npm", version, majorVersion: getMajorVersion(version) };
+  }
+  throw new Error(`Failed to detect package manager`);
+}
+function getVersion(packageManagerName) {
+  const buffer = execSync(`${packageManagerName} --version`);
+  return buffer.toString().trim();
+}
+
+// src/lib/package-manager/helpers/infer-from-manifest.ts
+import fs4 from "fs-extra";
+import assert from "node:assert";
+import path3 from "node:path";
+function inferFromManifest(workspaceRoot) {
+  const log = useLogger();
+  const { packageManager: packageManagerString } = readTypedJsonSync(
+    path3.join(workspaceRoot, "package.json")
+  );
+  if (!packageManagerString) {
+    log.debug("No packageManager field found in root manifest");
+    return;
+  }
+  const [name, version = "*"] = packageManagerString.split("@");
+  assert(
+    supportedPackageManagerNames.includes(name),
+    `Package manager "${name}" is not currently supported`
+  );
+  const lockfileName = getLockfileFileName(name);
+  assert(
+    fs4.existsSync(path3.join(workspaceRoot, lockfileName)),
+    `Manifest declares ${name} to be the packageManager, but failed to find ${lockfileName} in workspace root`
+  );
+  return {
+    name,
+    version,
+    majorVersion: getMajorVersion(version),
+    packageManagerString
+  };
+}
+
+// src/lib/package-manager/index.ts
+var packageManager;
+function usePackageManager() {
+  if (!packageManager) {
+    throw Error(
+      "No package manager detected. Make sure to call detectPackageManager() before usePackageManager()"
+    );
+  }
+  return packageManager;
+}
+function detectPackageManager(workspaceRootDir) {
+  if (isRushWorkspace(workspaceRootDir)) {
+    packageManager = inferFromFiles(
+      path4.join(workspaceRootDir, "common/config/rush")
+    );
+  } else {
+    packageManager = inferFromManifest(workspaceRootDir) ?? inferFromFiles(workspaceRootDir);
+  }
+  return packageManager;
+}
+function shouldUsePnpmPack() {
+  const { name, majorVersion } = usePackageManager();
+  return name === "pnpm" && majorVersion >= 8;
+}
+
+// src/lib/utils/pack.ts
+async function pack(srcDir, dstDir) {
+  const log = useLogger();
   const execOptions = {
     maxBuffer: 10 * 1024 * 1024
   };
-  const log = useLogger();
   const previousCwd = process.cwd();
   process.chdir(srcDir);
-  const stdout = usePnpmPack ? await new Promise((resolve, reject) => {
+  const stdout = shouldUsePnpmPack() ? await new Promise((resolve, reject) => {
     exec(
       `pnpm pack --pack-destination "${dstDir}"`,
       execOptions,
@@ -170,9 +274,9 @@ async function pack(srcDir, dstDir, usePnpmPack) {
       }
     );
   });
-  const fileName = path2.basename(stdout.trim());
-  const filePath = path2.join(dstDir, fileName);
-  if (!fs3.existsSync(filePath)) {
+  const fileName = path5.basename(stdout.trim());
+  const filePath = path5.join(dstDir, fileName);
+  if (!fs5.existsSync(filePath)) {
     log.error(
       `The response from pack could not be resolved to an existing file: ${filePath}`
     );
@@ -184,21 +288,21 @@ async function pack(srcDir, dstDir, usePnpmPack) {
 }
 
 // src/lib/utils/unpack.ts
-import fs4 from "fs-extra";
+import fs6 from "fs-extra";
 import tar from "tar-fs";
 import { createGunzip } from "zlib";
 async function unpack(filePath, unpackDir) {
   await new Promise((resolve, reject) => {
-    fs4.createReadStream(filePath).pipe(createGunzip()).pipe(tar.extract(unpackDir)).on("finish", () => resolve()).on("error", (err) => reject(err));
+    fs6.createReadStream(filePath).pipe(createGunzip()).pipe(tar.extract(unpackDir)).on("finish", () => resolve()).on("error", (err) => reject(err));
   });
 }
 
 // src/lib/utils/yaml.ts
-import fs5 from "fs-extra";
+import fs7 from "fs-extra";
 import yaml from "yaml";
 function readTypedYamlSync(filePath) {
   try {
-    const rawContent = fs5.readFileSync(filePath, "utf-8");
+    const rawContent = fs7.readFileSync(filePath, "utf-8");
     const data = yaml.parse(rawContent);
     return data;
   } catch (err) {
@@ -208,7 +312,7 @@ function readTypedYamlSync(filePath) {
   }
 }
 function writeTypedYamlSync(filePath, content) {
-  fs5.writeFileSync(filePath, yaml.stringify(content), "utf-8");
+  fs7.writeFileSync(filePath, yaml.stringify(content), "utf-8");
 }
 
 // src/lib/config.ts
@@ -249,12 +353,12 @@ function resolveConfig() {
   }
   setLogLevel(process.env.DEBUG_ISOLATE_CONFIG ? "debug" : "info");
   const log = useLogger();
-  const configFilePath = path3.join(process.cwd(), CONFIG_FILE_NAME);
+  const configFilePath = path6.join(process.cwd(), CONFIG_FILE_NAME);
   if (_user_defined_config) {
     log.debug(`Using user defined config:`, inspectValue(_user_defined_config));
   } else {
     log.debug(`Attempting to load config from ${configFilePath}`);
-    _user_defined_config = fs6.existsSync(configFilePath) ? readTypedJsonSync(configFilePath) : {};
+    _user_defined_config = fs8.existsSync(configFilePath) ? readTypedJsonSync(configFilePath) : {};
   }
   const foreignKeys = Object.keys(_user_defined_config).filter(
     (key) => !validConfigKeys.includes(key)
@@ -272,92 +376,6 @@ function resolveConfig() {
   return config;
 }
 
-// src/lib/package-manager/index.ts
-import path6 from "node:path";
-
-// src/lib/package-manager/helpers/infer-from-files.ts
-import fs7 from "fs-extra";
-import { execSync } from "node:child_process";
-import path4 from "node:path";
-
-// src/lib/package-manager/names.ts
-var supportedPackageManagerNames = ["pnpm", "yarn", "npm"];
-function getLockfileFileName(name) {
-  switch (name) {
-    case "pnpm":
-      return "pnpm-lock.yaml";
-    case "yarn":
-      return "yarn.lock";
-    case "npm":
-      return "package-lock.json";
-  }
-}
-
-// src/lib/package-manager/helpers/infer-from-files.ts
-function inferFromFiles(workspaceRoot) {
-  for (const name of supportedPackageManagerNames) {
-    const lockfileName = getLockfileFileName(name);
-    if (fs7.existsSync(path4.join(workspaceRoot, lockfileName))) {
-      return { name, version: getVersion(name) };
-    }
-  }
-  if (fs7.existsSync(path4.join(workspaceRoot, "npm-shrinkwrap.json"))) {
-    return { name: "npm", version: getVersion("npm") };
-  }
-  throw new Error(`Failed to detect package manager`);
-}
-function getVersion(packageManagerName) {
-  const buffer = execSync(`${packageManagerName} --version`);
-  return buffer.toString().trim();
-}
-
-// src/lib/package-manager/helpers/infer-from-manifest.ts
-import fs8 from "fs-extra";
-import assert2 from "node:assert";
-import path5 from "node:path";
-function inferFromManifest(workspaceRoot) {
-  const log = useLogger();
-  const rootManifest = readTypedJsonSync(
-    path5.join(workspaceRoot, "package.json")
-  );
-  if (!rootManifest.packageManager) {
-    log.debug("No packageManager field found in root manifest");
-    return;
-  }
-  const [name, version = "*"] = rootManifest.packageManager.split("@");
-  assert2(
-    supportedPackageManagerNames.includes(name),
-    `Package manager "${name}" is not currently supported`
-  );
-  const lockfileName = getLockfileFileName(name);
-  assert2(
-    fs8.existsSync(path5.join(workspaceRoot, lockfileName)),
-    `Manifest declares ${name} to be the packageManager, but failed to find ${lockfileName} in workspace root`
-  );
-  return { name, version };
-}
-
-// src/lib/package-manager/index.ts
-var packageManager;
-function usePackageManager() {
-  if (!packageManager) {
-    throw Error(
-      "No package manager detected. Make sure to call detectPackageManager() before usePackageManager()"
-    );
-  }
-  return packageManager;
-}
-function detectPackageManager(workspaceRootDir) {
-  if (isRushWorkspace(workspaceRootDir)) {
-    packageManager = inferFromFiles(
-      path6.join(workspaceRootDir, "common/config/rush")
-    );
-  } else {
-    packageManager = inferFromManifest(workspaceRootDir) ?? inferFromFiles(workspaceRootDir);
-  }
-  return packageManager;
-}
-
 // src/lib/lockfile/helpers/generate-npm-lockfile.ts
 import Arborist from "@npmcli/arborist";
 import fs9 from "fs-extra";
@@ -404,14 +422,20 @@ async function generateNpmLockfile({
 }
 
 // src/lib/lockfile/helpers/generate-pnpm-lockfile.ts
-import {
-  getLockfileImporterId,
-  readWantedLockfile,
-  writeWantedLockfile
-} from "@pnpm/lockfile-file";
-import { pruneLockfile } from "@pnpm/prune-lockfile";
 import assert3 from "node:assert";
 import path8 from "node:path";
+import {
+  getLockfileImporterId as getLockfileImporterId_v8,
+  readWantedLockfile as readWantedLockfile_v8,
+  writeWantedLockfile as writeWantedLockfile_v8
+} from "pnpm_lockfile_file_v8";
+import {
+  getLockfileImporterId as getLockfileImporterId_v9,
+  readWantedLockfile as readWantedLockfile_v9,
+  writeWantedLockfile as writeWantedLockfile_v9
+} from "pnpm_lockfile_file_v9";
+import { pruneLockfile as pruneLockfile_v8 } from "pnpm_prune_lockfile_v8";
+import { pruneLockfile as pruneLockfile_v9 } from "pnpm_prune_lockfile_v9";
 import { pick } from "remeda";
 
 // src/lib/lockfile/helpers/pnpm-map-importer.ts
@@ -440,24 +464,28 @@ async function generatePnpmLockfile({
   isolateDir,
   internalDepPackageNames,
   packagesRegistry,
-  targetPackageManifest
+  targetPackageManifest,
+  majorVersion
 }) {
+  const useVersion9 = majorVersion >= 9;
   const { includeDevDependencies, includePatchedDependencies } = useConfig();
   const log = useLogger();
   log.info("Generating PNPM lockfile...");
   try {
     const isRush = isRushWorkspace(workspaceRootDir);
-    const lockfile = await readWantedLockfile(
+    const lockfile = useVersion9 ? await readWantedLockfile_v9(
+      isRush ? path8.join(workspaceRootDir, "common/config/rush") : workspaceRootDir,
+      {
+        ignoreIncompatible: false
+      }
+    ) : await readWantedLockfile_v8(
       isRush ? path8.join(workspaceRootDir, "common/config/rush") : workspaceRootDir,
       {
         ignoreIncompatible: false
       }
     );
     assert3(lockfile, `No input lockfile found at ${workspaceRootDir}`);
-    const targetImporterId = getLockfileImporterId(
-      workspaceRootDir,
-      targetPackageDir
-    );
+    const targetImporterId = useVersion9 ? getLockfileImporterId_v9(workspaceRootDir, targetPackageDir) : getLockfileImporterId_v8(workspaceRootDir, targetPackageDir);
     const directoryByPackageName = Object.fromEntries(
       internalDepPackageNames.map((name) => {
         const pkg = packagesRegistry[name];
@@ -505,20 +533,14 @@ async function generatePnpmLockfile({
       })
     );
     log.debug("Pruning the lockfile");
-    const prunedLockfile = await pruneLockfile(
-      lockfile,
-      targetPackageManifest,
-      "."
-    );
-    await writeWantedLockfile(isolateDir, {
+    const prunedLockfile = useVersion9 ? await pruneLockfile_v9(lockfile, targetPackageManifest, ".") : await pruneLockfile_v8(lockfile, targetPackageManifest, ".");
+    const patchedDependencies = includePatchedDependencies ? lockfile.patchedDependencies : void 0;
+    useVersion9 ? await writeWantedLockfile_v9(isolateDir, {
       ...prunedLockfile,
-      /**
-       * Don't know how to map the patched dependencies yet, so we just include
-       * them but I don't think it would work like this. The important thing for
-       * now is that they are omitted by default, because that is the most
-       * common use case.
-       */
-      patchedDependencies: includePatchedDependencies ? lockfile.patchedDependencies : void 0
+      patchedDependencies
+    }) : await writeWantedLockfile_v8(isolateDir, {
+      ...prunedLockfile,
+      patchedDependencies
     });
     log.debug("Created lockfile at", path8.join(isolateDir, "pnpm-lock.yaml"));
   } catch (err) {
@@ -562,16 +584,7 @@ async function processLockfile({
   targetPackageManifest
 }) {
   const log = useLogger();
-  const { forceNpm } = useConfig();
-  if (forceNpm) {
-    log.info("Forcing to use NPM for isolate output");
-    await generateNpmLockfile({
-      workspaceRootDir,
-      isolateDir
-    });
-    return true;
-  }
-  const { name, version } = usePackageManager();
+  const { name, majorVersion } = usePackageManager();
   let usedFallbackToNpm = false;
   switch (name) {
     case "npm": {
@@ -582,8 +595,7 @@ async function processLockfile({
       break;
     }
     case "yarn": {
-      const versionMajor = parseInt(version.split(".")[0], 10);
-      if (versionMajor === 1) {
+      if (majorVersion === 1) {
         await generateYarnLockfile({
           workspaceRootDir,
           isolateDir
@@ -607,7 +619,8 @@ async function processLockfile({
         isolateDir,
         internalDepPackageNames,
         packagesRegistry,
-        targetPackageManifest
+        targetPackageManifest,
+        majorVersion
       });
       break;
     }
@@ -687,12 +700,11 @@ function adaptManifestInternalDeps({
 // src/lib/manifest/helpers/adapt-internal-package-manifests.ts
 async function adaptInternalPackageManifests(internalPackageNames, packagesRegistry, isolateDir) {
   const packageManager2 = usePackageManager();
-  const { forceNpm } = useConfig();
   await Promise.all(
     internalPackageNames.map(async (packageName) => {
       const { manifest, rootRelativeDir } = packagesRegistry[packageName];
       const strippedManifest = omit(manifest, ["scripts", "devDependencies"]);
-      const outputManifest = packageManager2.name === "pnpm" && !forceNpm ? (
+      const outputManifest = packageManager2.name === "pnpm" ? (
         /**
          * For PNPM the output itself is a workspace so we can preserve the specifiers
          * with "workspace:*" in the output manifest.
@@ -742,9 +754,9 @@ async function adaptTargetPackageManifest({
   workspaceRootDir
 }) {
   const packageManager2 = usePackageManager();
-  const { includeDevDependencies, forceNpm, pickFromScripts, omitFromScripts } = useConfig();
+  const { includeDevDependencies, pickFromScripts, omitFromScripts } = useConfig();
   const inputManifest = includeDevDependencies ? manifest : omit2(manifest, ["devDependencies"]);
-  const adaptedManifest = packageManager2.name === "pnpm" && !forceNpm ? (
+  const adaptedManifest = packageManager2.name === "pnpm" ? (
     /**
      * For PNPM the output itself is a workspace so we can preserve the specifiers
      * with "workspace:*" in the output manifest, but we do want to adopt the
@@ -760,6 +772,8 @@ async function adaptTargetPackageManifest({
   );
   return {
     ...adaptedManifest,
+    /** Adopt the package manager definition from the root manifest if available. */
+    packageManager: packageManager2.packageManagerString,
     /**
      * Scripts are removed by default if not explicitly picked or omitted via
      * config.
@@ -816,25 +830,15 @@ async function packDependencies({
 }) {
   const log = useLogger();
   const packedFileByName = {};
-  const { name, version } = usePackageManager();
-  const versionMajor = parseInt(version.split(".")[0], 10);
-  const usePnpmPack = name === "pnpm" && versionMajor >= 8;
-  if (usePnpmPack) {
-    log.debug("Using PNPM pack instead of NPM pack");
-  }
   for (const dependency of internalPackageNames) {
     const def = packagesRegistry[dependency];
     assert4(dependency, `Failed to find package definition for ${dependency}`);
-    const { name: name2 } = def.manifest;
-    if (packedFileByName[name2]) {
-      log.debug(`Skipping ${name2} because it has already been packed`);
+    const { name } = def.manifest;
+    if (packedFileByName[name]) {
+      log.debug(`Skipping ${name} because it has already been packed`);
       continue;
     }
-    packedFileByName[name2] = await pack(
-      def.absoluteDir,
-      packDestinationDir,
-      usePnpmPack
-    );
+    packedFileByName[name] = await pack(def.absoluteDir, packDestinationDir);
   }
   return packedFileByName;
 }
@@ -1024,10 +1028,10 @@ async function isolate(options = {}) {
   const config = resolveConfig();
   setLogLevel(config.logLevel);
   const log = useLogger();
-  const thisPackageManifest = await readTypedJson(
+  const { version: libraryVersion } = await readTypedJson(
     path19.join(path19.join(__dirname, "..", "package.json"))
   );
-  log.debug("Using isolate-package version", thisPackageManifest.version);
+  log.debug("Using isolate-package version", libraryVersion);
   const targetPackageDir = config.targetPackagePath ? path19.join(process.cwd(), config.targetPackagePath) : process.cwd();
   const workspaceRootDir = config.targetPackagePath ? process.cwd() : path19.join(targetPackageDir, config.workspaceRoot);
   const buildOutputDir = await getBuildOutputDir(targetPackageDir);
@@ -1061,6 +1065,9 @@ async function isolate(options = {}) {
     packageManager2.name,
     packageManager2.version
   );
+  if (shouldUsePnpmPack()) {
+    log.debug("Use PNPM pack instead of NPM pack");
+  }
   const packagesRegistry = await createPackagesRegistry(
     workspaceRootDir,
     config.workspacePackages
@@ -1114,7 +1121,7 @@ async function isolate(options = {}) {
     manifest.packageManager = `npm@${npmVersion}`;
     await writeManifest(isolateDir, manifest);
   }
-  if (packageManager2.name === "pnpm" && !config.forceNpm) {
+  if (packageManager2.name === "pnpm") {
     if (isRushWorkspace(workspaceRootDir)) {
       const packagesFolderNames = unique(
         internalPackageNames.map(