isolate-package 1.28.2 → 1.29.0-1

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,12 @@ 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 the pnpm.overrides field from the root package.json.
          */
         await adoptPnpmFieldsFromRoot(
           manifestWithResolvedCatalogs,

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

@@ -44,10 +44,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/validate-manifest.test.ts

@@ -43,7 +43,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidDevManifest, packagePath, false),
-    ).toThrow(/missing the "version" field/);
+    ).toThrow(/missing mandatory fields: version/);
   });
 
   it("should throw error when version field is missing", () => {
@@ -54,7 +54,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing the "version" field/);
+    ).toThrow(/missing mandatory fields: version/);
   });
 
   it("should throw error when files field is missing", () => {
@@ -65,7 +65,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing the "files" field/);
+    ).toThrow(/missing mandatory fields: files/);
   });
 
   it("should throw error when files field is empty array", () => {
@@ -77,7 +77,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing the "files" field/);
+    ).toThrow(/missing mandatory fields: files/);
   });
 
   it("should throw error when files field is not an array", () => {
@@ -89,7 +89,7 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing the "files" field/);
+    ).toThrow(/missing mandatory fields: files/);
   });
 
   it("should throw error when both fields are missing", () => {
@@ -99,29 +99,20 @@ describe("validateManifestMandatoryFields", () => {
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(/missing mandatory fields in its package\.json: version, files/);
+    ).toThrow(/missing mandatory fields: version, files/);
   });
 
-  it("should include documentation URL in error message", () => {
+  it("should include helpful error message", () => {
     const invalidManifest = {
       name: "test-package",
     } as PackageManifest;
 
     expect(() =>
       validateManifestMandatoryFields(invalidManifest, packagePath),
-    ).toThrow(
-      /See https:\/\/isolate-package\.codecompose\.dev\/getting-started#prerequisites/,
-    );
-
-    const singleFieldManifest = {
-      name: "test-package",
-      version: "1.0.0",
-    } as PackageManifest;
+    ).toThrow(/missing mandatory fields: version, files/);
 
     expect(() =>
-      validateManifestMandatoryFields(singleFieldManifest, packagePath),
-    ).toThrow(
-      /See https:\/\/isolate-package\.codecompose\.dev\/getting-started#define-files-field-in-each-package-manifest/,
-    );
+      validateManifestMandatoryFields(invalidManifest, packagePath),
+    ).toThrow(/See the documentation for more details/);
   });
 });

package/src/lib/manifest/validate-manifest.ts

@@ -1,14 +1,6 @@
 import { useLogger } from "../logger";
 import type { PackageManifest } from "../types";
 
-/** Maps field names to their documentation URLs */
-const fieldDocUrls: Record<string, string> = {
-  version:
-    "https://isolate-package.codecompose.dev/getting-started#define-version-field-in-each-package-manifest",
-  files:
-    "https://isolate-package.codecompose.dev/getting-started#define-files-field-in-each-package-manifest",
-};
-
 /**
  * Validate that mandatory fields are present in the package manifest. These
  * fields are required for the isolate process to work properly.
@@ -46,11 +38,7 @@ export function validateManifestMandatoryFields(
   }
 
   if (missingFields.length > 0) {
-    const field = missingFields[0]!;
-    const errorMessage =
-      missingFields.length === 1
-        ? `Package at ${packagePath} is missing the "${field}" field in its package.json. See ${fieldDocUrls[field] ?? "https://isolate-package.codecompose.dev/getting-started#prerequisites"}`
-        : `Package at ${packagePath} is missing mandatory fields in its package.json: ${missingFields.join(", ")}. See https://isolate-package.codecompose.dev/getting-started#prerequisites`;
+    const errorMessage = `Package at ${packagePath} is missing mandatory fields: ${missingFields.join(", ")}. See the documentation for more details.`;
 
     log.error(errorMessage);
     throw new Error(errorMessage);

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

@@ -22,7 +22,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 */
@@ -34,20 +34,11 @@ 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 } = vi.mocked(
   await import("~/lib/utils"),
 );
+const { usePackageManager } = vi.mocked(await import("~/lib/package-manager"));
 
 describe("copyPatches", () => {
   beforeEach(() => {
@@ -395,4 +386,48 @@ 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" },
+    };
+
+    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

@@ -37,7 +37,10 @@ export async function copyPatches({
     return {};
   }
 
-  const patchedDependencies = workspaceRootManifest.pnpm?.patchedDependencies;
+  /** PNPM stores patches under pnpm.patchedDependencies, Bun at the top level */
+  const patchedDependencies =
+    workspaceRootManifest.pnpm?.patchedDependencies ??
+    workspaceRootManifest.patchedDependencies;
 
   if (!patchedDependencies || Object.keys(patchedDependencies).length === 0) {
     log.debug("No patched dependencies found in workspace root package.json");
@@ -58,9 +61,15 @@ 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 { name: packageManagerName } = usePackageManager();
   const lockfilePatchedDependencies =
-    await readLockfilePatchedDependencies(workspaceRootDir);
+    packageManagerName === "pnpm"
+      ? await readLockfilePatchedDependencies(workspaceRootDir)
+      : undefined;
 
   const copiedPatches: Record<string, PatchFile> = {};
 
@@ -84,7 +93,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`);
     }
 

package/src/lib/types.ts

@@ -11,6 +11,9 @@ export interface PatchFile {
 
 export type PackageManifest = PnpmPackageManifest & {
   packageManager?: string;
+  workspaces?: string[];
+  /** Bun stores patchedDependencies at the top level */
+  patchedDependencies?: Record<string, string>;
   pnpm?: {
     patchedDependencies?: Record<string, string>;
     [key: string]: unknown;

package/src/lib/utils/filter-patched-dependencies.test.ts

@@ -1,17 +1,7 @@
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it } from "vitest";
 import type { PackageManifest } from "~/lib/types";
 import { filterPatchedDependencies } from "./filter-patched-dependencies";
 
-/** Mock the logger */
-vi.mock("~/lib/logger", () => ({
-  useLogger: () => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  }),
-}));
-
 describe("filterPatchedDependencies", () => {
   it("should return undefined when patchedDependencies is undefined", () => {
     const manifest: PackageManifest = { name: "test", version: "1.0.0" };

package/src/testing/setup.ts

@@ -0,0 +1,13 @@
+import { vi } from "vitest";
+
+/** Mock the logger for all tests to prevent console output during tests */
+vi.mock("~/lib/logger", () => ({
+  useLogger: () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  }),
+  setLogLevel: vi.fn(),
+  setLogger: vi.fn(),
+}));