isolate-package 1.9.4 → 1.10.0-2

package/README.md

@@ -60,6 +60,9 @@ integrated, check out [mono-ts](https://github.com/0x80/mono-ts)
 - Compatible with the Firebase tools CLI, including 1st and 2nd generation
   Firebase Functions. For more information see
   [the Firebase instructions](./docs/firebase.md).
+- Available in a
+  [forked version of firebase-tools](https://github.com/0x80/firebase-tools-with-isolate)
+  to preserve live code updates when running the emulators
 
 ## Installation
 
@@ -72,6 +75,11 @@ package manager should work.
 
 ## Usage
 
+> !! If you plan use this for Firebase deployments, and you want to preserve
+> live code updates when running the local emulators, you will want to use
+> [firebase-tools-with-isolate](https://github.com/0x80/firebase-tools-with-isolate)
+> instead.
+
 This package exposes a binary called `isolate`.
 
 Run `npx isolate` from the root of the package you want to isolate. Make sure
@@ -221,6 +229,11 @@ 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`
@@ -338,18 +351,18 @@ configuration.
 
 ### NPM
 
-For NPM we use a tool called Arborist which is an integral part of the NPM
+For NPM we use a tool called Arborist, which is an integral part of the NPM
 codebase. It is executed in the isolate output directory and requires the
 adapted lockfile and the `node_modules` directory from the root of the
 repository. As this directory is typically quite large, copying it over as part
 of the isolate flow is not very desirable.
 
 To work around this, we move it to the isolate output and then move it back
-after Arborist has finished doing its thing. Luckily it doesn't take long and
-hopefully this doesn't create any unwanted side effects for IDEs and other tools
-that depend on the content of the directory.
+after Arborist has finished doing its thing.
 
-When errors occur in this process, the folder should still be moved back.
+> !! Warning: This will not be compatible with setups that run multiple
+> isolation processes in parallel. Hopefully a future update to NPM Arborist
+> (the part the generates the lockfile) will solve this.
 
 ### PNPM
 

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 type IsolateConfigResolved = {
     buildDirName?: string;
     includeDevDependencies: boolean;
+    includePatchedDependencies: boolean;
     isolateDirName: string;
     logLevel: "info" | "debug" | "warn" | "error";
     targetPackagePath?: string;
@@ -35,4 +36,4 @@ type IsolateExports = {
     isolate: typeof isolate;
 };
 
-export { IsolateExports, Logger, isolate };
+export { type IsolateExports, type Logger, isolate };

package/dist/index.mjs

@@ -7,7 +7,7 @@ import path16 from "node:path";
 import fs5 from "fs-extra";
 import assert from "node:assert";
 import path2 from "node:path";
-import { isEmpty } from "ramda";
+import { isEmpty } from "remeda";
 
 // src/lib/logger.ts
 import chalk from "chalk";
@@ -124,10 +124,10 @@ async function readTypedJson(filePath) {
 }
 
 // src/lib/utils/pack.ts
-import fs2 from "fs-extra";
 import { exec } from "node:child_process";
+import fs2 from "node:fs";
 import path from "node:path";
-async function pack(srcDir, dstDir, usePnpmPack = false) {
+async function pack(srcDir, dstDir, usePnpmPack) {
   const execOptions = {
     maxBuffer: 10 * 1024 * 1024
   };
@@ -138,9 +138,9 @@ async function pack(srcDir, dstDir, usePnpmPack = false) {
     exec(
       `pnpm pack --pack-destination "${dstDir}"`,
       execOptions,
-      (err, stdout2, stderr) => {
+      (err, stdout2) => {
         if (err) {
-          log.error(stderr);
+          log.error(getErrorMessage(err));
           return reject(err);
         }
         resolve(stdout2);
@@ -200,6 +200,7 @@ function readTypedYamlSync(filePath) {
 var configDefaults = {
   buildDirName: void 0,
   includeDevDependencies: false,
+  includePatchedDependencies: false,
   isolateDirName: "isolate",
   logLevel: "info",
   targetPackagePath: void 0,
@@ -257,7 +258,7 @@ function resolveConfig() {
 }
 
 // src/lib/lockfile/process-lockfile.ts
-import { mapObjIndexed } from "ramda";
+import { mapValues } from "remeda";
 
 // src/lib/package-manager/helpers/infer-from-files.ts
 import fs6 from "fs-extra";
@@ -349,6 +350,7 @@ async function generateNpmLockfile({
   const origRootNodeModulesPath = path5.join(workspaceRootDir, "node_modules");
   const tempRootNodeModulesPath = path5.join(isolateDir, "node_modules");
   let hasMovedNodeModules = false;
+  let hasError = false;
   try {
     if (!fs8.existsSync(origRootNodeModulesPath)) {
       throw new Error(
@@ -359,7 +361,7 @@ async function generateNpmLockfile({
     await fs8.move(origRootNodeModulesPath, tempRootNodeModulesPath);
     hasMovedNodeModules = true;
     const arborist = new Arborist({ path: isolateDir });
-    log.debug(`Build tree`);
+    log.debug(`Building tree...`);
     const { meta } = await arborist.buildIdealTree();
     meta?.commit();
     const lockfilePath = path5.join(isolateDir, "package-lock.json");
@@ -368,12 +370,16 @@ async function generateNpmLockfile({
   } catch (err) {
     console.error(inspectValue(err));
     log.error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
+    hasError = true;
   } finally {
     if (hasMovedNodeModules) {
       log.debug(`Restoring node_modules to the workspace root`);
       await fs8.move(tempRootNodeModulesPath, origRootNodeModulesPath);
     }
   }
+  if (hasError) {
+    throw new Error("Failed to generate lockfile");
+  }
 }
 
 // src/lib/lockfile/helpers/generate-pnpm-lockfile.ts
@@ -384,7 +390,7 @@ import {
 } from "@pnpm/lockfile-file";
 import assert3 from "node:assert";
 import path6 from "node:path";
-import { pick } from "ramda";
+import { pick } from "remeda";
 async function generatePnpmLockfile({
   workspaceRootDir,
   targetPackageDir,
@@ -392,7 +398,7 @@ async function generatePnpmLockfile({
   internalDepPackageNames,
   packagesRegistry
 }) {
-  const { includeDevDependencies } = useConfig();
+  const { includeDevDependencies, includePatchedDependencies } = useConfig();
   const log = useLogger();
   log.info("Generating PNPM lockfile...");
   try {
@@ -421,7 +427,7 @@ async function generatePnpmLockfile({
     ];
     log.debug("Relevant importer ids:", relevantImporterIds);
     lockfile.importers = Object.fromEntries(
-      Object.entries(pick(relevantImporterIds, lockfile.importers)).map(
+      Object.entries(pick(lockfile.importers, relevantImporterIds)).map(
         ([importerId, importer]) => {
           if (importerId === targetImporterId) {
             log.debug("Setting target package importer on root");
@@ -429,6 +435,7 @@ async function generatePnpmLockfile({
               ".",
               pnpmMapImporter(importer, {
                 includeDevDependencies,
+                includePatchedDependencies,
                 directoryByPackageName
               })
             ];
@@ -438,6 +445,7 @@ async function generatePnpmLockfile({
             importerId,
             pnpmMapImporter(importer, {
               includeDevDependencies,
+              includePatchedDependencies,
               directoryByPackageName
             })
           ];
@@ -447,7 +455,7 @@ async function generatePnpmLockfile({
     await writeWantedLockfile(isolateDir, lockfile);
     log.debug("Created lockfile at", path6.join(isolateDir, "pnpm-lock.yaml"));
   } catch (err) {
-    log.error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
+    throw new Error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
   }
 }
 
@@ -473,25 +481,38 @@ async function generateYarnLockfile({
     execSync2(`yarn install --cwd ${isolateDir}`);
     log.debug("Generated lockfile at", newLockfilePath);
   } catch (err) {
-    log.error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
+    throw new Error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
   }
 }
 
 // src/lib/lockfile/process-lockfile.ts
-function pnpmMapImporter({ dependencies, devDependencies, ...rest }, {
+function pnpmMapImporter({
+  dependencies,
+  devDependencies,
+  patchedDependencies,
+  ...rest
+}, {
   includeDevDependencies,
+  includePatchedDependencies,
   directoryByPackageName
 }) {
   return {
     dependencies: dependencies ? pnpmMapDependenciesLinks(dependencies, directoryByPackageName) : void 0,
     devDependencies: includeDevDependencies && devDependencies ? pnpmMapDependenciesLinks(devDependencies, directoryByPackageName) : void 0,
+    /**
+     * 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 ? patchedDependencies : void 0,
     ...rest
   };
 }
 function pnpmMapDependenciesLinks(def, directoryByPackageName) {
-  return mapObjIndexed(
-    (version, name) => version.startsWith("link:") ? `link:./${directoryByPackageName[name]}` : version,
-    def
+  return mapValues(
+    def,
+    (value, key) => value.startsWith("link:") ? `link:./${directoryByPackageName[key]}` : value
   );
 }
 async function processLockfile({
@@ -562,11 +583,11 @@ async function processLockfile({
 }
 
 // src/lib/manifest/adapt-target-package-manifest.ts
-import { omit as omit2, pick as pick2 } from "ramda";
+import { omit as omit2, pick as pick2 } from "remeda";
 
 // src/lib/manifest/helpers/adapt-internal-package-manifests.ts
 import path10 from "node:path";
-import { omit } from "ramda";
+import { omit } from "remeda";
 
 // src/lib/manifest/io.ts
 import fs10 from "fs-extra";
@@ -630,7 +651,7 @@ async function adaptInternalPackageManifests(internalPackageNames, packagesRegis
   await Promise.all(
     internalPackageNames.map(async (packageName) => {
       const { manifest, rootRelativeDir } = packagesRegistry[packageName];
-      const inputManifest = includeDevDependencies ? omit(["peerDependencies"], manifest) : omit(["devDependencies", "peerDependencies"], manifest);
+      const inputManifest = includeDevDependencies ? omit(manifest, ["peerDependencies"]) : omit(manifest, ["devDependencies", "peerDependencies"]);
       const outputManifest = packageManager2.name === "pnpm" && !forceNpm ? (
         /**
          * For PNPM the output itself is a workspace so we can preserve the specifiers
@@ -654,7 +675,7 @@ async function adaptInternalPackageManifests(internalPackageNames, packagesRegis
 async function adaptTargetPackageManifest(manifest, packagesRegistry, isolateDir) {
   const packageManager2 = usePackageManager();
   const { includeDevDependencies, forceNpm, pickFromScripts, omitFromScripts } = useConfig();
-  const inputManifest = includeDevDependencies ? manifest : omit2(["devDependencies"], manifest);
+  const inputManifest = includeDevDependencies ? manifest : omit2(manifest, ["devDependencies"]);
   const adaptedManifest = packageManager2.name === "pnpm" && !forceNpm ? (
     /**
      * For PNPM the output itself is a workspace so we can preserve the specifiers
@@ -674,7 +695,7 @@ async function adaptTargetPackageManifest(manifest, packagesRegistry, isolateDir
      * Scripts are removed by default if not explicitly picked or omitted via
      * config.
      */
-    scripts: pickFromScripts ? pick2(pickFromScripts, manifest.scripts) : omitFromScripts ? omit2(omitFromScripts, manifest.scripts) : void 0
+    scripts: pickFromScripts ? pick2(manifest.scripts ?? {}, pickFromScripts) : omitFromScripts ? omit2(manifest.scripts ?? {}, omitFromScripts) : void 0
   };
   await writeManifest(isolateDir, outputManifest);
 }
@@ -891,7 +912,7 @@ async function createPackagesRegistry(workspaceRootDir, workspacePackagesOverrid
 }
 
 // src/lib/registry/list-internal-packages.ts
-import { uniq } from "ramda";
+import { uniq } from "remeda";
 function listInternalPackages(manifest, packagesRegistry, { includeDevDependencies = false } = {}) {
   const allWorkspacePackageNames = Object.keys(packagesRegistry);
   const internalPackageNames = (includeDevDependencies ? [