isolate-package 1.33.0 → 1.34.0

package/src/lib/lockfile/helpers/generate-yarn-lockfile.ts

@@ -1,8 +1,8 @@
 import fs from "fs-extra";
 import { execSync } from "node:child_process";
 import path from "node:path";
-import { useLogger } from "~/lib/logger";
-import { getErrorMessage, isRushWorkspace } from "~/lib/utils";
+import { useLogger } from "#/lib/logger";
+import { getErrorMessage, isRushWorkspace } from "#/lib/utils";
 
 /**
  * Generate an isolated / pruned lockfile, based on the existing lockfile from
@@ -43,8 +43,8 @@ export async function generateYarnLockfile({
     execSync(`yarn install --cwd ${isolateDir}`);
 
     log.debug("Generated lockfile at", newLockfilePath);
-  } catch (err) {
-    log.error(`Failed to generate lockfile: ${getErrorMessage(err)}`);
-    throw err;
+  } catch (error) {
+    log.error(`Failed to generate lockfile: ${getErrorMessage(error)}`);
+    throw error;
   }
 }

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

@@ -3,7 +3,7 @@ import { processLockfile } from "./process-lockfile";
 import type { IsolateConfigResolved } from "../config";
 
 /** Mock the package manager detection */
-vi.mock("~/lib/package-manager", () => ({
+vi.mock("#/lib/package-manager", () => ({
   usePackageManager: vi.fn(),
 }));
 
@@ -15,7 +15,7 @@ vi.mock("./helpers", () => ({
   generateYarnLockfile: vi.fn(),
 }));
 
-const { usePackageManager } = vi.mocked(await import("~/lib/package-manager"));
+const { usePackageManager } = vi.mocked(await import("#/lib/package-manager"));
 const {
   generateBunLockfile,
   generateNpmLockfile,

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

@@ -1,8 +1,8 @@
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import type { PackageManifest, PackagesRegistry } from "~/lib/types";
+import type { PackageManifest, PackagesRegistry } from "#/lib/types";
 
 /** Mock dependencies */
-vi.mock("~/lib/package-manager", () => ({
+vi.mock("#/lib/package-manager", () => ({
   usePackageManager: vi.fn(),
 }));
 
@@ -18,7 +18,7 @@ vi.mock("./resolve-catalog-dependencies", () => ({
   resolveCatalogDependencies: vi.fn((deps) => Promise.resolve(deps)),
 }));
 
-const { usePackageManager } = vi.mocked(await import("~/lib/package-manager"));
+const { usePackageManager } = vi.mocked(await import("#/lib/package-manager"));
 
 const { writeManifest } = vi.mocked(await import("../io"));
 

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

@@ -1,8 +1,8 @@
 import { got } from "get-or-throw";
 import path from "node:path";
 import { omit } from "remeda";
-import { usePackageManager } from "~/lib/package-manager";
-import type { PackagesRegistry } from "~/lib/types";
+import { usePackageManager } from "#/lib/package-manager";
+import type { PackagesRegistry } from "#/lib/types";
 import { writeManifest } from "../io";
 import { adaptManifestInternalDeps } from "./adapt-manifest-internal-deps";
 import { resolveCatalogDependencies } from "./resolve-catalog-dependencies";

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

@@ -1,4 +1,4 @@
-import type { PackageManifest, PackagesRegistry } from "~/lib/types";
+import type { PackageManifest, PackagesRegistry } from "#/lib/types";
 import { patchInternalEntries } from "./patch-internal-entries";
 
 /**

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

@@ -7,20 +7,20 @@ import type {
 import { adoptPnpmFieldsFromRoot } from "./adopt-pnpm-fields-from-root";
 
 /** Mock the dependencies */
-vi.mock("~/lib/utils", () => ({
+vi.mock("#/lib/utils", () => ({
   isRushWorkspace: vi.fn(),
   readTypedJson: vi.fn(),
 }));
 
-vi.mock("~/lib/package-manager", () => ({
+vi.mock("#/lib/package-manager", () => ({
   usePackageManager: vi.fn(() => ({ name: "pnpm", majorVersion: 9 })),
 }));
 
 const { isRushWorkspace, readTypedJson } = vi.mocked(
-  await import("~/lib/utils"),
+  await import("#/lib/utils"),
 );
 
-const { usePackageManager } = vi.mocked(await import("~/lib/package-manager"));
+const { usePackageManager } = vi.mocked(await import("#/lib/package-manager"));
 
 describe("adoptPnpmFieldsFromRoot", () => {
   beforeEach(() => {

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

@@ -1,8 +1,8 @@
 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";
+import path from "node:path";
+import { usePackageManager } from "#/lib/package-manager";
+import type { PackageManifest } from "#/lib/types";
+import { isRushWorkspace, readTypedJson } from "#/lib/utils";
 
 /**
  * Adopts workspace-level fields from the root package manifest. For pnpm this
@@ -17,9 +17,9 @@ export async function adoptPnpmFieldsFromRoot(
     return targetPackageManifest;
   }
 
-  const rootPackageManifest = await readTypedJson<ProjectManifest>(
+  const rootPackageManifest = (await readTypedJson(
     path.join(workspaceRootDir, "package.json"),
-  );
+  )) as ProjectManifest;
 
   const packageManager = usePackageManager();
 
@@ -60,7 +60,7 @@ function adoptPnpmFieldsOnly(
   rootPackageManifest: ProjectManifest,
 ): PackageManifest {
   const { overrides, onlyBuiltDependencies, ignoredBuiltDependencies } =
-    rootPackageManifest.pnpm || {};
+    rootPackageManifest.pnpm ?? {};
 
   /** If no pnpm fields are present, return the original manifest */
   if (!overrides && !onlyBuiltDependencies && !ignoredBuiltDependencies) {

package/src/lib/manifest/helpers/resolve-catalog-dependencies.test.ts

@@ -0,0 +1,410 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import yaml from "yaml";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockLogger = {
+  debug: vi.fn(),
+  warn: vi.fn(),
+};
+
+vi.mock("#/lib/logger", () => ({
+  useLogger: vi.fn(() => mockLogger),
+}));
+
+const { resolveCatalogDependencies } =
+  await import("./resolve-catalog-dependencies");
+
+/**
+ * Creates a temporary directory with optional pnpm-workspace.yaml and
+ * package.json for testing catalog resolution.
+ */
+async function createTempWorkspace({
+  workspaceYaml,
+  workspaceYamlRaw,
+  packageJson,
+}: {
+  workspaceYaml?: object;
+  workspaceYamlRaw?: string;
+  packageJson?: object;
+}): Promise<string> {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "isolate-test-"));
+
+  if (workspaceYaml !== undefined) {
+    await fs.writeFile(
+      path.join(dir, "pnpm-workspace.yaml"),
+      yaml.stringify(workspaceYaml),
+      "utf-8",
+    );
+  } else if (workspaceYamlRaw !== undefined) {
+    await fs.writeFile(
+      path.join(dir, "pnpm-workspace.yaml"),
+      workspaceYamlRaw,
+      "utf-8",
+    );
+  }
+
+  /** Always write a minimal package.json so the fallback doesn't throw. */
+  const manifest = packageJson ?? { name: "root", version: "0.0.0" };
+  await fs.writeJson(path.join(dir, "package.json"), manifest);
+
+  return dir;
+}
+
+describe("resolveCatalogDependencies", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(async () => {
+    if (tmpDir) {
+      await fs.remove(tmpDir);
+    }
+  });
+
+  describe("with no dependencies", () => {
+    it("returns undefined when dependencies is undefined", async () => {
+      tmpDir = await createTempWorkspace({});
+      const result = await resolveCatalogDependencies(undefined, tmpDir);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("pnpm-workspace.yaml: default catalog (catalog:)", () => {
+    it("resolves catalog: specifiers from pnpm-workspace.yaml", async () => {
+      tmpDir = await createTempWorkspace({
+        workspaceYaml: {
+          packages: ["packages/*"],
+          catalog: {
+            react: "^18.3.1",
+            typescript: "^5.0.0",
+          },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { react: "catalog:", typescript: "catalog:", lodash: "^4.0.0" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({
+        react: "^18.3.1",
+        typescript: "^5.0.0",
+        lodash: "^4.0.0",
+      });
+    });
+
+    it("also handles catalog:default as the default catalog name", async () => {
+      tmpDir = await createTempWorkspace({
+        workspaceYaml: {
+          packages: ["packages/*"],
+          catalogs: {
+            default: {
+              react: "^18.3.1",
+            },
+          },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { react: "catalog:default" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({ react: "^18.3.1" });
+    });
+
+    it("resolves catalog:default from the top-level catalog field", async () => {
+      tmpDir = await createTempWorkspace({
+        workspaceYaml: {
+          packages: ["packages/*"],
+          catalog: {
+            react: "^18.3.1",
+          },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { react: "catalog:default" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({ react: "^18.3.1" });
+    });
+  });
+
+  describe("pnpm-workspace.yaml: named catalogs (catalog:<name>)", () => {
+    it("resolves named catalog specifiers from pnpm-workspace.yaml", async () => {
+      tmpDir = await createTempWorkspace({
+        workspaceYaml: {
+          packages: ["packages/*"],
+          catalogs: {
+            react18: {
+              react: "^18.3.1",
+              "react-dom": "^18.3.1",
+            },
+            react19: {
+              react: "^19.0.0",
+            },
+          },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        {
+          react: "catalog:react18",
+          "react-dom": "catalog:react18",
+        },
+        tmpDir,
+      );
+
+      expect(result).toEqual({
+        react: "^18.3.1",
+        "react-dom": "^18.3.1",
+      });
+    });
+  });
+
+  describe("pnpm-workspace.yaml: missing package in catalog", () => {
+    it("keeps original specifier and warns when package not found in catalog", async () => {
+      tmpDir = await createTempWorkspace({
+        workspaceYaml: {
+          packages: ["packages/*"],
+          catalog: { react: "^18.0.0" },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { react: "catalog:", "missing-pkg": "catalog:" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({
+        react: "^18.0.0",
+        "missing-pkg": "catalog:", // kept as-is with a warning
+      });
+    });
+  });
+
+  describe("package.json fallback (Bun format)", () => {
+    it("resolves catalog: from root-level catalog field in package.json", async () => {
+      tmpDir = await createTempWorkspace({
+        packageJson: {
+          name: "root",
+          version: "0.0.0",
+          catalog: {
+            react: "^18.3.1",
+          },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { react: "catalog:" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({ react: "^18.3.1" });
+    });
+
+    it("resolves catalog: from workspaces.catalog in package.json", async () => {
+      tmpDir = await createTempWorkspace({
+        packageJson: {
+          name: "root",
+          version: "0.0.0",
+          workspaces: {
+            packages: ["packages/*"],
+            catalog: {
+              typescript: "^5.4.0",
+            },
+          },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { typescript: "catalog:" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({ typescript: "^5.4.0" });
+    });
+
+    it("resolves named catalog: from root-level catalogs field in package.json", async () => {
+      tmpDir = await createTempWorkspace({
+        packageJson: {
+          name: "root",
+          version: "0.0.0",
+          catalogs: {
+            react18: {
+              react: "^18.3.1",
+              "react-dom": "^18.3.1",
+            },
+          },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        {
+          react: "catalog:react18",
+          "react-dom": "catalog:react18",
+        },
+        tmpDir,
+      );
+
+      expect(result).toEqual({
+        react: "^18.3.1",
+        "react-dom": "^18.3.1",
+      });
+    });
+
+    it("resolves named catalog: from workspaces.catalogs in package.json", async () => {
+      tmpDir = await createTempWorkspace({
+        packageJson: {
+          name: "root",
+          version: "0.0.0",
+          workspaces: {
+            packages: ["packages/*"],
+            catalogs: {
+              tools: {
+                typescript: "^5.4.0",
+                eslint: "^8.0.0",
+              },
+            },
+          },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { typescript: "catalog:tools", eslint: "catalog:tools" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({
+        typescript: "^5.4.0",
+        eslint: "^8.0.0",
+      });
+    });
+  });
+
+  describe("precedence", () => {
+    it("prefers pnpm-workspace.yaml over package.json when both define the same catalog dependency", async () => {
+      tmpDir = await createTempWorkspace({
+        workspaceYaml: {
+          packages: ["packages/*"],
+          catalog: {
+            react: "^18.3.1",
+          },
+        },
+        packageJson: {
+          name: "root",
+          version: "0.0.0",
+          catalog: {
+            react: "^18.2.0",
+          },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { react: "catalog:" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({ react: "^18.3.1" });
+    });
+  });
+
+  describe("pnpm-workspace.yaml with invalid YAML", () => {
+    it("warns about invalid YAML and falls back to package.json", async () => {
+      tmpDir = await createTempWorkspace({
+        workspaceYamlRaw: "catalog:\n  react: ^18.3.1\n  - invalid format",
+        packageJson: {
+          name: "root",
+          version: "0.0.0",
+          catalog: { react: "^18.0.0" },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { react: "catalog:" },
+        tmpDir,
+      );
+
+      /** Verify it fell back to package.json correctly. */
+      expect(result).toEqual({ react: "^18.0.0" });
+
+      /** Verify a warning was logged. */
+      expect(mockLogger.warn).toHaveBeenCalledWith(
+        expect.stringContaining(
+          `Failed to parse ${path.join(tmpDir, "pnpm-workspace.yaml")}:`,
+        ),
+      );
+    });
+  });
+
+  describe("pnpm-workspace.yaml without catalog fields", () => {
+    it("falls back to package.json when pnpm-workspace.yaml has no catalog", async () => {
+      tmpDir = await createTempWorkspace({
+        workspaceYaml: {
+          /** No catalog or catalogs field - just packages. */
+          packages: ["packages/*"],
+        },
+        packageJson: {
+          name: "root",
+          version: "0.0.0",
+          catalog: { react: "^18.0.0" },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        { react: "catalog:" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({ react: "^18.0.0" });
+    });
+  });
+
+  describe("no catalog defined anywhere", () => {
+    it("returns dependencies as-is when no catalog is found", async () => {
+      tmpDir = await createTempWorkspace({});
+
+      const result = await resolveCatalogDependencies(
+        { react: "^18.0.0", typescript: "^5.0.0" },
+        tmpDir,
+      );
+
+      expect(result).toEqual({
+        react: "^18.0.0",
+        typescript: "^5.0.0",
+      });
+    });
+  });
+
+  describe("non-catalog specifiers", () => {
+    it("leaves non-catalog specifiers unchanged", async () => {
+      tmpDir = await createTempWorkspace({
+        workspaceYaml: {
+          packages: ["packages/*"],
+          catalog: { react: "^18.0.0" },
+        },
+      });
+
+      const result = await resolveCatalogDependencies(
+        {
+          react: "catalog:",
+          lodash: "^4.0.0",
+          typescript: "workspace:*",
+        },
+        tmpDir,
+      );
+
+      expect(result).toEqual({
+        react: "^18.0.0",
+        lodash: "^4.0.0",
+        typescript: "workspace:*",
+      });
+    });
+  });
+});