isolate-package 1.33.0 → 1.35.0

package/src/lib/lockfile/helpers/generate-pnpm-lockfile.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { generatePnpmLockfile } from "./generate-pnpm-lockfile";
 
 /** Mock utils */
-vi.mock("~/lib/utils", () => ({
+vi.mock("#/lib/utils", () => ({
   getErrorMessage: vi.fn((err: Error) => err.message),
   isRushWorkspace: vi.fn(() => false),
 }));
@@ -57,7 +57,7 @@ const { pruneLockfile: pruneLockfile_v9 } = vi.mocked(
   await import("pnpm_prune_lockfile_v9"),
 );
 
-const { isRushWorkspace } = vi.mocked(await import("~/lib/utils"));
+const { isRushWorkspace } = vi.mocked(await import("#/lib/utils"));
 
 /** Reusable lockfile fixture */
 function createMockLockfile() {
@@ -303,6 +303,87 @@ describe("generatePnpmLockfile", () => {
     expect(writtenLockfile.packageExtensionsChecksum).toBe("abc123");
   });
 
+  it("should restore the catalogs snapshot after pruning (#198)", async () => {
+    const catalogs = {
+      default: {
+        lodash: { specifier: "^4.17.21", version: "4.17.21" },
+      },
+      utils: {
+        ramda: { specifier: "^0.30.0", version: "0.30.0" },
+      },
+    };
+    const lockfile = {
+      ...createMockLockfile(),
+      catalogs,
+    };
+    readWantedLockfile_v9.mockResolvedValue(lockfile as never);
+    getLockfileImporterId_v9.mockReturnValue("apps/my-app");
+
+    /** Simulate prune dropping the catalogs snapshot */
+    pruneLockfile_v9.mockImplementation((lf) => {
+      const result = { ...(lf as unknown as Record<string, unknown>) };
+      delete result.catalogs;
+      return result as never;
+    });
+
+    await generatePnpmLockfile({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/apps/my-app",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      internalDepPackageNames: ["shared"],
+      packagesRegistry: {
+        shared: {
+          absoluteDir: "/workspace/packages/shared",
+          rootRelativeDir: "packages/shared",
+          manifest: { name: "shared", version: "1.0.0" },
+        },
+      },
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      majorVersion: 9,
+      includeDevDependencies: false,
+    });
+
+    const writeCall = writeWantedLockfile_v9.mock.calls[0]!;
+    const writtenLockfile = writeCall[1] as {
+      catalogs?: Record<string, Record<string, unknown>>;
+    };
+
+    /**
+     * The catalogs snapshot is restored verbatim (like overrides), so it stays
+     * in sync with the importer specifiers and the verbatim pnpm-workspace.yaml
+     * copy.
+     */
+    expect(writtenLockfile.catalogs).toEqual(catalogs);
+  });
+
+  it("should not set catalogs when the source lockfile has none", async () => {
+    const lockfile = createMockLockfile();
+    readWantedLockfile_v9.mockResolvedValue(lockfile as never);
+    getLockfileImporterId_v9.mockReturnValue("apps/my-app");
+    pruneLockfile_v9.mockImplementation((lf) => lf as never);
+
+    await generatePnpmLockfile({
+      workspaceRootDir: "/workspace",
+      targetPackageDir: "/workspace/apps/my-app",
+      isolateDir: "/workspace/apps/my-app/isolate",
+      internalDepPackageNames: ["shared"],
+      packagesRegistry: {
+        shared: {
+          absoluteDir: "/workspace/packages/shared",
+          rootRelativeDir: "packages/shared",
+          manifest: { name: "shared", version: "1.0.0" },
+        },
+      },
+      targetPackageManifest: { name: "my-app", version: "1.0.0" },
+      majorVersion: 9,
+      includeDevDependencies: false,
+    });
+
+    const writeCall = writeWantedLockfile_v9.mock.calls[0]!;
+    const writtenLockfile = writeCall[1] as { catalogs?: unknown };
+    expect(writtenLockfile.catalogs).toBeUndefined();
+  });
+
   it("should include patchedDependencies in written lockfile", async () => {
     const lockfile = createMockLockfile();
     readWantedLockfile_v9.mockResolvedValue(lockfile as never);

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

@@ -13,11 +13,22 @@ import {
 import { pruneLockfile as pruneLockfile_v8 } from "pnpm_prune_lockfile_v8";
 import { pruneLockfile as pruneLockfile_v9 } from "pnpm_prune_lockfile_v9";
 import { pick } from "remeda";
-import { useLogger } from "~/lib/logger";
-import type { PackageManifest, PackagesRegistry, PatchFile } from "~/lib/types";
-import { getErrorMessage, isRushWorkspace } from "~/lib/utils";
+import { useLogger } from "#/lib/logger";
+import type { PackageManifest, PackagesRegistry, PatchFile } from "#/lib/types";
+import { getErrorMessage, isRushWorkspace } from "#/lib/utils";
 import { pnpmMapImporter } from "./pnpm-map-importer";
 
+/**
+ * A pnpm catalog snapshot as stored in the lockfile: a map of catalog name
+ * (e.g. "default") to a map of dependency name to its resolved entry. The
+ * pinned `@pnpm/lockfile-file` types predate catalogs, so we model the shape
+ * locally for the cast below.
+ */
+type CatalogSnapshots = Record<
+  string,
+  Record<string, { specifier: string; version: string }>
+>;
+
 export async function generatePnpmLockfile({
   workspaceRootDir,
   targetPackageDir,
@@ -167,6 +178,22 @@ export async function generatePnpmLockfile({
         lockfile.packageExtensionsChecksum;
     }
 
+    /**
+     * Pruning drops the catalogs snapshot, but the isolated importers keep
+     * their "catalog:" specifiers (for pnpm we don't resolve catalog deps in
+     * the manifest, since the output is itself a workspace). Restore it
+     * verbatim — like overrides above — so it stays in sync with the importer
+     * specifiers and the preserved pnpm-workspace.yaml catalog definitions,
+     * which are themselves copied verbatim (see issue #198). pnpm tolerates
+     * catalog entries that no retained importer references, so there is no need
+     * to narrow the snapshot.
+     */
+    const catalogs = (lockfile as { catalogs?: CatalogSnapshots }).catalogs;
+
+    if (catalogs) {
+      (prunedLockfile as { catalogs?: CatalogSnapshots }).catalogs = catalogs;
+    }
+
     /**
      * Use pre-computed patched dependencies with transformed paths. The paths
      * are already adapted by copyPatches to match the isolated directory
@@ -185,8 +212,8 @@ export async function generatePnpmLockfile({
     }
 
     log.debug("Created lockfile at", path.join(isolateDir, "pnpm-lock.yaml"));
-  } 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/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/adapt-target-package-manifest.ts

@@ -41,14 +41,26 @@ export async function adaptTargetPackageManifest({
     ? manifest
     : omit(manifest, ["devDependencies"]);
 
-  /** Resolve catalog dependencies before adapting internal deps */
-  const manifestWithResolvedCatalogs = {
-    ...inputManifest,
-    dependencies: await resolveCatalogDependencies(
-      inputManifest.dependencies,
-      workspaceRootDir,
-    ),
-  };
+  /**
+   * For PNPM (non-forceNpm) the isolated output is itself a pnpm workspace and
+   * the `pnpm-workspace.yaml` with its catalog definitions is preserved, so
+   * "catalog:" specifiers can be kept verbatim — just like "workspace:*". The
+   * lockfile importers also keep their "catalog:" specifiers, so resolving them
+   * here would create a mismatch and break `pnpm install --frozen-lockfile`
+   * (see issue #198). For other package managers (and forceNpm) the catalog is
+   * not available in the output, so we resolve the specifiers to versions.
+   */
+  const isPnpmWorkspaceOutput = packageManager.name === "pnpm" && !forceNpm;
+
+  const preparedManifest = isPnpmWorkspaceOutput
+    ? inputManifest
+    : {
+        ...inputManifest,
+        dependencies: await resolveCatalogDependencies(
+          inputManifest.dependencies,
+          workspaceRootDir,
+        ),
+      };
 
   const adaptedManifest =
     (packageManager.name === "pnpm" || packageManager.name === "bun") &&
@@ -59,13 +71,10 @@ export async function adaptTargetPackageManifest({
          * want to adopt workspace-level fields from the root package.json
          * (pnpm.overrides for PNPM, top-level overrides for Bun).
          */
-        await adoptPnpmFieldsFromRoot(
-          manifestWithResolvedCatalogs,
-          workspaceRootDir,
-        )
+        await adoptPnpmFieldsFromRoot(preparedManifest, workspaceRootDir)
       : /** For other package managers we replace the links to internal dependencies */
         adaptManifestInternalDeps({
-          manifest: manifestWithResolvedCatalogs,
+          manifest: preparedManifest,
           packagesRegistry,
         });
 

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,11 @@ 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 { resolveCatalogDependencies } = vi.mocked(
+  await import("./resolve-catalog-dependencies"),
+);
 
 const { writeManifest } = vi.mocked(await import("../io"));
 
@@ -178,4 +182,69 @@ describe("adaptInternalPackageManifests", () => {
 
     expect(writtenManifest.devDependencies).toBeUndefined();
   });
+
+  it("should preserve catalog: specifiers for pnpm without resolving them (#198)", async () => {
+    const manifest: PackageManifest = {
+      name: "@repo/shared",
+      version: "1.0.0",
+      dependencies: {
+        "lodash.merge": "catalog:",
+      },
+    };
+
+    const packagesRegistry = createRegistry({
+      "@repo/shared": {
+        rootRelativeDir: "packages/shared",
+        manifest,
+      },
+    });
+
+    await adaptInternalPackageManifests({
+      internalPackageNames: ["@repo/shared"],
+      packagesRegistry,
+      isolateDir: "/output",
+      forceNpm: false,
+      workspaceRootDir: "/workspace",
+    });
+
+    /**
+     * For pnpm the isolated output is itself a workspace with its catalog
+     * definitions preserved, so the specifier is kept verbatim rather than
+     * resolved (which would desync it from the lockfile importers).
+     */
+    expect(resolveCatalogDependencies).not.toHaveBeenCalled();
+
+    const writtenManifest = writeManifest.mock.calls[0]![1];
+    expect(writtenManifest.dependencies).toEqual({
+      "lodash.merge": "catalog:",
+    });
+  });
+
+  it("should resolve catalog dependencies when forceNpm is enabled", async () => {
+    const manifest: PackageManifest = {
+      name: "@repo/shared",
+      version: "1.0.0",
+      dependencies: {
+        "lodash.merge": "catalog:",
+      },
+    };
+
+    const packagesRegistry = createRegistry({
+      "@repo/shared": {
+        rootRelativeDir: "packages/shared",
+        manifest,
+      },
+    });
+
+    await adaptInternalPackageManifests({
+      internalPackageNames: ["@repo/shared"],
+      packagesRegistry,
+      isolateDir: "/output",
+      forceNpm: true,
+      workspaceRootDir: "/workspace",
+    });
+
+    /** With forceNpm the catalog is not available in the output, so resolve. */
+    expect(resolveCatalogDependencies).toHaveBeenCalledOnce();
+  });
 });

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";
@@ -27,6 +27,15 @@ export async function adaptInternalPackageManifests({
 }) {
   const packageManager = usePackageManager();
 
+  /**
+   * For PNPM (non-forceNpm) the isolated output is itself a pnpm workspace with
+   * its `pnpm-workspace.yaml` catalog definitions preserved, so "catalog:"
+   * specifiers are kept verbatim to stay in sync with the lockfile importers
+   * (see issue #198). For other package managers the catalog is not available
+   * in the output, so we resolve the specifiers to versions.
+   */
+  const isPnpmWorkspaceOutput = packageManager.name === "pnpm" && !forceNpm;
+
   await Promise.all(
     internalPackageNames.map(async (packageName) => {
       const { manifest, rootRelativeDir } = got(packagesRegistry, packageName);
@@ -45,14 +54,15 @@ export async function adaptInternalPackageManifests({
         strippedManifest.scripts = omit(strippedManifest.scripts, ["prepare"]);
       }
 
-      /** Resolve catalog dependencies before adapting internal deps */
-      const manifestWithResolvedCatalogs = {
-        ...strippedManifest,
-        dependencies: await resolveCatalogDependencies(
-          strippedManifest.dependencies,
-          workspaceRootDir,
-        ),
-      };
+      const preparedManifest = isPnpmWorkspaceOutput
+        ? strippedManifest
+        : {
+            ...strippedManifest,
+            dependencies: await resolveCatalogDependencies(
+              strippedManifest.dependencies,
+              workspaceRootDir,
+            ),
+          };
 
       const outputManifest =
         (packageManager.name === "pnpm" || packageManager.name === "bun") &&
@@ -61,10 +71,10 @@ export async function adaptInternalPackageManifests({
              * For PNPM and Bun the output itself is a workspace so we can preserve
              * the specifiers with "workspace:*" in the output manifest.
              */
-            manifestWithResolvedCatalogs
+            preparedManifest
           : /** For other package managers we replace the links to internal dependencies */
             adaptManifestInternalDeps({
-              manifest: manifestWithResolvedCatalogs,
+              manifest: preparedManifest,
               packagesRegistry,
               parentRootRelativeDir: rootRelativeDir,
             });

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) {