isolate-package 1.29.0 → 1.30.0

package/src/lib/lockfile/process-lockfile.test.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { processLockfile } from "./process-lockfile";
+import type { IsolateConfigResolved } from "../config";
+
+/** Mock the package manager detection */
+vi.mock("~/lib/package-manager", () => ({
+  usePackageManager: vi.fn(),
+}));
+
+/** Mock all lockfile generators */
+vi.mock("./helpers", () => ({
+  generateBunLockfile: vi.fn(),
+  generateNpmLockfile: vi.fn(),
+  generatePnpmLockfile: vi.fn(),
+  generateYarnLockfile: vi.fn(),
+}));
+
+const { usePackageManager } = vi.mocked(await import("~/lib/package-manager"));
+const {
+  generateBunLockfile,
+  generateNpmLockfile,
+  generatePnpmLockfile,
+  generateYarnLockfile,
+} = vi.mocked(await import("./helpers"));
+
+/** Minimal config for testing */
+function createConfig(
+  overrides?: Partial<IsolateConfigResolved>,
+): IsolateConfigResolved {
+  return {
+    buildDirName: "dist",
+    forceNpm: false,
+    includeDevDependencies: false,
+    isolateDirName: "isolate",
+    logLevel: "info",
+    omitPackageManager: false,
+    tsconfigPath: undefined,
+    workspacePackages: undefined,
+    workspaceRoot: undefined,
+    ...overrides,
+  } as IsolateConfigResolved;
+}
+
+describe("processLockfile", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should route to npm generator for npm package manager", async () => {
+    usePackageManager.mockReturnValue({
+      name: "npm",
+      majorVersion: 10,
+      version: "10.0.0",
+      packageManagerString: "npm@10.0.0",
+    });
+
+    const result = await processLockfile({
+      workspaceRootDir: "/workspace",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      packagesRegistry: {},
+      internalDepPackageNames: [],
+      targetPackageDir: "/workspace/apps/my-app",
+      targetPackageName: "my-app",
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      config: createConfig(),
+    });
+
+    expect(generateNpmLockfile).toHaveBeenCalledWith({
+      workspaceRootDir: "/workspace",
+      isolateDir: "/workspace/apps/my-app/isolate",
+    });
+    expect(result).toBe(false);
+  });
+
+  it("should route to pnpm generator for pnpm package manager", async () => {
+    usePackageManager.mockReturnValue({
+      name: "pnpm",
+      majorVersion: 9,
+      version: "9.0.0",
+      packageManagerString: "pnpm@9.0.0",
+    });
+
+    const config = createConfig({ includeDevDependencies: true });
+
+    await processLockfile({
+      workspaceRootDir: "/workspace",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      packagesRegistry: { shared: {} as never },
+      internalDepPackageNames: ["shared"],
+      targetPackageDir: "/workspace/apps/my-app",
+      targetPackageName: "my-app",
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      config,
+    });
+
+    expect(generatePnpmLockfile).toHaveBeenCalledWith({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/apps/my-app",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      internalDepPackageNames: ["shared"],
+      packagesRegistry: { shared: {} as never },
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      majorVersion: 9,
+      includeDevDependencies: true,
+      patchedDependencies: undefined,
+    });
+  });
+
+  it("should route to yarn generator for yarn v1", async () => {
+    usePackageManager.mockReturnValue({
+      name: "yarn",
+      majorVersion: 1,
+      version: "1.22.0",
+      packageManagerString: "yarn@1.22.0",
+    });
+
+    const result = await processLockfile({
+      workspaceRootDir: "/workspace",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      packagesRegistry: {},
+      internalDepPackageNames: [],
+      targetPackageDir: "/workspace/apps/my-app",
+      targetPackageName: "my-app",
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      config: createConfig(),
+    });
+
+    expect(generateYarnLockfile).toHaveBeenCalledWith({
+      workspaceRootDir: "/workspace",
+      isolateDir: "/workspace/apps/my-app/isolate",
+    });
+    expect(result).toBe(false);
+  });
+
+  it("should fall back to npm for modern yarn (v2+)", async () => {
+    usePackageManager.mockReturnValue({
+      name: "yarn",
+      majorVersion: 4,
+      version: "4.0.0",
+      packageManagerString: "yarn@4.0.0",
+    });
+
+    const result = await processLockfile({
+      workspaceRootDir: "/workspace",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      packagesRegistry: {},
+      internalDepPackageNames: [],
+      targetPackageDir: "/workspace/apps/my-app",
+      targetPackageName: "my-app",
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      config: createConfig(),
+    });
+
+    expect(generateNpmLockfile).toHaveBeenCalled();
+    expect(result).toBe(true);
+  });
+
+  it("should route to bun generator for bun package manager", async () => {
+    usePackageManager.mockReturnValue({
+      name: "bun",
+      majorVersion: 1,
+      version: "1.2.0",
+      packageManagerString: "bun@1.2.0",
+    });
+
+    const result = await processLockfile({
+      workspaceRootDir: "/workspace",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      packagesRegistry: {},
+      internalDepPackageNames: ["shared"],
+      targetPackageDir: "/workspace/apps/my-app",
+      targetPackageName: "my-app",
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      config: createConfig(),
+    });
+
+    expect(generateBunLockfile).toHaveBeenCalledWith({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/apps/my-app",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      internalDepPackageNames: ["shared"],
+      packagesRegistry: {},
+      includeDevDependencies: false,
+    });
+    expect(result).toBe(false);
+  });
+
+  it("should use npm when forceNpm is true regardless of package manager", async () => {
+    usePackageManager.mockReturnValue({
+      name: "pnpm",
+      majorVersion: 9,
+      version: "9.0.0",
+      packageManagerString: "pnpm@9.0.0",
+    });
+
+    const result = await processLockfile({
+      workspaceRootDir: "/workspace",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      packagesRegistry: {},
+      internalDepPackageNames: [],
+      targetPackageDir: "/workspace/apps/my-app",
+      targetPackageName: "my-app",
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      config: createConfig({ forceNpm: true }),
+    });
+
+    expect(generateNpmLockfile).toHaveBeenCalled();
+    expect(generatePnpmLockfile).not.toHaveBeenCalled();
+    expect(result).toBe(true);
+  });
+
+  it("should fall back to npm for unknown package manager", async () => {
+    usePackageManager.mockReturnValue({
+      name: "unknown" as never,
+      majorVersion: 1,
+      version: "1.0.0",
+      packageManagerString: "unknown@1.0.0",
+    });
+
+    const result = await processLockfile({
+      workspaceRootDir: "/workspace",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      packagesRegistry: {},
+      internalDepPackageNames: [],
+      targetPackageDir: "/workspace/apps/my-app",
+      targetPackageName: "my-app",
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      config: createConfig(),
+    });
+
+    expect(generateNpmLockfile).toHaveBeenCalled();
+    expect(result).toBe(true);
+  });
+});

package/src/lib/lockfile/process-lockfile.ts

@@ -3,6 +3,7 @@ import { useLogger } from "../logger";
 import { usePackageManager } from "../package-manager";
 import type { PackageManifest, PackagesRegistry, PatchFile } from "../types";
 import {
+  generateBunLockfile,
   generateNpmLockfile,
   generatePnpmLockfile,
   generateYarnLockfile,
@@ -97,15 +98,14 @@ export async function processLockfile({
       break;
     }
     case "bun": {
-      log.warn(
-        `Ouput lockfiles for Bun are not yet supported. Using NPM for output`,
-      );
-      await generateNpmLockfile({
+      await generateBunLockfile({
         workspaceRootDir,
+        targetPackageDir,
         isolateDir,
+        internalDepPackageNames,
+        packagesRegistry,
+        includeDevDependencies: config.includeDevDependencies,
       });
-
-      usedFallbackToNpm = true;
       break;
     }
     default:

package/src/lib/manifest/adapt-target-package-manifest.ts

@@ -51,11 +51,13 @@ export async function adaptTargetPackageManifest({
   };
 
   const adaptedManifest =
-    packageManager.name === "pnpm" && !forceNpm
+    (packageManager.name === "pnpm" || packageManager.name === "bun") &&
+    !forceNpm
       ? /**
-         * 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
-         * pnpm.overrides field from the root package.json.
+         * For PNPM and Bun the output itself is a workspace so we can preserve
+         * the specifiers with "workspace:*" in the output manifest, but we do
+         * want to adopt workspace-level fields from the root package.json
+         * (pnpm.overrides for PNPM, top-level overrides for Bun).
          */
         await adoptPnpmFieldsFromRoot(
           manifestWithResolvedCatalogs,

package/src/lib/manifest/helpers/adapt-internal-package-manifests.test.ts

@@ -95,6 +95,55 @@ describe("adaptInternalPackageManifests", () => {
     });
   });
 
+  it("should strip the prepare script from internal dependency manifests", async () => {
+    const manifest: PackageManifest = {
+      name: "@repo/common",
+      version: "1.0.0",
+      scripts: {
+        prepare: "npm run clean && npm run build",
+        clean: "del-cli dist",
+        build: "tsdown",
+        postinstall: "prisma generate",
+      },
+      dependencies: {
+        ky: "^1.0.0",
+      },
+      devDependencies: {
+        "del-cli": "^7.0.0",
+        tsdown: "^0.20.0",
+      },
+    };
+
+    const packagesRegistry = createRegistry({
+      "@repo/common": {
+        rootRelativeDir: "packages/common",
+        manifest,
+      },
+    });
+
+    await adaptInternalPackageManifests({
+      internalPackageNames: ["@repo/common"],
+      packagesRegistry,
+      isolateDir: "/output",
+      forceNpm: false,
+      workspaceRootDir: "/workspace",
+    });
+
+    expect(writeManifest).toHaveBeenCalledOnce();
+
+    const writtenManifest = writeManifest.mock.calls[0]![1];
+
+    /** prepare should be stripped because it depends on devDependency binaries */
+    expect(writtenManifest.scripts?.prepare).toBeUndefined();
+
+    /** Other scripts should be preserved */
+    expect(writtenManifest.scripts).toEqual({
+      clean: "del-cli dist",
+      build: "tsdown",
+      postinstall: "prisma generate",
+    });
+  });
+
   it("should strip devDependencies from internal dependency manifests", async () => {
     const manifest: PackageManifest = {
       name: "@repo/shared",

package/src/lib/manifest/helpers/adapt-internal-package-manifests.ts

@@ -34,6 +34,17 @@ export async function adaptInternalPackageManifests({
       /** Dev dependencies are never included for internal deps */
       const strippedManifest = omit(manifest, ["devDependencies"]);
 
+      /**
+       * Strip the `prepare` script because it runs during `pnpm install` and
+       * typically depends on devDependency binaries (e.g. tsdown, del-cli)
+       * which are not available in the isolated output. Other lifecycle
+       * scripts like `postinstall` are preserved because they handle runtime
+       * setup (e.g. Prisma client generation).
+       */
+      if (strippedManifest.scripts) {
+        strippedManifest.scripts = omit(strippedManifest.scripts, ["prepare"]);
+      }
+
       /** Resolve catalog dependencies before adapting internal deps */
       const manifestWithResolvedCatalogs = {
         ...strippedManifest,
@@ -44,10 +55,11 @@ export async function adaptInternalPackageManifests({
       };
 
       const outputManifest =
-        packageManager.name === "pnpm" && !forceNpm
+        (packageManager.name === "pnpm" || packageManager.name === "bun") &&
+        !forceNpm
           ? /**
-             * For PNPM the output itself is a workspace so we can preserve the specifiers
-             * with "workspace:*" in the output manifest.
+             * For PNPM and Bun the output itself is a workspace so we can preserve
+             * the specifiers with "workspace:*" in the output manifest.
              */
             manifestWithResolvedCatalogs
           : /** For other package managers we replace the links to internal dependencies */

package/src/lib/manifest/helpers/adopt-pnpm-fields-from-root.test.ts

@@ -12,10 +12,16 @@ vi.mock("~/lib/utils", () => ({
   readTypedJson: vi.fn(),
 }));
 
+vi.mock("~/lib/package-manager", () => ({
+  usePackageManager: vi.fn(() => ({ name: "pnpm", majorVersion: 9 })),
+}));
+
 const { isRushWorkspace, readTypedJson } = vi.mocked(
   await import("~/lib/utils"),
 );
 
+const { usePackageManager } = vi.mocked(await import("~/lib/package-manager"));
+
 describe("adoptPnpmFieldsFromRoot", () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -209,4 +215,59 @@ describe("adoptPnpmFieldsFromRoot", () => {
       },
     });
   });
+
+  it("should adopt top-level overrides for Bun", async () => {
+    usePackageManager.mockReturnValue({
+      name: "bun",
+      majorVersion: 1,
+      version: "1.0.0",
+      packageManagerString: "bun@1.0.0",
+    } as ReturnType<typeof usePackageManager>);
+    isRushWorkspace.mockReturnValue(false);
+    readTypedJson.mockResolvedValue({
+      name: "root",
+      version: "1.0.0",
+      overrides: {
+        foo: "^1.0.0",
+      },
+    } as unknown as ProjectManifest);
+
+    const targetManifest: PackageManifest = {
+      name: "test-package",
+      version: "1.0.0",
+    };
+
+    const result = await adoptPnpmFieldsFromRoot(targetManifest, "/workspace");
+
+    expect(result).toEqual({
+      name: "test-package",
+      version: "1.0.0",
+      overrides: {
+        foo: "^1.0.0",
+      },
+    });
+  });
+
+  it("should return original manifest for Bun when no overrides are present", async () => {
+    usePackageManager.mockReturnValue({
+      name: "bun",
+      majorVersion: 1,
+      version: "1.0.0",
+      packageManagerString: "bun@1.0.0",
+    } as ReturnType<typeof usePackageManager>);
+    isRushWorkspace.mockReturnValue(false);
+    readTypedJson.mockResolvedValue({
+      name: "root",
+      version: "1.0.0",
+    } as ProjectManifest);
+
+    const targetManifest: PackageManifest = {
+      name: "test-package",
+      version: "1.0.0",
+    };
+
+    const result = await adoptPnpmFieldsFromRoot(targetManifest, "/workspace");
+
+    expect(result).toEqual(targetManifest);
+  });
 });

package/src/lib/manifest/helpers/adopt-pnpm-fields-from-root.ts

@@ -1,12 +1,13 @@
 import type { ProjectManifest, PnpmSettings } from "@pnpm/types";
 import path from "path";
+import { usePackageManager } from "~/lib/package-manager";
 import type { PackageManifest } from "~/lib/types";
 import { isRushWorkspace, readTypedJson } from "~/lib/utils";
 
 /**
- * Adopts the `pnpm` fields from the root package manifest. Currently it takes
- * overrides, onlyBuiltDependencies, and ignoredBuiltDependencies, because these
- * are typically workspace-level configuration settings.
+ * Adopts workspace-level fields from the root package manifest. For pnpm this
+ * reads overrides, onlyBuiltDependencies, and ignoredBuiltDependencies from the
+ * `pnpm` key. For Bun it reads `overrides` from the top level.
  */
 export async function adoptPnpmFieldsFromRoot(
   targetPackageManifest: PackageManifest,
@@ -20,6 +21,44 @@ export async function adoptPnpmFieldsFromRoot(
     path.join(workspaceRootDir, "package.json"),
   );
 
+  const packageManager = usePackageManager();
+
+  if (packageManager.name === "bun") {
+    return adoptBunFieldsFromRoot(targetPackageManifest, rootPackageManifest);
+  }
+
+  return adoptPnpmFieldsOnly(targetPackageManifest, rootPackageManifest);
+}
+
+/** Adopt Bun's top-level overrides from the root manifest */
+function adoptBunFieldsFromRoot(
+  targetPackageManifest: PackageManifest,
+  rootPackageManifest: ProjectManifest,
+): PackageManifest {
+  /**
+   * Bun supports `overrides` at the top level of package.json (same as npm).
+   * Read from the root manifest and set them on the output manifest so that
+   * `bun install --frozen-lockfile` succeeds.
+   */
+  const overrides = (rootPackageManifest as Record<string, unknown>)[
+    "overrides"
+  ] as Record<string, string> | undefined;
+
+  if (!overrides) {
+    return targetPackageManifest;
+  }
+
+  return {
+    ...targetPackageManifest,
+    overrides,
+  } as PackageManifest;
+}
+
+/** Adopt pnpm-specific fields from the root manifest */
+function adoptPnpmFieldsOnly(
+  targetPackageManifest: PackageManifest,
+  rootPackageManifest: ProjectManifest,
+): PackageManifest {
   const { overrides, onlyBuiltDependencies, ignoredBuiltDependencies } =
     rootPackageManifest.pnpm || {};
 

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

@@ -23,7 +23,7 @@ vi.mock("~/lib/utils", () => ({
 
 /** Mock the package manager */
 vi.mock("~/lib/package-manager", () => ({
-  usePackageManager: vi.fn(() => ({ majorVersion: 9 })),
+  usePackageManager: vi.fn(() => ({ name: "pnpm", majorVersion: 9 })),
 }));
 
 /** Mock the pnpm lockfile readers */
@@ -35,19 +35,10 @@ vi.mock("pnpm_lockfile_file_v9", () => ({
   readWantedLockfile: vi.fn(() => Promise.resolve(null)),
 }));
 
-/** Mock the logger */
-vi.mock("~/lib/logger", () => ({
-  useLogger: () => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  }),
-}));
-
 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"));
 
 describe("copyPatches", () => {
   beforeEach(() => {
@@ -420,4 +411,51 @@ describe("copyPatches", () => {
       expect(fs.copy).toHaveBeenCalledTimes(2);
     });
   });
+
+  it("should read top-level patchedDependencies for Bun projects", async () => {
+    usePackageManager.mockReturnValue({
+      name: "bun",
+      majorVersion: 1,
+      version: "1.2.0",
+      packageManagerString: "bun@1.2.0",
+    });
+
+    const targetManifest: PackageManifest = {
+      name: "test",
+      version: "1.0.0",
+      dependencies: { lodash: "^4.0.0" },
+    };
+
+    /** No patches in pnpm-workspace.yaml, so it falls back to package.json */
+    readTypedYamlSync.mockReturnValue({});
+
+    readTypedJson.mockResolvedValue({
+      name: "root",
+      version: "1.0.0",
+      patchedDependencies: {
+        "lodash@4.17.21": "patches/lodash.patch",
+      },
+    } as PackageManifest);
+
+    filterPatchedDependencies.mockReturnValue({
+      "lodash@4.17.21": "patches/lodash.patch",
+    });
+
+    fs.existsSync.mockReturnValue(true);
+
+    const result = await copyPatches({
+      workspaceRootDir: "/workspace",
+      targetPackageManifest: targetManifest,
+      isolateDir: "/workspace/isolate",
+      includeDevDependencies: false,
+    });
+
+    expect(result).toEqual({
+      "lodash@4.17.21": { path: "patches/lodash.patch", hash: "" },
+    });
+    expect(fs.copy).toHaveBeenCalledWith(
+      "/workspace/patches/lodash.patch",
+      "/workspace/isolate/patches/lodash.patch",
+    );
+  });
 });

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

@@ -26,30 +26,46 @@ export async function copyPatches({
 }): Promise<Record<string, PatchFile>> {
   const log = useLogger();
 
+  const { name: packageManagerName } = usePackageManager();
+
   let patchedDependencies: Record<string, string> | undefined;
 
-  // First try reading the pnpm-workspace.yaml file
-  try {
-    const pnpmSettings = readTypedYamlSync<PnpmSettings>(
-      path.join(workspaceRootDir, "pnpm-workspace.yaml"),
-    );
-    patchedDependencies = pnpmSettings?.patchedDependencies;
-  } catch (error) {
-    log.warn(
-      `Could not read pnpm-workspace.yaml: ${error instanceof Error ? error.message : String(error)}`,
-    );
+  /**
+   * Only try reading pnpm-workspace.yaml for pnpm workspaces. Bun workspaces
+   * don't have this file and the warning would be noisy.
+   */
+  if (packageManagerName === "pnpm") {
+    try {
+      const pnpmSettings = readTypedYamlSync<PnpmSettings>(
+        path.join(workspaceRootDir, "pnpm-workspace.yaml"),
+      );
+      patchedDependencies = pnpmSettings?.patchedDependencies;
+    } catch (error) {
+      log.warn(
+        `Could not read pnpm-workspace.yaml: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
   }
 
   if (!patchedDependencies || Object.keys(patchedDependencies).length === 0) {
-    log.debug(
-      "No patched dependencies found in pnpm-workspace.yaml; Falling back to workspace root package.json",
-    );
+    if (packageManagerName === "pnpm") {
+      log.debug(
+        "No patched dependencies found in pnpm-workspace.yaml; Falling back to workspace root package.json",
+      );
+    } else {
+      log.debug(
+        "Reading patched dependencies from workspace root package.json",
+      );
+    }
 
     try {
       const workspaceRootManifest = await readTypedJson<PackageManifest>(
         path.join(workspaceRootDir, "package.json"),
       );
-      patchedDependencies = workspaceRootManifest?.pnpm?.patchedDependencies;
+      /** PNPM stores patches under pnpm.patchedDependencies, Bun at the top level */
+      patchedDependencies =
+        workspaceRootManifest?.pnpm?.patchedDependencies ??
+        workspaceRootManifest?.patchedDependencies;
     } catch (error) {
       log.warn(
         `Could not read workspace root package.json: ${error instanceof Error ? error.message : String(error)}`,
@@ -76,9 +92,14 @@ export async function copyPatches({
     return {};
   }
 
-  /** Read the lockfile to get the hashes for each patch */
+  /**
+   * Read the pnpm lockfile to get patch hashes. Bun doesn't store hashes in
+   * its lockfile so we skip this for Bun.
+   */
   const lockfilePatchedDependencies =
-    await readLockfilePatchedDependencies(workspaceRootDir);
+    packageManagerName === "pnpm"
+      ? await readLockfilePatchedDependencies(workspaceRootDir)
+      : undefined;
 
   const copiedPatches: Record<string, PatchFile> = {};
 
@@ -102,7 +123,7 @@ export async function copyPatches({
     const originalPatchFile = lockfilePatchedDependencies?.[packageSpec];
     const hash = originalPatchFile?.hash ?? "";
 
-    if (!hash) {
+    if (packageManagerName === "pnpm" && !hash) {
       log.warn(`No hash found for patch ${packageSpec} in lockfile`);
     }