isolate-package 1.31.0 → 1.32.1

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

@@ -67,6 +67,7 @@ describe("copyPatches", () => {
       workspaceRootDir: "/workspace",
       targetPackageManifest: { name: "test", version: "1.0.0" },
       isolateDir: "/workspace/isolate",
+      packagesRegistry: {},
       includeDevDependencies: false,
     });
 
@@ -127,6 +128,7 @@ describe("copyPatches", () => {
         workspaceRootDir: "/workspace",
         targetPackageManifest: { name: "test", version: "1.0.0" },
         isolateDir: "/workspace/isolate",
+        packagesRegistry: {},
         includeDevDependencies: false,
       });
 
@@ -146,6 +148,7 @@ describe("copyPatches", () => {
         workspaceRootDir: "/workspace",
         targetPackageManifest: { name: "test", version: "1.0.0" },
         isolateDir: "/workspace/isolate",
+        packagesRegistry: {},
         includeDevDependencies: false,
       });
 
@@ -175,6 +178,7 @@ describe("copyPatches", () => {
         workspaceRootDir: "/workspace",
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
+        packagesRegistry: {},
         includeDevDependencies: false,
       });
 
@@ -212,6 +216,7 @@ describe("copyPatches", () => {
         workspaceRootDir: "/workspace",
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
+        packagesRegistry: {},
         includeDevDependencies: true,
       });
 
@@ -222,6 +227,7 @@ describe("copyPatches", () => {
         patchedDependencies: { "vitest@1.0.0": "patches/vitest.patch" },
         targetPackageManifest: targetManifest,
         includeDevDependencies: true,
+        reachableDependencyNames: expect.any(Set),
       });
       expect(fs.copy).toHaveBeenCalledWith(
         "/workspace/patches/vitest.patch",
@@ -252,6 +258,7 @@ describe("copyPatches", () => {
         workspaceRootDir: "/workspace",
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
+        packagesRegistry: {},
         includeDevDependencies: false,
       });
 
@@ -282,6 +289,7 @@ describe("copyPatches", () => {
         workspaceRootDir: "/workspace",
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
+        packagesRegistry: {},
         includeDevDependencies: false,
       });
 
@@ -315,6 +323,7 @@ describe("copyPatches", () => {
         workspaceRootDir: "/workspace",
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
+        packagesRegistry: {},
         includeDevDependencies: false,
       });
 
@@ -357,6 +366,7 @@ describe("copyPatches", () => {
         workspaceRootDir: "/workspace",
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
+        packagesRegistry: {},
         includeDevDependencies: false,
       });
 
@@ -401,6 +411,7 @@ describe("copyPatches", () => {
         workspaceRootDir: "/workspace",
         targetPackageManifest: targetManifest,
         isolateDir: "/workspace/isolate",
+        packagesRegistry: {},
         includeDevDependencies: false,
       });
 
@@ -447,6 +458,7 @@ describe("copyPatches", () => {
       workspaceRootDir: "/workspace",
       targetPackageManifest: targetManifest,
       isolateDir: "/workspace/isolate",
+      packagesRegistry: {},
       includeDevDependencies: false,
     });
 
@@ -458,4 +470,70 @@ describe("copyPatches", () => {
       "/workspace/isolate/patches/lodash.patch",
     );
   });
+
+  it("should pass reachable transitive dep names from internal packages to the filter (regression: issue #167)", async () => {
+    /**
+     * Target `consumer` depends on internal `firebase-package`, which in turn
+     * depends on `tslib`. A patch for `tslib@2.0.0` declared at the workspace
+     * root must reach the filter with `tslib` in `reachableDependencyNames`
+     * so it can be preserved even though `consumer` doesn't list it directly.
+     */
+    const consumerManifest: PackageManifest = {
+      name: "consumer",
+      version: "1.0.0",
+      dependencies: { "firebase-package": "file:./packages/firebase-package" },
+    };
+
+    readTypedYamlSync.mockReturnValue({
+      patchedDependencies: {
+        "tslib@2.0.0": "patches/tslib@2.0.0.patch",
+      },
+    });
+    readTypedJson.mockResolvedValue({
+      name: "root",
+      version: "1.0.0",
+    } as PackageManifest);
+
+    filterPatchedDependencies.mockReturnValue({
+      "tslib@2.0.0": "patches/tslib@2.0.0.patch",
+    });
+
+    fs.existsSync.mockReturnValue(true);
+
+    usePackageManager.mockReturnValue({
+      name: "pnpm",
+      majorVersion: 9,
+      version: "9.0.0",
+      packageManagerString: "pnpm@9.0.0",
+    });
+
+    const result = await copyPatches({
+      workspaceRootDir: "/workspace",
+      targetPackageManifest: consumerManifest,
+      isolateDir: "/workspace/isolate",
+      packagesRegistry: {
+        "firebase-package": {
+          absoluteDir: "/workspace/packages/firebase-package",
+          rootRelativeDir: "packages/firebase-package",
+          manifest: {
+            name: "firebase-package",
+            version: "1.0.0",
+            dependencies: { tslib: "^2.0.0" },
+          },
+        },
+      },
+      includeDevDependencies: false,
+    });
+
+    expect(result).toEqual({
+      "tslib@2.0.0": { path: "patches/tslib@2.0.0.patch", hash: "" },
+    });
+
+    const filterCall = filterPatchedDependencies.mock.calls[0]?.[0];
+    expect(filterCall).toBeDefined();
+    const reachable = filterCall!.reachableDependencyNames;
+    expect(reachable).toBeInstanceOf(Set);
+    expect(reachable!.has("firebase-package")).toBe(true);
+    expect(reachable!.has("tslib")).toBe(true);
+  });
 });

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

@@ -4,7 +4,13 @@ import { readWantedLockfile as readWantedLockfile_v8 } from "pnpm_lockfile_file_
 import { readWantedLockfile as readWantedLockfile_v9 } from "pnpm_lockfile_file_v9";
 import { useLogger } from "~/lib/logger";
 import { usePackageManager } from "~/lib/package-manager";
-import type { PackageManifest, PatchFile, PnpmSettings } from "~/lib/types";
+import { collectReachablePackageNames } from "~/lib/registry";
+import type {
+  PackageManifest,
+  PackagesRegistry,
+  PatchFile,
+  PnpmSettings,
+} from "~/lib/types";
 import {
   filterPatchedDependencies,
   getRootRelativeLogPath,
@@ -16,11 +22,13 @@ import {
 export async function copyPatches({
   workspaceRootDir,
   targetPackageManifest,
+  packagesRegistry,
   isolateDir,
   includeDevDependencies,
 }: {
   workspaceRootDir: string;
   targetPackageManifest: PackageManifest;
+  packagesRegistry: PackagesRegistry;
   isolateDir: string;
   includeDevDependencies: boolean;
 }): Promise<Record<string, PatchFile>> {
@@ -82,10 +90,23 @@ export async function copyPatches({
     `Found ${Object.keys(patchedDependencies).length} patched dependencies in workspace`,
   );
 
+  /**
+   * Collect the set of dependency names reachable from the target (direct deps
+   * plus deps introduced by internal workspace packages). Patches for names in
+   * this set are preserved even when the target doesn't list them directly —
+   * see issue #167.
+   */
+  const reachableDependencyNames = collectReachablePackageNames({
+    targetPackageManifest,
+    packagesRegistry,
+    includeDevDependencies,
+  });
+
   const filteredPatches = filterPatchedDependencies({
     patchedDependencies,
     targetPackageManifest,
     includeDevDependencies,
+    reachableDependencyNames,
   });
 
   if (!filteredPatches) {

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);
+}