isolate-package 1.33.0 → 1.35.0

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:*",
+      });
+    });
+  });
+});

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

@@ -1,16 +1,112 @@
+import fs from "fs-extra";
 import path from "node:path";
-import { useLogger } from "~/lib/logger";
-import type { PackageManifest } from "~/lib/types";
-import { readTypedJson } from "~/lib/utils";
+import { useLogger } from "#/lib/logger";
+import type { PackageManifest } from "#/lib/types";
+import { readTypedJson } from "#/lib/utils";
+import yaml from "yaml";
+
+type CatalogMap = Record<string, string>;
+type CatalogsMap = Record<string, CatalogMap>;
+
+type CatalogSource = {
+  catalog?: CatalogMap;
+  catalogs?: CatalogsMap;
+};
+
+const catalogSourceCache = new Map<string, Promise<CatalogSource>>();
+
+/**
+ * Loads catalog definitions by checking pnpm-workspace.yaml first (pnpm
+ * format), then falling back to the root package.json (Bun format).
+ *
+ * Pnpm defines catalogs in pnpm-workspace.yaml:
+ *
+ * ```yaml
+ * catalog:
+ *   react: ^18.3.1
+ * catalogs:
+ *   react18:
+ *     react: ^18.3.1
+ * ```
+ *
+ * Bun defines catalogs in package.json (at root level or under workspaces).
+ */
+async function loadCatalogSource(
+  workspaceRootDir: string,
+): Promise<CatalogSource> {
+  const cached = catalogSourceCache.get(workspaceRootDir);
+  if (cached) {
+    return cached;
+  }
+
+  const loadPromise = (async () => {
+    const log = useLogger();
+
+    /** Try pnpm-workspace.yaml first. */
+    const workspaceYamlPath = path.join(
+      workspaceRootDir,
+      "pnpm-workspace.yaml",
+    );
+
+    if (await fs.pathExists(workspaceYamlPath)) {
+      try {
+        const rawContent = await fs.readFile(workspaceYamlPath, "utf-8");
+        const yamlConfig = yaml.parse(rawContent) as CatalogSource | null;
+
+        if (yamlConfig?.catalog || yamlConfig?.catalogs) {
+          return {
+            catalog: yamlConfig.catalog,
+            catalogs: yamlConfig.catalogs,
+          };
+        }
+      } catch (error) {
+        log.warn(
+          `Failed to parse ${workspaceYamlPath}: ${error instanceof Error ? error.message : String(error)}. Falling back to package.json for catalog definitions.`,
+        );
+      }
+    }
+
+    /** Fall back to package.json (Bun format). */
+    const rootManifestPath = path.join(workspaceRootDir, "package.json");
+    const rootManifest = (await readTypedJson(
+      rootManifestPath,
+    )) as PackageManifest & {
+      catalog?: CatalogMap;
+      catalogs?: CatalogsMap;
+      workspaces?: {
+        catalog?: CatalogMap;
+        catalogs?: CatalogsMap;
+      };
+    };
+
+    return {
+      catalog: rootManifest.catalog ?? rootManifest.workspaces?.catalog,
+      catalogs: rootManifest.catalogs ?? rootManifest.workspaces?.catalogs,
+    };
+  })();
+
+  /**
+   * Drop the cache entry if loading fails so a subsequent call can retry
+   * instead of immediately rethrowing the same rejection.
+   */
+  const cachedLoadPromise = loadPromise.catch((error) => {
+    catalogSourceCache.delete(workspaceRootDir);
+    throw error;
+  });
+
+  catalogSourceCache.set(workspaceRootDir, cachedLoadPromise);
+  return cachedLoadPromise;
+}
 
 /**
  * Resolves catalog dependencies by replacing "catalog:" specifiers with their
- * actual versions from the root package.json catalog field.
+ * actual versions.
  *
  * Supports both pnpm and Bun catalog formats:
  *
- * - Pnpm: catalog at root level
- * - Bun: catalog or catalogs at root level, or workspaces.catalog
+ * - Pnpm: catalog/catalogs defined in pnpm-workspace.yaml
+ * - Bun: catalog or catalogs at root level, or workspaces.catalog in
+ *   package.json
  */
 export async function resolveCatalogDependencies(
   dependencies: Record<string, string> | undefined,
@@ -21,22 +117,8 @@ export async function resolveCatalogDependencies(
   }
 
   const log = useLogger();
-  const rootManifestPath = path.join(workspaceRootDir, "package.json");
-  const rootManifest = await readTypedJson<
-    PackageManifest & {
-      catalog?: Record<string, string>;
-      catalogs?: Record<string, Record<string, string>>;
-      workspaces?: {
-        catalog?: Record<string, string>;
-        catalogs?: Record<string, Record<string, string>>;
-      };
-    }
-  >(rootManifestPath);
-
-  // Try to find catalog in various locations (pnpm and Bun formats)
-  const flatCatalog = rootManifest.catalog || rootManifest.workspaces?.catalog;
-  const nestedCatalogs =
-    rootManifest.catalogs || rootManifest.workspaces?.catalogs;
+  const { catalog: flatCatalog, catalogs: nestedCatalogs } =
+    await loadCatalogSource(workspaceRootDir);
 
   if (!flatCatalog && !nestedCatalogs) {
     // No catalog found, return dependencies as-is
@@ -50,12 +132,18 @@ export async function resolveCatalogDependencies(
     if (specifier === "catalog:" || specifier.startsWith("catalog:")) {
       let catalogVersion: string | undefined;
 
-      if (specifier === "catalog:") {
-        // Simple catalog reference - use package name as key
-        catalogVersion = flatCatalog?.[packageName];
+      const groupName =
+        specifier === "catalog:" ? "default" : specifier.slice(8);
+
+      if (groupName === "default") {
+        /**
+         * Per pnpm semantics, `catalog:` and `catalog:default` are
+         * equivalent: the default catalog can live under the top-level
+         * `catalog` field or under `catalogs.default`, so check both.
+         */
+        catalogVersion =
+          flatCatalog?.[packageName] ?? nestedCatalogs?.default?.[packageName];
       } else {
-        // Catalog group reference (e.g., "catalog:group1")
-        const groupName = specifier.slice(8);
         catalogVersion = nestedCatalogs?.[groupName]?.[packageName];
       }
 

package/src/lib/manifest/io.ts

@@ -3,8 +3,12 @@ import path from "node:path";
 import type { PackageManifest } from "../types";
 import { readTypedJson } from "../utils";
 
-export async function readManifest(packageDir: string) {
-  return readTypedJson<PackageManifest>(path.join(packageDir, "package.json"));
+export async function readManifest(
+  packageDir: string,
+): Promise<PackageManifest> {
+  return (await readTypedJson(
+    path.join(packageDir, "package.json"),
+  )) as PackageManifest;
 }
 
 export async function writeManifest(

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

@@ -45,8 +45,8 @@ export function validateManifestMandatoryFields(
     missingFields.push("files");
   }
 
-  if (missingFields.length > 0) {
-    const field = missingFields[0]!;
+  const [field] = missingFields;
+  if (field) {
     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/src/lib/output/get-build-output-dir.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 import outdent from "outdent";
 import { useLogger } from "../logger";
 
-export async function getBuildOutputDir({
+export function getBuildOutputDir({
   targetPackageDir,
   buildDirName,
   tsconfigPath,

package/src/lib/output/pack-dependencies.ts

@@ -2,7 +2,7 @@ import { got } from "get-or-throw";
 import assert from "node:assert";
 import { useLogger } from "../logger";
 import type { PackagesRegistry } from "../types";
-import { pack } from "../utils";
+import { pack } from "../utils/pack";
 
 /**
  * Pack dependencies so that we extract only the files that are supposed to be

package/src/lib/output/process-build-output-files.ts

@@ -1,9 +1,7 @@
 import fs from "fs-extra";
 import path from "node:path";
-import { useLogger } from "../logger";
-import { pack, unpack } from "../utils";
-
-const TIMEOUT_MS = 5000;
+import { unpack } from "../utils";
+import { pack } from "../utils/pack";
 
 export async function processBuildOutputFiles({
   targetPackageDir,
@@ -14,22 +12,13 @@ export async function processBuildOutputFiles({
   tmpDir: string;
   isolateDir: string;
 }) {
-  const log = useLogger();
-
   const packedFilePath = await pack(targetPackageDir, tmpDir);
   const unpackDir = path.join(tmpDir, "target");
 
-  const now = Date.now();
-  let isWaitingYet = false;
-
-  while (!fs.existsSync(packedFilePath) && Date.now() - now < TIMEOUT_MS) {
-    if (!isWaitingYet) {
-      log.debug(`Waiting for ${packedFilePath} to become available...`);
-    }
-    isWaitingYet = true;
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-
+  /**
+   * `pack` already waits for the tarball to be fully written before returning,
+   * so it is safe to unpack immediately.
+   */
   await unpack(packedFilePath, unpackDir);
   await fs.copy(path.join(unpackDir, "package"), isolateDir);
 }

package/src/lib/package-manager/helpers/infer-from-files.ts

@@ -1,8 +1,8 @@
 import fs from "fs-extra";
 import { execSync } from "node:child_process";
 import path from "node:path";
-import { getErrorMessage } from "~/lib/utils";
-import { getMajorVersion } from "~/lib/utils/get-major-version";
+import { getErrorMessage } from "#/lib/utils";
+import { getMajorVersion } from "#/lib/utils/get-major-version";
 import type { PackageManager, PackageManagerName } from "../names";
 import { getLockfileFileName, supportedPackageManagerNames } from "../names";
 
@@ -15,10 +15,10 @@ export function inferFromFiles(workspaceRoot: string): PackageManager {
         const version = getVersion(name);
 
         return { name, version, majorVersion: getMajorVersion(version) };
-      } catch (err) {
+      } catch (error) {
         throw new Error(
-          `Failed to find package manager version for ${name}: ${getErrorMessage(err)}`,
-          { cause: err },
+          `Failed to find package manager version for ${name}: ${getErrorMessage(error)}`,
+          { cause: error },
         );
       }
     }