isolate-package 1.13.1 → 1.14.0-0

package/README.md

@@ -210,30 +210,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 +317,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 +337,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,109 @@ 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/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 (fs3.existsSync(path2.join(workspaceRoot, lockfileName))) {
+      return { name, version: getVersion(name) };
+    }
+  }
+  if (fs3.existsSync(path2.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 fs4 from "fs-extra";
+import assert from "node:assert";
+import path3 from "node:path";
+function inferFromManifest(workspaceRoot) {
+  const log = useLogger();
+  const rootManifest = readTypedJsonSync(
+    path3.join(workspaceRoot, "package.json")
+  );
+  if (!rootManifest.packageManager) {
+    log.debug("No packageManager field found in root manifest");
+    return;
+  }
+  const [name, version = "*"] = rootManifest.packageManager.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 };
+}
+
+// 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, version } = usePackageManager();
+  const majorVersion = parseInt(version.split(".")[0], 10);
+  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 +263,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 +277,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 +301,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 +342,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 +365,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";
@@ -462,7 +469,6 @@ async function generatePnpmLockfile({
       internalDepPackageNames.map((name) => {
         const pkg = packagesRegistry[name];
         assert3(pkg, `Package ${name} not found in packages registry`);
-        console.log("pkg.rootRelativeDir", pkg.rootRelativeDir);
         return [name, pkg.rootRelativeDir];
       })
     );
@@ -563,15 +569,6 @@ 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();
   let usedFallbackToNpm = false;
   switch (name) {
@@ -688,12 +685,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.
@@ -743,9 +739,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
@@ -817,25 +813,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;
 }
@@ -1062,6 +1048,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
@@ -1115,7 +1104,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(