bun-nested-workspace 0.3.0 → 0.3.2

package/README.md

@@ -102,6 +102,7 @@ Exclude `node_modules` and other large directories from the build context with `
   An explicit list replaces the default trusted list of Bun, so when only one side defines the field, the packages of the other side lose the default list; list the ones whose lifecycle scripts they need.
   The sync warns when it adds the field to the host.
 - `patchedDependencies` paths are rewritten through the nested directory, such as `nested/patches/exceljs@4.4.0.patch`.
+  Bun warns on every install that it ignores `patchedDependencies` of the nested root package; keep them there, because the host applies the synced copies.
 
 A nested entry replaces a host entry with the same name, while the other host entries stay.
 The sync lists the host entries it replaced.
@@ -112,7 +113,7 @@ A package version patched by both the host and the nested repository is an error
 ### Lockfile
 
 The nested lockfile entries replace the host entries, so the nested packages keep their versions.
-When a replaced entry no longer satisfies a dependency of a host package, the host package keeps its previous resolution as a nested lockfile entry.
+When a replaced entry no longer satisfies a dependency of a host package, the host package keeps its previous resolution, and the nested packages keep theirs.
 When neither satisfies the range, which Bun lockfiles occasionally contain, the dependency gets the highest satisfying version recorded in either lockfile.
 Ranges are checked as `bun install` applies them: an override replaces the declared range, and an `npm:` alias requires the package it names.
 `bun install` then resolves new dependencies of host packages and drops unused entries.
@@ -120,7 +121,7 @@ Ranges are checked as `bun install` applies them: an override replaces the decla
 After the install, the sync compares the direct dependencies of host packages with the original host lockfile.
 A dependency may only change to the version that the nested lockfile hoists to its top level, and only within the host range.
 Any other change means either that the host lockfile did not pin the host dependencies, for example after an edit of a host `package.json` without `bun install`, or that the lockfile cannot record the host version next to the nested one.
-The latter happens to a host workspace without a name, because Bun records workspace-specific versions under the workspace name; name the workspace or align its range with the nested version.
+The latter happens to a host workspace other than the root without a name, because Bun records workspace-specific versions under the workspace name; name the workspace or align its range with the nested version.
 
 Only `bun.lock` with `lockfileVersion` 1 or 2 is supported, because the lockfile format is internal to Bun.
 

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/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-DfVz3A2J.mjs";
+import { a as syncNestedWorkspace, i as loadNestedWorkspace, n as checkNestedWorkspace, r as isInSync, t as BunInstallError, y as getErrorMessage } from "./workspace-ChlHn5I8.mjs";
 // src/cli.ts
 const usage = `Usage:
   bun-nested-workspace [bun install options]  Sync package.json and bun.lock, then run bun install

package/dist/index.d.mts

@@ -173,9 +173,12 @@ export declare function parseLockfile(text: string, source?: string): Lockfile;
 /**
  * Returns the nested lockfile with workspace and local paths relative to the host root.
  *
- * The nested root workspace moves to the nested directory, where it is a workspace of the host.
+ * The nested root workspace moves to the nested directory, where it is a workspace of the host,
+ * and takes `rootName`, the name of the nested root `package.json`, when it is given.
+ * Bun requires the name of a workspace package entry but keeps a root entry without the name
+ * when the name was added to `package.json` after the lockfile.
  */
-export declare function relocateLockfile(lock: Lockfile, dir: string): Lockfile;
+export declare function relocateLockfile(lock: Lockfile, dir: string, rootName?: string): Lockfile;
 /**
  * Returns the lockfile with root fields that affect resolution taken from the root `package.json`.
  *
@@ -191,7 +194,9 @@ export declare function applyManifestToLockfile(lock: Lockfile, manifest: Packag
  * A root entry overridden by the nested lockfile might not satisfy a dependency of a host package:
  * such a dependency gets back its previous host resolution as a nested entry, so `bun install` keeps the host version
  * instead of resolving the range again.
- * A host workspace without a name cannot have nested entries, so `bun install` resolves its dependency again.
+ * A dependency of the host root package gets it back at the top level instead, as `keepHostRootResolutions` describes.
+ * A host workspace other than the root without a name cannot have nested entries,
+ * so `bun install` resolves its dependency again.
  * When the previous host resolution does not satisfy the range either, which Bun lockfiles occasionally contain,
  * the dependency gets the highest satisfying version recorded in either lockfile.
  * Catalog dependencies are checked against the catalogs of the host lockfile, so apply the synced root fields
@@ -257,7 +262,7 @@ interface NestedWorkspace {
   manifestText: string;
   nestedManifest: PackageManifest;
   lock: Lockfile;
-  /** Nested lockfile relocated with `relocateLockfile`. */
+  /** Nested lockfile relocated with `relocateLockfile`, with the root name of `nestedManifest`. */
   nestedLock: Lockfile;
 }
 /** Loads the root `package.json` and `bun.lock` files of the host and of the nested checkout. */

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-DfVz3A2J.mjs";
+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";

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

@@ -506,12 +506,18 @@ async function readLockfile(file) {
 /**
 * Returns the nested lockfile with workspace and local paths relative to the host root.
 *
-* The nested root workspace moves to the nested directory, where it is a workspace of the host.
+* The nested root workspace moves to the nested directory, where it is a workspace of the host,
+* and takes `rootName`, the name of the nested root `package.json`, when it is given.
+* Bun requires the name of a workspace package entry but keeps a root entry without the name
+* when the name was added to `package.json` after the lockfile.
 */
-function relocateLockfile(lock, dir) {
+function relocateLockfile(lock, dir, rootName) {
 	return {
 		...lock,
-		workspaces: Object.fromEntries(Object.entries(lock.workspaces).map(([workspacePath, workspace]) => [path.posix.join(dir, workspacePath), workspace])),
+		workspaces: Object.fromEntries(Object.entries(lock.workspaces).map(([workspacePath, workspace]) => [path.posix.join(dir, workspacePath), workspacePath === "" && rootName !== void 0 ? {
+			...workspace,
+			name: rootName
+		} : workspace])),
 		packages: Object.fromEntries(Object.entries(lock.packages).map(([key, [resolution, ...rest]]) => [key, [relocateResolution(resolution, dir), ...rest]]))
 	};
 }
@@ -551,7 +557,9 @@ function applyManifestToLockfile(lock, manifest) {
 * A root entry overridden by the nested lockfile might not satisfy a dependency of a host package:
 * such a dependency gets back its previous host resolution as a nested entry, so `bun install` keeps the host version
 * instead of resolving the range again.
-* A host workspace without a name cannot have nested entries, so `bun install` resolves its dependency again.
+* A dependency of the host root package gets it back at the top level instead, as `keepHostRootResolutions` describes.
+* A host workspace other than the root without a name cannot have nested entries,
+* so `bun install` resolves its dependency again.
 * When the previous host resolution does not satisfy the range either, which Bun lockfiles occasionally contain,
 * the dependency gets the highest satisfying version recorded in either lockfile.
 * Catalog dependencies are checked against the catalogs of the host lockfile, so apply the synced root fields
@@ -565,16 +573,16 @@ function mergeLockfiles(lock, nestedLock, dir) {
 		...nestedLock.packages
 	};
 	const hostWorkspaces = Object.entries(lock.workspaces).filter(([workspacePath]) => !isNestedPath(workspacePath, dir));
-	const dependents = [...hostWorkspaces.map(([, workspace]) => ({
+	if (lock.workspaces[""]) keepHostRootResolutions(lock, nestedLock, packages);
+	const dependents = [...hostWorkspaces.flatMap(([workspacePath, workspace]) => workspacePath && workspace.name ? [{
 		key: workspace.name,
 		dependencies: getWorkspaceDependencies(workspace)
-	})), ...Object.keys(packages).map((key) => ({
+	}] : []), ...Object.keys(packages).map((key) => ({
 		key,
 		dependencies: getPackageDependencies(packages[key])
 	}))];
 	for (let index = 0; index < dependents.length; index++) {
 		const { key, dependencies } = dependents[index];
-		if (key === void 0) continue;
 		for (const [dependency, specifier] of Object.entries(dependencies)) {
 			const requirement = getRequirement(lock, dependency, specifier);
 			const resolved = resolveDependencyLockKey(key, dependency, packages);
@@ -600,6 +608,63 @@ function mergeLockfiles(lock, nestedLock, dir) {
 		packages
 	};
 }
+/**
+* Gives the dependencies of the host root package back their previous host resolutions where top-level nested
+* entries do not satisfy them.
+*
+* Bun resolves the dependencies of the root package at the top level only, so placing the host resolution under the
+* root name does not pin the root dependency: the host resolution returns to the top level with its host chain instead.
+* Then every dependency of a nested workspace or package that no longer resolves to its nested entry or a copy of it,
+* such as one that resolved the replaced entry, gets a copy of its nested entry under the dependent,
+* so the copied entries keep their whole nested dependency trees.
+*/
+function keepHostRootResolutions(lock, nestedLock, packages) {
+	const replaced = /* @__PURE__ */ new Set();
+	for (const [dependency, specifier] of Object.entries(getWorkspaceDependencies(lock.workspaces[""]))) {
+		const requirement = getRequirement(lock, dependency, specifier);
+		const nestedEntry = Object.hasOwn(nestedLock.packages, dependency) ? nestedLock.packages[dependency] : void 0;
+		if (!requirement || !nestedEntry || satisfies(nestedEntry, requirement)) continue;
+		const previous = Object.hasOwn(lock.packages, dependency) ? lock.packages[dependency] : void 0;
+		const replacement = previous && satisfies(previous, requirement) ? previous : findSatisfyingEntry([nestedLock.packages, lock.packages], requirement);
+		if (!replacement) continue;
+		replaced.add(dependency);
+		const prefix = `${dependency}/`;
+		for (const key of Object.keys(packages)) if (key.startsWith(prefix)) delete packages[key];
+		packages[dependency] = replacement;
+		if (replacement === previous) {
+			for (const [key, entry] of Object.entries(lock.packages)) if (key.startsWith(prefix)) packages[key] = entry;
+		}
+	}
+	if (!replaced.size) return;
+	const nestedKeys = new Map(Object.keys(nestedLock.packages).filter((key) => !replaced.has(splitPackageKey(key)[0])).map((key) => [key, key]));
+	const queue = [...Object.values(nestedLock.workspaces).flatMap((workspace) => workspace.name ? [{
+		key: workspace.name,
+		nestedKey: workspace.name,
+		dependencies: getWorkspaceDependencies(workspace)
+	}] : []), ...[...nestedKeys.keys()].map((key) => ({
+		key,
+		nestedKey: key,
+		dependencies: getPackageDependencies(nestedLock.packages[key])
+	}))];
+	for (let index = 0; index < queue.length; index++) {
+		const { key, nestedKey, dependencies } = queue[index];
+		for (const dependency of Object.keys(dependencies)) {
+			const expected = resolveDependencyLockKey(nestedKey, dependency, nestedLock.packages);
+			if (expected === void 0) continue;
+			const actual = resolveDependencyLockKey(key, dependency, packages);
+			if (actual !== void 0 && nestedKeys.get(actual) === expected) continue;
+			const entry = nestedLock.packages[expected];
+			const pinnedKey = `${key}/${dependency}`;
+			packages[pinnedKey] = entry;
+			nestedKeys.set(pinnedKey, expected);
+			queue.push({
+				key: pinnedKey,
+				nestedKey: expected,
+				dependencies: getPackageDependencies(entry)
+			});
+		}
+	}
+}
 /** Returns the installed dependencies declared by a lockfile workspace. */
 function getWorkspaceDependencies(workspace) {
 	return {
@@ -815,14 +880,15 @@ async function loadNestedWorkspace(root) {
 	const manifest = JSON.parse(manifestText);
 	const config = readConfig(manifest);
 	const nestedRoot = path.join(root, config.dir);
+	const nestedManifest = await Bun.file(path.join(nestedRoot, "package.json")).json();
 	return {
 		root,
 		config,
 		manifest,
 		manifestText,
-		nestedManifest: await Bun.file(path.join(nestedRoot, "package.json")).json(),
+		nestedManifest,
 		lock: await readLockfile(path.join(root, "bun.lock")),
-		nestedLock: relocateLockfile(await readLockfile(path.join(nestedRoot, "bun.lock")), config.dir)
+		nestedLock: relocateLockfile(await readLockfile(path.join(nestedRoot, "bun.lock")), config.dir, typeof nestedManifest.name === "string" ? nestedManifest.name : void 0)
 	};
 }
 /** Returns whether a check found no differences. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-nested-workspace",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "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",