isolate-package 1.32.0 → 1.33.0-0

package/src/lib/patches/copy-patches.test.ts

@@ -15,9 +15,17 @@ vi.mock("fs-extra", () => ({
 vi.mock("~/lib/utils", () => ({
   filterPatchedDependencies: vi.fn(),
   getIsolateRelativeLogPath: vi.fn((p: string) => p),
+  getPackageName: vi.fn((spec: string) => {
+    if (spec.startsWith("@")) {
+      const parts = spec.split("@");
+      return `@${parts[1] ?? ""}`;
+    }
+    return spec.split("@")[0] ?? "";
+  }),
   getRootRelativeLogPath: vi.fn((p: string) => p),
   isRushWorkspace: vi.fn(() => false),
   readTypedJson: vi.fn(),
+  readTypedJsonSync: vi.fn(),
   readTypedYamlSync: vi.fn(),
 }));
 
@@ -29,16 +37,25 @@ vi.mock("~/lib/package-manager", () => ({
 /** Mock the pnpm lockfile readers */
 vi.mock("pnpm_lockfile_file_v8", () => ({
   readWantedLockfile: vi.fn(() => Promise.resolve(null)),
+  getLockfileImporterId: vi.fn(
+    (root: string, dir: string) => dir.replace(`${root}/`, "") || ".",
+  ),
 }));
 
 vi.mock("pnpm_lockfile_file_v9", () => ({
   readWantedLockfile: vi.fn(() => Promise.resolve(null)),
+  getLockfileImporterId: vi.fn(
+    (root: string, dir: string) => dir.replace(`${root}/`, "") || ".",
+  ),
 }));
 
 const fs = vi.mocked((await import("fs-extra")).default);
 const { filterPatchedDependencies, readTypedJson, readTypedYamlSync } =
   vi.mocked(await import("~/lib/utils"));
 const { usePackageManager } = vi.mocked(await import("~/lib/package-manager"));
+const { readWantedLockfile: readWantedLockfile_v9 } = vi.mocked(
+  await import("pnpm_lockfile_file_v9"),
+);
 
 describe("copyPatches", () => {
   beforeEach(() => {
@@ -65,6 +82,8 @@ describe("copyPatches", () => {
 
     const result = await copyPatches({
       workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/test",
+      internalDepPackageNames: [],
       targetPackageManifest: { name: "test", version: "1.0.0" },
       isolateDir: "/workspace/isolate",
       packagesRegistry: {},
@@ -126,6 +145,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: { name: "test", version: "1.0.0" },
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -146,6 +167,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: { name: "test", version: "1.0.0" },
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -176,6 +199,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -214,6 +239,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -256,6 +283,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -287,6 +316,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -321,6 +352,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -364,6 +397,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -409,6 +444,8 @@ describe("copyPatches", () => {
 
       const result = await copyPatches({
         workspaceRootDir: "/workspace",
+        targetPackageDir: "/workspace/packages/test",
+        internalDepPackageNames: [],
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
         packagesRegistry: {},
@@ -456,6 +493,8 @@ describe("copyPatches", () => {
 
     const result = await copyPatches({
       workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/test",
+      internalDepPackageNames: [],
       targetPackageManifest: targetManifest,
       isolateDir: "/workspace/isolate",
       packagesRegistry: {},
@@ -509,6 +548,8 @@ describe("copyPatches", () => {
 
     const result = await copyPatches({
       workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/test",
+      internalDepPackageNames: [],
       targetPackageManifest: consumerManifest,
       isolateDir: "/workspace/isolate",
       packagesRegistry: {
@@ -536,4 +577,88 @@ describe("copyPatches", () => {
     expect(reachable!.has("firebase-package")).toBe(true);
     expect(reachable!.has("tslib")).toBe(true);
   });
+
+  it("should pick up deep external-to-external transitives from the pnpm lockfile (regression: issue #167 follow-up)", async () => {
+    /**
+     * Target depends on `@react-pdf/renderer` (external). The patched
+     * `@react-pdf/render` is only a transitive of `@react-pdf/renderer`. The
+     * manifest walker can't see it because it can't open external manifests,
+     * so the lockfile walker has to surface it.
+     */
+    const targetManifest: PackageManifest = {
+      name: "consumer",
+      version: "1.0.0",
+      dependencies: { "@react-pdf/renderer": "^4.0.0" },
+    };
+
+    readTypedYamlSync.mockReturnValue({
+      patchedDependencies: {
+        "@react-pdf/render@4.3.0": "patches/@react-pdf__render@4.3.0.patch",
+      },
+    });
+    readTypedJson.mockResolvedValue({
+      name: "root",
+      version: "1.0.0",
+    } as PackageManifest);
+
+    filterPatchedDependencies.mockReturnValue({
+      "@react-pdf/render@4.3.0": "patches/@react-pdf__render@4.3.0.patch",
+    });
+
+    fs.existsSync.mockReturnValue(true);
+
+    usePackageManager.mockReturnValue({
+      name: "pnpm",
+      majorVersion: 9,
+      version: "9.0.0",
+      packageManagerString: "pnpm@9.0.0",
+    });
+
+    /**
+     * Fake v9 lockfile: target importer depends on @react-pdf/renderer, which
+     * has @react-pdf/render as its only resolved dep.
+     */
+    readWantedLockfile_v9.mockResolvedValue({
+      lockfileVersion: "9.0",
+      importers: {
+        "packages/consumer": {
+          specifiers: { "@react-pdf/renderer": "^4.0.0" },
+          dependencies: { "@react-pdf/renderer": "4.0.0" },
+        },
+      },
+      packages: {
+        "@react-pdf/renderer@4.0.0": {
+          resolution: { integrity: "sha512-x" },
+          dependencies: { "@react-pdf/render": "4.3.0" },
+        },
+        "@react-pdf/render@4.3.0": {
+          resolution: { integrity: "sha512-y" },
+        },
+      },
+    } as unknown as Awaited<ReturnType<typeof readWantedLockfile_v9>>);
+
+    const result = await copyPatches({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/packages/consumer",
+      internalDepPackageNames: [],
+      targetPackageManifest: targetManifest,
+      isolateDir: "/workspace/isolate",
+      packagesRegistry: {},
+      includeDevDependencies: false,
+    });
+
+    expect(result).toEqual({
+      "@react-pdf/render@4.3.0": {
+        path: "patches/@react-pdf__render@4.3.0.patch",
+        hash: "",
+      },
+    });
+
+    const filterCall = filterPatchedDependencies.mock.calls[0]?.[0];
+    expect(filterCall).toBeDefined();
+    const reachable = filterCall!.reachableDependencyNames;
+    expect(reachable).toBeInstanceOf(Set);
+    expect(reachable!.has("@react-pdf/renderer")).toBe(true);
+    expect(reachable!.has("@react-pdf/render")).toBe(true);
+  });
 });

package/src/lib/patches/copy-patches.ts

@@ -18,23 +18,29 @@ import {
   readTypedJson,
   readTypedYamlSync,
 } from "~/lib/utils";
+import { collectInstalledNamesFromBunLockfile } from "./collect-installed-names-bun";
+import { collectInstalledNamesFromPnpmLockfile } from "./collect-installed-names-pnpm";
 
 export async function copyPatches({
   workspaceRootDir,
+  targetPackageDir,
   targetPackageManifest,
   packagesRegistry,
+  internalDepPackageNames,
   isolateDir,
   includeDevDependencies,
 }: {
   workspaceRootDir: string;
+  targetPackageDir: string;
   targetPackageManifest: PackageManifest;
   packagesRegistry: PackagesRegistry;
+  internalDepPackageNames: string[];
   isolateDir: string;
   includeDevDependencies: boolean;
 }): Promise<Record<string, PatchFile>> {
   const log = useLogger();
 
-  const { name: packageManagerName } = usePackageManager();
+  const { name: packageManagerName, majorVersion } = usePackageManager();
 
   let patchedDependencies: Record<string, string> | undefined;
 
@@ -102,6 +108,37 @@ export async function copyPatches({
     includeDevDependencies,
   });
 
+  /**
+   * Manifest-based reachability misses external→external transitives because
+   * external manifests aren't loaded here. Walk the package-manager's
+   * lockfile to also pick up those names, so a patch for a deeply-nested
+   * external dep (e.g. `@react-pdf/render` reached via `@react-pdf/renderer`)
+   * survives isolation.
+   */
+  const lockfileInstalledNames =
+    packageManagerName === "pnpm"
+      ? await collectInstalledNamesFromPnpmLockfile({
+          workspaceRootDir,
+          targetPackageDir,
+          internalDepPackageNames,
+          packagesRegistry,
+          majorVersion,
+          includeDevDependencies,
+        })
+      : packageManagerName === "bun"
+        ? collectInstalledNamesFromBunLockfile({
+            workspaceRootDir,
+            targetPackageDir,
+            internalDepPackageNames,
+            packagesRegistry,
+            includeDevDependencies,
+          })
+        : new Set<string>();
+
+  for (const name of lockfileInstalledNames) {
+    reachableDependencyNames.add(name);
+  }
+
   const filteredPatches = filterPatchedDependencies({
     patchedDependencies,
     targetPackageManifest,

package/src/lib/patches/write-isolate-pnpm-workspace.test.ts

@@ -0,0 +1,189 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { PatchFile } from "~/lib/types";
+import { writeIsolatePnpmWorkspace } from "./write-isolate-pnpm-workspace";
+
+vi.mock("fs-extra", () => ({
+  default: {
+    copyFileSync: vi.fn(),
+  },
+}));
+
+vi.mock("~/lib/utils", () => ({
+  readTypedYamlSync: vi.fn(),
+  writeTypedYamlSync: vi.fn(),
+}));
+
+const fs = vi.mocked((await import("fs-extra")).default);
+const { readTypedYamlSync, writeTypedYamlSync } = vi.mocked(
+  await import("~/lib/utils"),
+);
+
+const workspaceRootDir = "/workspace";
+const isolateDir = "/workspace/isolate";
+
+describe("writeIsolatePnpmWorkspace", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("retains only the patches that were copied", () => {
+    readTypedYamlSync.mockReturnValue({
+      packages: ["packages/*"],
+      patchedDependencies: {
+        "lodash@4.17.21": "patches/lodash@4.17.21.patch",
+        "react@18.2.0": "patches/react@18.2.0.patch",
+        "axios@1.6.0": "patches/axios@1.6.0.patch",
+      },
+    });
+
+    const copiedPatches: Record<string, PatchFile> = {
+      "lodash@4.17.21": {
+        path: "patches/lodash@4.17.21.patch",
+        hash: "abc",
+      },
+    };
+
+    writeIsolatePnpmWorkspace({
+      workspaceRootDir,
+      isolateDir,
+      copiedPatches,
+    });
+
+    expect(fs.copyFileSync).not.toHaveBeenCalled();
+    expect(writeTypedYamlSync).toHaveBeenCalledTimes(1);
+    expect(writeTypedYamlSync).toHaveBeenCalledWith(
+      "/workspace/isolate/pnpm-workspace.yaml",
+      {
+        packages: ["packages/*"],
+        patchedDependencies: {
+          "lodash@4.17.21": "patches/lodash@4.17.21.patch",
+        },
+      },
+    );
+  });
+
+  it("removes the patchedDependencies field when no patches were copied", () => {
+    readTypedYamlSync.mockReturnValue({
+      packages: ["packages/*"],
+      patchedDependencies: {
+        "lodash@4.17.21": "patches/lodash@4.17.21.patch",
+      },
+    });
+
+    writeIsolatePnpmWorkspace({
+      workspaceRootDir,
+      isolateDir,
+      copiedPatches: {},
+    });
+
+    expect(fs.copyFileSync).not.toHaveBeenCalled();
+    expect(writeTypedYamlSync).toHaveBeenCalledWith(
+      "/workspace/isolate/pnpm-workspace.yaml",
+      { packages: ["packages/*"] },
+    );
+  });
+
+  it("falls back to a verbatim copy when the file has no patchedDependencies field", () => {
+    readTypedYamlSync.mockReturnValue({
+      packages: ["packages/*"],
+    });
+
+    writeIsolatePnpmWorkspace({
+      workspaceRootDir,
+      isolateDir,
+      copiedPatches: {},
+    });
+
+    expect(writeTypedYamlSync).not.toHaveBeenCalled();
+    expect(fs.copyFileSync).toHaveBeenCalledWith(
+      "/workspace/pnpm-workspace.yaml",
+      "/workspace/isolate/pnpm-workspace.yaml",
+    );
+  });
+
+  it("preserves unrelated top-level fields", () => {
+    readTypedYamlSync.mockReturnValue({
+      packages: ["packages/*"],
+      onlyBuiltDependencies: ["esbuild"],
+      overrides: { foo: "1.0.0" },
+      patchedDependencies: {
+        "lodash@4.17.21": "patches/lodash@4.17.21.patch",
+        "react@18.2.0": "patches/react@18.2.0.patch",
+      },
+    });
+
+    const copiedPatches: Record<string, PatchFile> = {
+      "react@18.2.0": { path: "patches/react@18.2.0.patch", hash: "def" },
+    };
+
+    writeIsolatePnpmWorkspace({
+      workspaceRootDir,
+      isolateDir,
+      copiedPatches,
+    });
+
+    expect(writeTypedYamlSync).toHaveBeenCalledWith(
+      "/workspace/isolate/pnpm-workspace.yaml",
+      {
+        packages: ["packages/*"],
+        onlyBuiltDependencies: ["esbuild"],
+        overrides: { foo: "1.0.0" },
+        patchedDependencies: {
+          "react@18.2.0": "patches/react@18.2.0.patch",
+        },
+      },
+    );
+  });
+
+  it("copies verbatim when every patch is kept (preserving comments and order)", () => {
+    readTypedYamlSync.mockReturnValue({
+      packages: ["packages/*"],
+      patchedDependencies: {
+        "lodash@4.17.21": "patches/lodash@4.17.21.patch",
+        "react@18.2.0": "patches/react@18.2.0.patch",
+      },
+    });
+
+    const copiedPatches: Record<string, PatchFile> = {
+      "lodash@4.17.21": {
+        path: "patches/lodash@4.17.21.patch",
+        hash: "abc",
+      },
+      "react@18.2.0": { path: "patches/react@18.2.0.patch", hash: "def" },
+    };
+
+    writeIsolatePnpmWorkspace({
+      workspaceRootDir,
+      isolateDir,
+      copiedPatches,
+    });
+
+    expect(writeTypedYamlSync).not.toHaveBeenCalled();
+    expect(fs.copyFileSync).toHaveBeenCalledWith(
+      "/workspace/pnpm-workspace.yaml",
+      "/workspace/isolate/pnpm-workspace.yaml",
+    );
+  });
+
+  it("falls back to a verbatim copy when the yaml cannot be parsed", () => {
+    readTypedYamlSync.mockImplementation(() => {
+      throw new Error("bad yaml");
+    });
+
+    writeIsolatePnpmWorkspace({
+      workspaceRootDir,
+      isolateDir,
+      copiedPatches: {},
+    });
+
+    expect(writeTypedYamlSync).not.toHaveBeenCalled();
+    expect(fs.copyFileSync).toHaveBeenCalledWith(
+      "/workspace/pnpm-workspace.yaml",
+      "/workspace/isolate/pnpm-workspace.yaml",
+    );
+  });
+});

package/src/lib/patches/write-isolate-pnpm-workspace.ts

@@ -0,0 +1,80 @@
+import fs from "fs-extra";
+import path from "node:path";
+import { useLogger } from "~/lib/logger";
+import type { PatchFile, PnpmSettings } from "~/lib/types";
+import { readTypedYamlSync, writeTypedYamlSync } from "~/lib/utils";
+
+/**
+ * Copy `pnpm-workspace.yaml` from the workspace root to the isolate directory,
+ * filtering its `patchedDependencies` field so it only references patches that
+ * were actually copied to the isolate. Without this, `pnpm install` in the
+ * isolate fails when patches that don't apply to the target package are
+ * declared in the workspace root config (see issue #178).
+ *
+ * The yaml is only rewritten when filtering is required. The file is copied
+ * verbatim — preserving comments, key order, and trailing whitespace — when
+ * any of the following hold:
+ *
+ * - The source yaml cannot be read or parsed.
+ * - The parsed settings have no `patchedDependencies` field.
+ * - Every entry in `patchedDependencies` is also present in `copiedPatches`
+ *   (no exclusions, so rewriting would only churn formatting).
+ *
+ * Otherwise, `patchedDependencies` is rewritten to the entries in
+ * `copiedPatches` (or removed entirely when none remain).
+ */
+export function writeIsolatePnpmWorkspace({
+  workspaceRootDir,
+  isolateDir,
+  copiedPatches,
+}: {
+  workspaceRootDir: string;
+  isolateDir: string;
+  copiedPatches: Record<string, PatchFile>;
+}) {
+  const log = useLogger();
+  const sourcePath = path.join(workspaceRootDir, "pnpm-workspace.yaml");
+  const targetPath = path.join(isolateDir, "pnpm-workspace.yaml");
+
+  let settings: PnpmSettings | undefined;
+
+  try {
+    settings = readTypedYamlSync<PnpmSettings>(sourcePath);
+  } catch (error) {
+    log.warn(
+      `Could not read pnpm-workspace.yaml, falling back to verbatim copy: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    fs.copyFileSync(sourcePath, targetPath);
+    return;
+  }
+
+  if (!settings || !settings.patchedDependencies) {
+    fs.copyFileSync(sourcePath, targetPath);
+    return;
+  }
+
+  /**
+   * If every patch declared in the source yaml was kept, copy verbatim so
+   * comments, ordering, and trailing whitespace are preserved.
+   */
+  const sourceSpecs = Object.keys(settings.patchedDependencies);
+  const copiedSpecs = new Set(Object.keys(copiedPatches));
+  const hasExclusions = sourceSpecs.some((spec) => !copiedSpecs.has(spec));
+
+  if (!hasExclusions) {
+    fs.copyFileSync(sourcePath, targetPath);
+    return;
+  }
+
+  const filteredEntries = Object.entries(copiedPatches).map(
+    ([spec, patchFile]) => [spec, patchFile.path] as const,
+  );
+
+  if (filteredEntries.length > 0) {
+    settings.patchedDependencies = Object.fromEntries(filteredEntries);
+  } else {
+    delete settings.patchedDependencies;
+  }
+
+  writeTypedYamlSync(targetPath, settings);
+}