@savvy-web/silk-effects 5.9.0 → 5.9.1

package/changesets/services/release-planner.js

@@ -338,13 +338,10 @@ function applyEffect(root, dryRun, changelogModules, inspector, fs) {
 					version: fresh
 				} : p;
 			});
-			versionFileUpdates = yield* Effect.try({
-				try: () => scopes.length > 0 ? VersionFiles.processResolvedVersionFiles(scopes, dryRun) : [],
-				catch: (e) => new ReleasePlanError({
-					phase: "apply",
-					reason: errMsg(e)
-				})
-			});
+			versionFileUpdates = scopes.length > 0 ? yield* VersionFiles.processResolvedVersionFiles(scopes, dryRun).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.mapError((e) => new ReleasePlanError({
+				phase: "apply",
+				reason: errMsg(e)
+			}))) : [];
 		}
 		return {
 			dryRun,

package/changesets/utils/version-files.js

@@ -1,7 +1,7 @@
+import { VersionFileError } from "../errors.js";
 import { LegacyVersionFilesSchema } from "../schemas/version-files.js";
 import { jsonPathGet, jsonPathResolve, parseJsonPath } from "./jsonpath.js";
-import { Effect, Path, Schema } from "effect";
-import { readFileSync, writeFileSync } from "node:fs";
+import { Effect, FileSystem, Path, Schema } from "effect";
 import { join, relative, resolve } from "node:path";
 import { GlobPatternOptions } from "@effected/glob";
 import { compileAndExpand } from "@effected/walker";
@@ -102,34 +102,32 @@ var VersionFiles = class VersionFiles {
 	* @returns Array of workspace packages with versions
 	*/
 	static discoverVersions(cwd, packages) {
-		const resolvedCwd = resolve(cwd);
-		const results = [];
-		const seen = /* @__PURE__ */ new Set();
-		for (const pkg of packages) {
-			if (seen.has(pkg.path) || !pkg.version) continue;
-			seen.add(pkg.path);
-			results.push({
-				name: pkg.name,
-				path: pkg.path,
-				version: pkg.version
-			});
-		}
-		if (!seen.has(resolvedCwd)) {
-			const version = readPackageVersion(resolvedCwd);
-			if (version) {
-				let rootName = "root";
-				try {
-					const pkg = JSON.parse(readFileSync(join(resolvedCwd, "package.json"), "utf-8"));
-					if (pkg.name) rootName = pkg.name;
-				} catch {}
+		return Effect.gen(function* () {
+			const resolvedCwd = resolve(cwd);
+			const results = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const pkg of packages) {
+				if (seen.has(pkg.path) || !pkg.version) continue;
+				seen.add(pkg.path);
 				results.push({
-					name: rootName,
-					path: resolvedCwd,
-					version
+					name: pkg.name,
+					path: pkg.path,
+					version: pkg.version
 				});
 			}
-		}
-		return results;
+			if (!seen.has(resolvedCwd)) {
+				const version = yield* readPackageVersion(resolvedCwd);
+				if (version) {
+					const rootName = yield* readPackageName(resolvedCwd);
+					results.push({
+						name: rootName,
+						path: resolvedCwd,
+						version
+					});
+				}
+			}
+			return results;
+		});
 	}
 	/**
 	* Determine which workspace version applies to a given file path
@@ -224,16 +222,19 @@ var VersionFiles = class VersionFiles {
 	* @see {@link VersionFiles.applyVersionEdit} for the per-path edit
 	*/
 	static updateFile(filePath, jsonPaths, version) {
-		const original = readFileSync(filePath, "utf-8");
-		const { content, previousValues, totalChanged } = VersionFiles.computeUpdate(original, jsonPaths, version);
-		if (totalChanged === 0) return;
-		writeFileSync(filePath, content, "utf-8");
-		return {
-			filePath,
-			jsonPaths,
-			version,
-			previousValues
-		};
+		return Effect.gen(function* () {
+			const fs = yield* FileSystem.FileSystem;
+			const original = yield* fs.readFileString(filePath);
+			const { content, previousValues, totalChanged } = VersionFiles.computeUpdate(original, jsonPaths, version);
+			if (totalChanged === 0) return;
+			yield* fs.writeFileString(filePath, content);
+			return {
+				filePath,
+				jsonPaths,
+				version,
+				previousValues
+			};
+		});
 	}
 	/**
 	* Compute the full update for a document without touching the filesystem:
@@ -330,30 +331,15 @@ var VersionFiles = class VersionFiles {
 	*/
 	static processVersionFiles(cwd, configs, dryRun = false, packages = []) {
 		return Effect.gen(function* () {
-			const workspaces = VersionFiles.discoverVersions(cwd, packages);
+			const workspaces = yield* VersionFiles.discoverVersions(cwd, packages);
 			const rootVersion = workspaces.find((ws) => ws.path === resolve(cwd))?.version ?? "0.0.0";
 			const resolved = yield* VersionFiles.resolveGlobs(configs, cwd);
 			const updates = [];
 			for (const [filePath, config] of resolved) {
 				const jsonPaths = config.paths ?? ["$.version"];
 				const version = config.package ? workspaces.find((ws) => ws.name === config.package)?.version ?? rootVersion : VersionFiles.resolveVersion(filePath, workspaces, rootVersion);
-				try {
-					if (dryRun) {
-						const content = readFileSync(filePath, "utf-8");
-						const { previousValues, totalChanged } = VersionFiles.computeUpdate(content, jsonPaths, version);
-						if (totalChanged > 0) updates.push({
-							filePath,
-							jsonPaths,
-							version,
-							previousValues
-						});
-					} else {
-						const result = VersionFiles.updateFile(filePath, jsonPaths, version);
-						if (result) updates.push(result);
-					}
-				} catch (error) {
-					throw new Error(`Failed to update ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-				}
+				const result = yield* VersionFiles.applyOne(filePath, jsonPaths, version, dryRun).pipe(Effect.orDie);
+				if (result) updates.push(result);
 			}
 			return updates;
 		});
@@ -380,28 +366,61 @@ var VersionFiles = class VersionFiles {
 	* @internal
 	*/
 	static processResolvedVersionFiles(scopes, dryRun = false) {
-		const updates = [];
-		for (const scope of scopes) for (const vf of scope.versionFiles) {
-			const jsonPaths = vf.paths.length > 0 ? vf.paths : ["$.version"];
-			for (const filePath of vf.matchedFiles) try {
-				if (dryRun) {
-					const content = readFileSync(filePath, "utf-8");
-					const { previousValues, totalChanged } = VersionFiles.computeUpdate(content, jsonPaths, scope.version);
-					if (totalChanged > 0) updates.push({
-						filePath,
-						jsonPaths,
-						version: scope.version,
-						previousValues
-					});
-				} else {
-					const result = VersionFiles.updateFile(filePath, jsonPaths, scope.version);
+		return Effect.gen(function* () {
+			const updates = [];
+			for (const scope of scopes) for (const vf of scope.versionFiles) {
+				const jsonPaths = vf.paths.length > 0 ? vf.paths : ["$.version"];
+				for (const filePath of vf.matchedFiles) {
+					const result = yield* VersionFiles.applyOne(filePath, jsonPaths, scope.version, dryRun);
 					if (result) updates.push(result);
 				}
-			} catch (error) {
-				throw new Error(`Failed to update ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
 			}
+			return updates;
+		});
+	}
+	/**
+	* Apply one version file's update, shared by both process entry points.
+	*
+	* @remarks
+	* Fails TYPED with `VersionFileError`, carrying the offending `filePath`. The two callers then
+	* choose their own posture, which is not the same and must not be unified:
+	* {@link VersionFiles.processVersionFiles} (legacy) turns it into a DEFECT,
+	* matching the synchronous throw it had under `node:fs`, while
+	* {@link VersionFiles.processResolvedVersionFiles} leaves it typed because
+	* `ReleasePlanner.apply` converts it to a `ReleasePlanError` — a defect there
+	* would bypass the inspector's catch and crash `apply()`.
+	*
+	* @internal
+	*/
+	static applyOne(filePath, jsonPaths, version, dryRun) {
+		return Effect.gen(function* () {
+			if (dryRun) {
+				const content = yield* (yield* FileSystem.FileSystem).readFileString(filePath);
+				const { previousValues, totalChanged } = VersionFiles.computeUpdate(content, jsonPaths, version);
+				return totalChanged > 0 ? {
+					filePath,
+					jsonPaths,
+					version,
+					previousValues
+				} : void 0;
+			}
+			return yield* VersionFiles.updateFile(filePath, jsonPaths, version);
+		}).pipe(Effect.mapError((error) => new VersionFileError({
+			filePath,
+			reason: VersionFiles.describeFailure(error)
+		})), Effect.catchDefect((defect) => Effect.fail(new VersionFileError({
+			filePath,
+			reason: VersionFiles.describeFailure(defect)
+		}))));
+	}
+	/** Render a `PlatformError` the way the old `node:fs` catch rendered an `Error`. */
+	static describeFailure(error) {
+		if (typeof error === "object" && error !== null) {
+			const e = error;
+			if (typeof e.message === "string") return e.message;
+			if (typeof e.reason === "string") return e.reason;
 		}
-		return updates;
+		return String(error);
 	}
 };
 /**
@@ -450,12 +469,32 @@ function expandGlob(source, cwd) {
 *
 * @internal
 */
+/**
+* Read the `name` field from a `package.json` in the given directory, falling
+* back to `"root"` when it is absent, unreadable, or malformed.
+*
+* @param dir - Absolute path to the directory containing `package.json`
+* @returns The package name, or `"root"`
+*
+* @internal
+*/
+function readPackageName(dir) {
+	return Effect.gen(function* () {
+		const raw = yield* (yield* FileSystem.FileSystem).readFileString(join(dir, "package.json"));
+		return yield* Effect.try({
+			try: () => JSON.parse(raw).name,
+			catch: (e) => e
+		});
+	}).pipe(Effect.map((name) => name ?? "root"), Effect.orElseSucceed(() => "root"));
+}
 function readPackageVersion(dir) {
-	try {
-		return JSON.parse(readFileSync(join(dir, "package.json"), "utf-8")).version;
-	} catch {
-		return;
-	}
+	return Effect.gen(function* () {
+		const raw = yield* (yield* FileSystem.FileSystem).readFileString(join(dir, "package.json"));
+		return yield* Effect.try({
+			try: () => JSON.parse(raw).version,
+			catch: (e) => e
+		});
+	}).pipe(Effect.orElseSucceed(() => void 0));
 }
 
 //#endregion

package/index.d.ts

@@ -4,6 +4,7 @@ import { ChildProcessSpawner } from "effect/unstable/process";
 import { PackageManagerDetector, PublishConfig, PublishTarget, PublishabilityDetector, VersioningStrategy, WorkspaceDiscovery, WorkspaceDiscoveryFailure, WorkspacePackage, WorkspaceSnapshotAtFailure, WorkspaceSnapshotWorktreeFailure, WorkspaceSnapshots, WorkspaceStateSnapshot, WorkspacesOptions } from "@effected/workspaces";
 import { Git } from "@effected/git";
 import { GlobExpansionError } from "@effected/walker";
+import * as PlatformError from "effect/PlatformError";
 import { YamlFormattingOptions } from "@effected/yaml";
 import { Section, SectionId } from "@effected/templates";
 import { ToolDiscovery } from "@effected/commands";
@@ -4808,7 +4809,7 @@ declare class VersionFiles {
     name: string;
     version: string;
     path: string;
-  }>): WorkspaceVersion[];
+  }>): Effect.Effect<WorkspaceVersion[], never, FileSystem.FileSystem>;
   /**
    * Determine which workspace version applies to a given file path
    * using longest-prefix matching.
@@ -4883,7 +4884,7 @@ declare class VersionFiles {
    * @see {@link jsonPathResolve} for concrete-path enumeration
    * @see {@link VersionFiles.applyVersionEdit} for the per-path edit
    */
-  static updateFile(filePath: string, jsonPaths: readonly string[], version: string): VersionFileUpdate | undefined;
+  static updateFile(filePath: string, jsonPaths: readonly string[], version: string): Effect.Effect<VersionFileUpdate | undefined, PlatformError.PlatformError, FileSystem.FileSystem>;
   /**
    * Compute the full update for a document without touching the filesystem:
    * the edited content, the previous values at every matched path, and how
@@ -4965,7 +4966,24 @@ declare class VersionFiles {
    *
    * @internal
    */
-  static processResolvedVersionFiles(scopes: ReadonlyArray<ResolvedPackageScope>, dryRun?: boolean): VersionFileUpdate[];
+  static processResolvedVersionFiles(scopes: ReadonlyArray<ResolvedPackageScope>, dryRun?: boolean): Effect.Effect<VersionFileUpdate[], VersionFileError, FileSystem.FileSystem>;
+  /**
+   * Apply one version file's update, shared by both process entry points.
+   *
+   * @remarks
+   * Fails TYPED with `VersionFileError`, carrying the offending `filePath`. The two callers then
+   * choose their own posture, which is not the same and must not be unified:
+   * {@link VersionFiles.processVersionFiles} (legacy) turns it into a DEFECT,
+   * matching the synchronous throw it had under `node:fs`, while
+   * {@link VersionFiles.processResolvedVersionFiles} leaves it typed because
+   * `ReleasePlanner.apply` converts it to a `ReleasePlanError` — a defect there
+   * would bypass the inspector's catch and crash `apply()`.
+   *
+   * @internal
+   */
+  private static applyOne;
+  /** Render a `PlatformError` the way the old `node:fs` catch rendered an `Error`. */
+  private static describeFailure;
 }
 //#endregion
 //#region ../../node_modules/.pnpm/micromark-util-types@2.0.2/node_modules/micromark-util-types/index.d.ts

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/silk-effects",
-	"version": "5.9.0",
+	"version": "5.9.1",
 	"private": false,
 	"description": "Shared Effect library for Silk Suite conventions",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/silk-effects",
@@ -40,8 +40,8 @@
 		"@effected/package-json": "^0.9.0",
 		"@effected/templates": "^0.2.0",
 		"@effected/walker": "^0.4.0",
-		"@effected/workspaces": "^0.13.0",
-		"@effected/yaml": "^0.8.0",
+		"@effected/workspaces": "^0.13.1",
+		"@effected/yaml": "^0.9.0",
 		"@manypkg/get-packages": "^3.1.0",
 		"mdast-util-heading-range": "^4.0.0",
 		"mdast-util-to-string": "^4.0.0",