bun-nested-workspace 0.3.2 → 0.4.0

package/README.md

@@ -51,6 +51,8 @@ Then update the nested lockfile with `bun install --lockfile-only` in the direct
 bunx bun-nested-workspace
 ```
 
+A nested repository without workspace packages updates its lockfile in a separate clone.
+
 Do not run other `bun install`, `bun add`, or `bun remove` commands in the nested directory or in its package directories:
 
 - In the nested root, Bun runs them for the host: it writes the host lockfile and leaves the nested one stale.
@@ -72,6 +74,7 @@ The sync:
 4. Fails if the install re-resolved own dependencies of host packages, or if the host does not resolve the nested packages as the nested lockfile does.
 
 Commit `package.json` and `bun.lock` after the sync.
+A failed sync restores `package.json` and `bun.lock` to their contents before the run, while `node_modules` stays as the install left it.
 
 In a Docker build, run the sync with `--lockfile-only` in a stage that contains only the dependency files, before installing dependencies.
 The dependency install runs the `prepare` script of the nested root unless it gets `--ignore-scripts`.
@@ -132,7 +135,8 @@ bunx bun-nested-workspace --check
 ```
 
 The check writes nothing, does not run `bun install`, and exits with code 1 when the host files lag behind the nested checkout.
-It reads the root `package.json` and `bun.lock` of the host and of the nested checkout only, so it relies on the nested `bun.lock` being up to date with the nested packages; `bun install --frozen-lockfile` in the CI of the nested repository verifies that.
+It reads the root `package.json` and `bun.lock` of the host and of the nested checkout only, so it relies on the nested `bun.lock` being up to date with the nested packages.
+Verify that in the CI of the nested repository with `bun install --lockfile-only` followed by `git diff --exit-code bun.lock`: `bun install --frozen-lockfile` misses some changes, such as a narrowed range that the locked version still satisfies.
 Use it in a non-blocking CI job that signals when a sync commit is due.
 
 It reports:
@@ -149,7 +153,7 @@ Limitations:
 
 - Peer dependencies are not walked.
 - Edges that the nested lockfile itself resolves outside their range are skipped, because the sync repairs them in the host.
-- The check does not verify that the host lockfile matches the host packages; `bun install --frozen-lockfile` does.
+- The check does not verify that the host lockfile matches the host packages; `bun install --lockfile-only` followed by `git diff --exit-code bun.lock` does.
 - The check does not predict whether a sync would re-resolve own dependencies of host packages; only the sync detects it after `bun install`.
 
 ## API
@@ -173,7 +177,8 @@ if (!isInSync(check)) {
 }
 ```
 
-`syncNestedWorkspace` writes the files and runs `bun install` before it checks the result, so a failed sync leaves the written files for inspection.
+`syncNestedWorkspace` writes the files and runs `bun install` before it checks the result.
+When `bun install` fails or the result shows differences, it restores both files before it throws or returns, and throws an error saying so when it cannot restore them.
 Its `onManifestSync` option receives the replaced host entries and whether the sync added `trustedDependencies`, as soon as `package.json` is written and even when `bun install` then fails.
 
 Lower-level functions work on parsed files without touching the disk: `syncManifest`, `diffManifests`, `parseLockfile`, `relocateLockfile`, `applyManifestToLockfile`, `mergeLockfiles`, and the `find*` checks.

package/dist/cli.mjs

@@ -1,11 +1,12 @@
 #!/usr/bin/env bun
-import { a as syncNestedWorkspace, i as loadNestedWorkspace, n as checkNestedWorkspace, r as isInSync, t as BunInstallError, y as getErrorMessage } from "./workspace-ChlHn5I8.mjs";
+import { a as isNestedWorkspace, i as isInSync, n as checkNestedWorkspace, o as loadNestedWorkspace, r as findNestedPackageDir, s as syncNestedWorkspace, t as BunInstallError, x as getErrorMessage } from "./workspace-DOwKm8pX.mjs";
 // src/cli.ts
 const usage = `Usage:
   bun-nested-workspace [bun install options]  Sync package.json and bun.lock, then run bun install
   bun-nested-workspace --check                Exit with 1 if package.json or bun.lock lag behind the nested checkout
 
 Configure the nested directory in the "bun-nested-workspace" field of the host package.json.`;
+const restoredMessage = "Restored package.json and bun.lock to their contents before the sync.";
 /** Runs the CLI with the given arguments in the given host root and returns the exit code. */
 async function runCli(args, root = process.cwd()) {
 	if (args.includes("--help") || args.includes("-h")) {
@@ -23,7 +24,10 @@ async function runCli(args, root = process.cwd()) {
 		}
 		return await runSync(root, args);
 	} catch (error) {
-		if (error instanceof BunInstallError) return error.exitCode;
+		if (error instanceof BunInstallError) {
+			console.error(restoredMessage);
+			return error.exitCode;
+		}
 		console.error(getErrorMessage(error));
 		return 1;
 	}
@@ -51,7 +55,7 @@ async function runSync(root, installArgs) {
 	if (ownDependencyChanges.length) {
 		console.error([
 			"The sync changed own dependencies of host packages.",
-			"Either the host bun.lock did not pin them: restore bun.lock, run bun install, commit bun.lock, and sync again.",
+			"Either the host bun.lock did not pin them: run bun install, commit bun.lock, and sync again.",
 			"Or the nested lockfile resolves them outside the host range: align the host range with the nested version.",
 			...ownDependencyChanges.map(({ workspace, dependency, expected, actual }) => formatChange(`${workspace} > ${dependency}`, expected, actual))
 		].join("\n"));
@@ -59,10 +63,23 @@ async function runSync(root, installArgs) {
 	}
 	if (!isInSync(check)) {
 		console.error(["bun install did not keep the nested resolutions:", ...formatCheckResult(check)].join("\n"));
+		const workspace = await loadNestedWorkspace(root);
+		if (check.workspaces.some((workspacePath) => isNestedWorkspace(workspace, workspacePath))) console.error(await formatNestedLockfileUpdate(workspace));
 		exitCode = 1;
 	}
+	if (exitCode) console.error(restoredMessage);
 	return exitCode;
 }
+/** Formats how to update a nested lockfile that lags behind the nested package.json files. */
+async function formatNestedLockfileUpdate(workspace) {
+	const { dir } = workspace.config;
+	const packageDir = await findNestedPackageDir(workspace);
+	return packageDir ? `${dir}/bun.lock lags behind the package.json files of ${dir}. Update it and sync again:\n  (cd ${quoteShellArgument(packageDir)} && bun install --lockfile-only)` : `${dir}/bun.lock lags behind the package.json files of ${dir}. Update it with bun install --lockfile-only in a separate clone of the nested repository and sync again.`;
+}
+/** Quotes a value for a POSIX shell when it contains characters other than those of plain paths. */
+function quoteShellArgument(value) {
+	return /^[\w@%+=:,./-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+}
 function printManifestSync({ overridden, addedTrustedDependencies }) {
 	if (overridden.length) console.log(["Nested entries replaced host entries:", ...overridden.map(formatOverridden)].join("\n"));
 	if (addedTrustedDependencies) console.warn([

package/dist/index.d.mts

@@ -298,11 +298,15 @@ interface SyncOptions {
    */
   onManifestSync?: (sync: ManifestSync) => void;
 }
-/** Result of `syncNestedWorkspace`. */
+/**
+ * Result of `syncNestedWorkspace`.
+ *
+ * The sync failed and restored the host files when `ownDependencyChanges` is not empty or `isInSync(check)` is false.
+ */
 interface SyncResult {
-  /** Own dependencies of host workspaces that the sync re-resolved; the sync failed when this is not empty. */
+  /** Own dependencies of host workspaces that the sync re-resolved. */
   ownDependencyChanges: DependencyMismatch[];
-  /** Check of the synced files; the sync failed when it is not in sync. */
+  /** Check of the synced files. */
   check: CheckResult;
 }
 /**
@@ -310,6 +314,9 @@ interface SyncResult {
  *
  * Writes the synced `package.json`, writes the merged `bun.lock`, runs `bun install`,
  * and then compares the result with the nested checkout and with the original host resolutions.
+ * When `bun install` fails or the result differs, restores both files before it throws or returns,
+ * so that the next sync starts from the original host resolutions.
+ * Throws an error that says so when it cannot restore them.
  */
 export declare function syncNestedWorkspace(root: string, options?: SyncOptions): Promise<SyncResult>;
 export type { CheckResult, DependencyMismatch, Lockfile, ManifestDifference, ManifestSync, NestedWorkspace, NestedWorkspaceConfig, OverriddenEntry, PackageManifest, PackageMismatch, ResolvedConfig, SyncOptions, SyncResult, SyncedEntries, SyncedField, WorkspacesConfig };

package/dist/index.mjs

@@ -1 +1 @@
-export { t as BunInstallError, d as applyManifestToLockfile, n as checkNestedWorkspace, g as diffManifests, o as findDirectDependencyMismatches, s as findOwnDependencyChanges, c as findTransitiveMismatches, l as findUncoveredWorkspaces, u as findWorkspaceMismatches, r as isInSync, i as loadNestedWorkspace, f as mergeLockfiles, p as parseLockfile, m as relocateLockfile, h as supportedLockfileVersions, _ as syncManifest, a as syncNestedWorkspace, v as syncedFields } from "./workspace-ChlHn5I8.mjs";
+export { t as BunInstallError, p as applyManifestToLockfile, n as checkNestedWorkspace, v as diffManifests, c as findDirectDependencyMismatches, l as findOwnDependencyChanges, u as findTransitiveMismatches, d as findUncoveredWorkspaces, f as findWorkspaceMismatches, i as isInSync, o as loadNestedWorkspace, m as mergeLockfiles, h as parseLockfile, g as relocateLockfile, _ as supportedLockfileVersions, y as syncManifest, s as syncNestedWorkspace, b as syncedFields } from "./workspace-DOwKm8pX.mjs";

package/dist/{workspace-ChlHn5I8.mjs → workspace-DOwKm8pX.mjs}

@@ -1,6 +1,6 @@
+import path from "node:path";
 import JSON5 from "json5";
 import semver from "semver";
-import path from "node:path";
 // ../lockfile/src/parse.ts
 function isObject(value) {
 	return typeof value === "object" && value !== null;
@@ -742,12 +742,40 @@ function resolveDependency(lock, workspaceName, dependency) {
 	return key === void 0 ? void 0 : lock.packages[key][0];
 }
 // src/check.ts
+/** Returns the `workspaces` patterns of a root `package.json`. */
+function getWorkspacePatterns(manifest) {
+	const patterns = (Array.isArray(manifest.workspaces) ? manifest.workspaces : manifest.workspaces?.packages ?? []).map((pattern) => pattern.replace(/^(!?)\.\//, "$1").replace(/\/+$/, ""));
+	return {
+		included: patterns.filter((pattern) => !pattern.startsWith("!")),
+		excluded: patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1))
+	};
+}
+/**
+* Returns whether the patterns include a directory relative to their root, as `bun install` decides it.
+*
+* The root itself is never included.
+* A pattern without glob syntax includes its exact path regardless of exclusions.
+* A glob pattern matches the `package.json` path of the directory, so `dir/**` includes `dir` itself,
+* and skips `node_modules`, `.git`, and `CMakeFiles` directories.
+* An exclusion `dir/**` also excludes `dir` itself.
+*/
+function matchesWorkspacePatterns(patterns, dir) {
+	const isGlob = (pattern) => /[*?[\]{}]/.test(pattern);
+	const matches = (pattern) => new Bun.Glob(pattern).match(dir);
+	const matchesManifest = (pattern) => new Bun.Glob(path.posix.join(pattern, "package.json")).match(path.posix.join(dir, "package.json"));
+	if (path.posix.normalize(dir) === ".") return false;
+	if (patterns.included.some((pattern) => !isGlob(pattern) && path.posix.normalize(pattern) === dir)) return true;
+	return !dir.split("/").some((part) => ignoredGlobDirs.has(part)) && patterns.included.some((pattern) => isGlob(pattern) && matchesManifest(pattern)) && !patterns.excluded.some((pattern) => matches(pattern) || pattern.endsWith("/**") && matches(pattern.slice(0, -3)));
+}
+const ignoredGlobDirs = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"CMakeFiles"
+]);
 /** Returns the nested workspace paths that the host `workspaces` patterns do not include. */
 function findUncoveredWorkspaces(manifest, nestedLock) {
-	const patterns = (Array.isArray(manifest.workspaces) ? manifest.workspaces : manifest.workspaces?.packages ?? []).map((pattern) => pattern.replace(/^(!?)\.\//, "$1").replace(/\/+$/, ""));
-	const included = patterns.filter((pattern) => !pattern.startsWith("!")).map((pattern) => new Bun.Glob(pattern));
-	const excluded = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => new Bun.Glob(pattern.slice(1)));
-	return Object.keys(nestedLock.workspaces).filter((workspacePath) => !included.some((glob) => glob.match(workspacePath)) || excluded.some((glob) => glob.match(workspacePath)));
+	const patterns = getWorkspacePatterns(manifest);
+	return Object.keys(nestedLock.workspaces).filter((workspacePath) => !matchesWorkspacePatterns(patterns, workspacePath));
 }
 /**
 * Returns the paths of nested workspaces whose host lockfile entries differ from the relocated nested lockfile,
@@ -891,6 +919,33 @@ async function loadNestedWorkspace(root) {
 		nestedLock: relocateLockfile(await readLockfile(path.join(nestedRoot, "bun.lock")), config.dir, typeof nestedManifest.name === "string" ? nestedManifest.name : void 0)
 	};
 }
+/**
+* Returns whether a workspace path of the host lockfile is a workspace of the nested repository:
+* its root, a workspace of the nested lockfile, or a directory that the nested `workspaces` patterns include.
+*/
+function isNestedWorkspace(workspace, workspacePath) {
+	const { dir } = workspace.config;
+	return workspacePath === dir || workspacePath in workspace.nestedLock.workspaces || isNestedPath(workspacePath, dir) && matchesWorkspacePatterns(getWorkspacePatterns(workspace.nestedManifest), workspacePath.slice(dir.length + 1));
+}
+/**
+* Returns the first directory with a named package that the nested `workspaces` patterns include, relative to the host root.
+*
+* `bun install` treats the nested root as the workspace root there and writes the nested lockfile,
+* while in the nested root itself it writes the host lockfile.
+*/
+async function findNestedPackageDir(workspace) {
+	const nestedRoot = path.join(workspace.root, workspace.config.dir);
+	const patterns = getWorkspacePatterns(workspace.nestedManifest);
+	const dirs = /* @__PURE__ */ new Set();
+	for (const pattern of patterns.included) for await (const file of new Bun.Glob(`${pattern}/package.json`).scan(nestedRoot)) {
+		const dir = path.posix.normalize(path.posix.dirname(file.split(path.sep).join("/")));
+		if (matchesWorkspacePatterns(patterns, dir)) dirs.add(dir);
+	}
+	for (const dir of [...dirs].sort()) {
+		const manifest = await Bun.file(path.join(nestedRoot, dir, "package.json")).json();
+		if (typeof manifest.name === "string" && manifest.name) return `${workspace.config.dir}/${dir}`;
+	}
+}
 /** Returns whether a check found no differences. */
 function isInSync(result) {
 	return Object.values(result).every((list) => !list.length);
@@ -951,6 +1006,9 @@ async function runBunInstall(root, args = []) {
 *
 * Writes the synced `package.json`, writes the merged `bun.lock`, runs `bun install`,
 * and then compares the result with the nested checkout and with the original host resolutions.
+* When `bun install` fails or the result differs, restores both files before it throws or returns,
+* so that the next sync starts from the original host resolutions.
+* Throws an error that says so when it cannot restore them.
 */
 async function syncNestedWorkspace(root, options = {}) {
 	const workspace = await loadNestedWorkspace(root);
@@ -958,20 +1016,56 @@ async function syncNestedWorkspace(root, options = {}) {
 	const manifestSync = syncManifest(workspace.manifest, workspace.nestedManifest);
 	const { manifest } = manifestSync;
 	const merged = mergeLockfiles(applyManifestToLockfile(workspace.lock, manifest), workspace.nestedLock, workspace.config.dir);
-	const manifestText = formatJson(manifest, workspace.manifestText);
-	if (manifestText !== workspace.manifestText) await Bun.write(path.join(root, "package.json"), manifestText);
-	options.onManifestSync?.(manifestSync);
-	await Bun.write(path.join(root, "bun.lock"), renderBunLock(merged));
-	await runBunInstall(root, options.installArgs);
-	const synced = await loadNestedWorkspace(root);
-	return {
-		ownDependencyChanges: findOwnDependencyChanges(workspace.lock, synced.lock, workspace.nestedLock, workspace.config.dir),
-		check: checkNestedWorkspace(synced)
+	const manifestPath = path.join(root, "package.json");
+	const lockPath = path.join(root, "bun.lock");
+	const originals = /* @__PURE__ */ new Map([[manifestPath, workspace.manifestText], [lockPath, await Bun.file(lockPath).text()]]);
+	const restore = async () => {
+		const failures = await restoreFiles(originals);
+		if (failures.length) throw new Error([
+			"The sync failed and could not restore the host files:",
+			...failures.map(({ file, error }) => `  ${path.basename(file)}: ${getErrorMessage(error)}`),
+			"Restore them before running the sync again."
+		].join("\n"));
 	};
+	let result;
+	try {
+		const manifestText = formatJson(manifest, workspace.manifestText);
+		if (manifestText !== workspace.manifestText) await Bun.write(manifestPath, manifestText);
+		options.onManifestSync?.(manifestSync);
+		await Bun.write(lockPath, renderBunLock(merged));
+		await runBunInstall(root, options.installArgs);
+		const synced = await loadNestedWorkspace(root);
+		result = {
+			ownDependencyChanges: findOwnDependencyChanges(workspace.lock, synced.lock, workspace.nestedLock, workspace.config.dir),
+			check: checkNestedWorkspace(synced)
+		};
+	} catch (error) {
+		await restore();
+		throw error;
+	}
+	if (result.ownDependencyChanges.length || !isInSync(result.check)) await restore();
+	return result;
+}
+/**
+* Writes back the original texts of files whose contents differ from them and returns the files it could not restore.
+*
+* Restores each file separately, so that a failure does not keep the other files changed.
+*/
+async function restoreFiles(originals) {
+	const failures = [];
+	for (const [file, text] of originals) try {
+		if (await Bun.file(file).text().catch(() => void 0) !== text) await Bun.write(file, text);
+	} catch (error) {
+		failures.push({
+			file,
+			error
+		});
+	}
+	return failures;
 }
 /** Serializes JSON with the indentation and final newline of the original text. */
 function formatJson(value, original) {
 	const indent = /^[ \t]+(?=")/m.exec(original)?.[0] ?? "  ";
 	return `${JSON.stringify(value, null, indent)}${original.endsWith("\n") ? "\n" : ""}`;
 }
-export { syncManifest as _, syncNestedWorkspace as a, findTransitiveMismatches as c, applyManifestToLockfile as d, mergeLockfiles as f, diffManifests as g, supportedLockfileVersions as h, loadNestedWorkspace as i, findUncoveredWorkspaces as l, relocateLockfile as m, checkNestedWorkspace as n, findDirectDependencyMismatches as o, parseLockfile as p, isInSync as r, findOwnDependencyChanges as s, BunInstallError as t, findWorkspaceMismatches as u, syncedFields as v, getErrorMessage as y };
+export { supportedLockfileVersions as _, isNestedWorkspace as a, syncedFields as b, findDirectDependencyMismatches as c, findUncoveredWorkspaces as d, findWorkspaceMismatches as f, relocateLockfile as g, parseLockfile as h, isInSync as i, findOwnDependencyChanges as l, mergeLockfiles as m, checkNestedWorkspace as n, loadNestedWorkspace as o, applyManifestToLockfile as p, findNestedPackageDir as r, syncNestedWorkspace as s, BunInstallError as t, findTransitiveMismatches as u, diffManifests as v, getErrorMessage as x, syncManifest as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-nested-workspace",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Embed a checkout of another Bun workspace repository into a Bun workspace and keep the root package.json and bun.lock in sync with it",
   "keywords": [
     "bun",