@markjaquith/agency 3.2.8 → 3.2.10

package/src/services/LifecycleTransaction.ts

@@ -1,4 +1,4 @@
-import { Data, Effect } from "effect"
+import { Cause, Data, Effect, Exit, Option } from "effect"
 import { lstat, mkdir, open, rename, rm } from "node:fs/promises"
 import { dirname, join, relative } from "node:path"
 import {
@@ -16,25 +16,33 @@ class LifecycleTransactionError extends Data.TaggedError(
 	readonly cause?: unknown
 }> {}
 
-export interface TransactionStep {
+export interface TransactionStep<R = never> {
 	readonly label: string
-	readonly preflight?: () => Promise<void>
-	readonly apply: () => Promise<void>
-	readonly rollback?: () => Promise<void>
-	readonly finalize?: () => Promise<void>
+	readonly preflight?: Effect.Effect<void, unknown, R>
+	readonly apply: Effect.Effect<void, unknown, R>
+	readonly rollback?: Effect.Effect<void, unknown, R>
+	readonly finalize?: Effect.Effect<void, unknown, R>
 	readonly manualRecovery?: string
 }
 
+export const transactionEffect = <A>(run: () => PromiseLike<A>) =>
+	Effect.uninterruptible(
+		Effect.tryPromise({
+			try: () => Promise.resolve(run()),
+			catch: (cause) => cause,
+		}),
+	)
+
 export const pathMustNotExistStep = (
 	root: string,
 	path: string,
 	message: string,
 ): TransactionStep => ({
 	label: `verify ${relative(root, path)} is available`,
-	preflight: async () => {
+	preflight: transactionEffect(async () => {
 		if (await exists(path)) throw new Error(message)
-	},
-	apply: async () => {},
+	}),
+	apply: Effect.void,
 })
 
 interface DocumentWrite {
@@ -43,13 +51,13 @@ interface DocumentWrite {
 	readonly create?: boolean
 }
 
-interface TransactionPlan {
+interface TransactionPlan<R> {
 	readonly root: string
 	readonly preconditions?: readonly {
 		readonly path: string
 		readonly revision: string
 	}[]
-	readonly steps: readonly TransactionStep[]
+	readonly steps: readonly TransactionStep<R>[]
 }
 
 const exists = async (path: string) => {
@@ -103,7 +111,7 @@ export const documentWriteStep = (
 
 	return {
 		label,
-		preflight: async () => {
+		preflight: transactionEffect(async () => {
 			for (const write of staged) {
 				const targetExists = await exists(write.path)
 				if (write.create === true && targetExists)
@@ -115,8 +123,8 @@ export const documentWriteStep = (
 						`Document does not exist: ${relative(root, write.path)}`,
 					)
 			}
-		},
-		apply: async () => {
+		}),
+		apply: transactionEffect(async () => {
 			await mkdir(stagingDirectory)
 			for (const write of staged) await Bun.write(write.stage, write.content)
 			try {
@@ -156,11 +164,11 @@ export const documentWriteStep = (
 				}
 				throw cause
 			}
-		},
-		rollback,
-		finalize: async () => {
+		}),
+		rollback: transactionEffect(rollback),
+		finalize: transactionEffect(async () => {
 			await rm(stagingDirectory, { recursive: true, force: true })
-		},
+		}),
 		manualRecovery: `Inspect ${relative(root, stagingDirectory)} for staged documents and backups`,
 	}
 }
@@ -173,146 +181,157 @@ export const directoryMoveStep = (
 	let createdParent = false
 	return {
 		label: `move ${relative(root, from)} to ${relative(root, to)}`,
-		preflight: async () => {
+		preflight: transactionEffect(async () => {
 			if (!(await exists(from)))
 				throw new Error(`Move source does not exist: ${relative(root, from)}`)
 			if (await exists(to))
 				throw new Error(
 					`Move destination already exists: ${relative(root, to)}`,
 				)
-		},
-		apply: async () => {
+		}),
+		apply: transactionEffect(async () => {
 			const parent = dirname(to)
 			if (!(await exists(parent))) {
 				await mkdir(parent, { recursive: true })
 				createdParent = true
 			}
 			await rename(from, to)
-		},
-		rollback: async () => {
+		}),
+		rollback: transactionEffect(async () => {
 			await rename(to, from)
 			if (createdParent) await rm(dirname(to), { recursive: true, force: true })
-		},
+		}),
 		manualRecovery: `Move ${relative(root, to)} back to ${relative(root, from)}`,
 	}
 }
 
-export const runLifecycleTransaction = ({
+export const runLifecycleTransaction = <R>({
 	root,
 	preconditions = [],
 	steps,
-}: TransactionPlan) =>
-	Effect.tryPromise({
-		try: async () => {
-			const lockPath = join(root, ".agency-graph-mutation.lock")
-			let lock: Awaited<ReturnType<typeof open>>
-			try {
-				lock = await open(lockPath, "wx")
-			} catch (cause) {
-				throw new LifecycleTransactionError({
-					message:
-						"Another graph mutation is in progress; wait for it to finish and retry",
-					completed: [],
-					rolledBack: [],
-					manualRecovery: [],
-					cause,
-				})
-			}
-
-			const completed: TransactionStep[] = []
-			const rolledBack: string[] = []
-			try {
-				for (const precondition of preconditions) {
-					const content = await Bun.file(precondition.path).text()
-					const currentRevision = documentRevision(content)
-					if (currentRevision !== precondition.revision) {
-						throw new RevisionConflictError({
-							path: relative(root, precondition.path),
-							expectedRevision: precondition.revision,
-							currentRevision,
-							message: `Revision conflict for ${relative(root, precondition.path)}`,
-						})
-					}
-				}
-				for (const step of steps) await step.preflight?.()
-				for (const step of steps) {
-					await step.apply()
-					completed.push(step)
-				}
-				const cleanup = await Promise.allSettled(
-					completed.map((step) => step.finalize?.() ?? Promise.resolve()),
-				)
-				const cleanupFailures = cleanup.filter(
-					(result) => result.status === "rejected",
-				)
-				if (cleanupFailures.length > 0) {
-					throw new LifecycleTransactionError({
+}: TransactionPlan<R>) =>
+	Effect.uninterruptibleMask((restore) => {
+		const lockPath = join(root, ".agency-graph-mutation.lock")
+		return Effect.acquireUseRelease(
+			Effect.tryPromise({
+				try: () => open(lockPath, "wx"),
+				catch: (cause) =>
+					new LifecycleTransactionError({
 						message:
-							"Lifecycle mutation completed, but transaction artifacts require manual cleanup",
-						completed: completed.map((step) => step.label),
-						rolledBack: [],
-						manualRecovery: completed.flatMap((step) =>
-							step.finalize && step.manualRecovery ? [step.manualRecovery] : [],
-						),
-						cause: new AggregateError(
-							cleanupFailures.map((result) =>
-								result.status === "rejected" ? result.reason : undefined,
-							),
-						),
-					})
-				}
-			} catch (cause) {
-				if (
-					cause instanceof LifecycleTransactionError ||
-					cause instanceof RevisionConflictError
-				)
-					throw cause
-				const rollbackErrors: unknown[] = []
-				for (const step of [...completed].reverse()) {
-					if (!step.rollback) continue
-					try {
-						await step.rollback()
-						rolledBack.push(step.label)
-						await step.finalize?.()
-					} catch (error) {
-						rollbackErrors.push(error)
-					}
-				}
-				const manualRecovery = completed
-					.filter(
-						(step) =>
-							!rolledBack.includes(step.label) &&
-							step.manualRecovery !== undefined,
-					)
-					.map((step) => step.manualRecovery!)
-				throw new LifecycleTransactionError({
-					message:
-						completed.length === 0
-							? `Lifecycle mutation failed before changes were applied: ${cause instanceof Error ? cause.message : String(cause)}`
-							: rollbackErrors.length
-								? `Lifecycle mutation failed and rollback requires manual recovery: ${cause instanceof Error ? cause.message : String(cause)}`
-								: `Lifecycle mutation failed; completed changes were rolled back: ${cause instanceof Error ? cause.message : String(cause)}`,
-					completed: completed.map((step) => step.label),
-					rolledBack,
-					manualRecovery,
-					cause: rollbackErrors.length
-						? new AggregateError([cause, ...rollbackErrors])
-						: cause,
-				})
-			} finally {
-				await lock.close().catch(() => undefined)
-				await rm(lockPath, { force: true }).catch(() => undefined)
-			}
-		},
-		catch: (cause) =>
-			cause instanceof LifecycleTransactionError ||
-			cause instanceof RevisionConflictError
-				? cause
-				: new LifecycleTransactionError({
-						message: "Lifecycle mutation failed before changes were applied",
+							"Another graph mutation is in progress; wait for it to finish and retry",
 						completed: [],
 						rolledBack: [],
 						manualRecovery: [],
 						cause,
 					}),
+			}),
+			() => {
+				const completed: TransactionStep<R>[] = []
+				const rolledBack: string[] = []
+				const execute = Effect.gen(function* () {
+					for (const precondition of preconditions) {
+						const content = yield* restore(
+							transactionEffect(() => Bun.file(precondition.path).text()),
+						)
+						const currentRevision = documentRevision(content as string)
+						if (currentRevision !== precondition.revision) {
+							return yield* new RevisionConflictError({
+								path: relative(root, precondition.path),
+								expectedRevision: precondition.revision,
+								currentRevision,
+								message: `Revision conflict for ${relative(root, precondition.path)}`,
+							})
+						}
+					}
+					for (const step of steps) {
+						if (step.preflight) yield* restore(step.preflight)
+					}
+					for (const step of steps) {
+						yield* restore(
+							Effect.uninterruptibleMask((restoreStep) =>
+								restoreStep(step.apply).pipe(
+									Effect.tap(() => Effect.sync(() => completed.push(step))),
+								),
+							),
+						)
+					}
+					const cleanup = yield* Effect.forEach(
+						completed,
+						(step) => Effect.exit(step.finalize ?? Effect.void),
+						{ concurrency: "unbounded" },
+					)
+					const cleanupFailures = cleanup.filter(Exit.isFailure)
+					if (cleanupFailures.length > 0) {
+						return yield* new LifecycleTransactionError({
+							message:
+								"Lifecycle mutation completed, but transaction artifacts require manual cleanup",
+							completed: completed.map((step) => step.label),
+							rolledBack: [],
+							manualRecovery: completed.flatMap((step) =>
+								step.finalize && step.manualRecovery
+									? [step.manualRecovery]
+									: [],
+							),
+							cause: new AggregateError(
+								cleanupFailures.map((result) => Cause.squash(result.cause)),
+							),
+						})
+					}
+				})
+
+				return execute.pipe(
+					Effect.catchAllCause((cause) =>
+						Effect.gen(function* () {
+							const failure = Option.getOrUndefined(Cause.failureOption(cause))
+							if (failure instanceof LifecycleTransactionError)
+								return yield* failure
+							const rollbackErrors: unknown[] = []
+							for (const step of [...completed].reverse()) {
+								if (!step.rollback) continue
+								const rollback = yield* Effect.exit(
+									step.rollback.pipe(
+										Effect.zipRight(step.finalize ?? Effect.void),
+									),
+								)
+								if (Exit.isSuccess(rollback)) {
+									rolledBack.push(step.label)
+								} else {
+									rollbackErrors.push(Cause.squash(rollback.cause))
+								}
+							}
+							if (Cause.isInterruptedOnly(cause))
+								return yield* Effect.failCause(cause as Cause.Cause<never>)
+							const manualRecovery = completed
+								.filter(
+									(step) =>
+										!rolledBack.includes(step.label) &&
+										step.manualRecovery !== undefined,
+								)
+								.map((step) => step.manualRecovery!)
+							if (failure instanceof RevisionConflictError)
+								return yield* failure
+							return yield* new LifecycleTransactionError({
+								message:
+									completed.length === 0
+										? `Lifecycle mutation failed before changes were applied: ${failure instanceof Error ? failure.message : String(failure)}`
+										: rollbackErrors.length
+											? `Lifecycle mutation failed and rollback requires manual recovery: ${failure instanceof Error ? failure.message : String(failure)}`
+											: `Lifecycle mutation failed; completed changes were rolled back: ${failure instanceof Error ? failure.message : String(failure)}`,
+								completed: completed.map((step) => step.label),
+								rolledBack,
+								manualRecovery,
+								cause: rollbackErrors.length
+									? new AggregateError([Cause.squash(cause), ...rollbackErrors])
+									: Cause.squash(cause),
+							})
+						}),
+					),
+				)
+			},
+			(lock) =>
+				Effect.promise(async () => {
+					await lock.close().catch(() => undefined)
+					await rm(lockPath, { force: true }).catch(() => undefined)
+				}),
+		)
 	})

package/src/services/PhaseService.ts

@@ -23,6 +23,7 @@ import { archivedPhaseDirectory } from "../workbase/archive"
 import {
 	documentWriteStep,
 	runLifecycleTransaction,
+	transactionEffect,
 	type TransactionStep,
 } from "./LifecycleTransaction"
 import { withWorktreeLocks } from "./WorktreeLock"
@@ -295,7 +296,7 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 							}
 							steps.push({
 								label: `move and repair code for ${taskId}/${firstPhaseId}`,
-								preflight: async () => {
+								preflight: transactionEffect(async () => {
 									for (const entry of await readdir(oldCodePath)) {
 										if (!checkoutAliases.includes(entry))
 											throw new Error(
@@ -339,8 +340,8 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 												`Cannot convert task '${taskId}'; checkout '${alias}' is not registered as a Git worktree`,
 											)
 									}
-								},
-								apply: async () => {
+								}),
+								apply: transactionEffect(async () => {
 									await mkdir(firstDirectory, { recursive: true })
 									await rename(oldCodePath, firstCodePath)
 									try {
@@ -351,12 +352,12 @@ export class PhaseService extends Effect.Service<PhaseService>()(
 										await rm(firstDirectory, { recursive: true, force: true })
 										throw cause
 									}
-								},
-								rollback: async () => {
+								}),
+								rollback: transactionEffect(async () => {
 									await rename(firstCodePath, oldCodePath)
 									await repair(oldCodePath)
 									await rm(firstDirectory, { recursive: true, force: true })
-								},
+								}),
 								manualRecovery: `Move ${firstCodePath} back to ${oldCodePath} and run git worktree repair`,
 							})
 						}