alchemy 2.0.0-beta.28 → 2.0.0-beta.29

package/bin/exec.js

@@ -12,6 +12,7 @@ import * as Logger from "effect/Logger";
 import * as Option from "effect/Option";
 import * as Command from "effect/unstable/cli/Command";
 import * as Flag from "effect/unstable/cli/Flag";
+import * as Cause from "effect/Cause";
 import * as Deferred from "effect/Deferred";
 import * as Data from "effect/Data";
 import { pipe } from "effect/Function";
@@ -24,7 +25,6 @@ import os from "node:os";
 import * as Duration from "effect/Duration";
 import * as Exit from "effect/Exit";
 import * as Metric from "effect/Metric";
-import "effect/Cause";
 import * as Argument from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -645,6 +645,79 @@ const generateInstanceId = () => Effect.sync(() => {
 //#region lib/Util/types.js
 const asEffect = (effect) => Effect.isEffect(effect) ? effect : Effect.succeed(effect);
 
+//#endregion
+//#region lib/Util/scc.js
+/**
+* Compute the set of graph nodes that participate in a dependency cycle.
+*
+* A node is considered "in a cycle" iff it sits in a strongly-connected
+* component (SCC) of size > 1, or has a self-edge (size-1 SCC that loops
+* back to itself).
+*
+* Implementation is iterative Tarjan's algorithm to avoid blowing the JS
+* call stack on very wide graphs.
+*/
+const findCycleMembers = (edges) => {
+	const cycleMembers = /* @__PURE__ */ new Set();
+	let index = 0;
+	const indexOf = /* @__PURE__ */ new Map();
+	const lowlink = /* @__PURE__ */ new Map();
+	const onStack = /* @__PURE__ */ new Set();
+	const stack = [];
+	const callStack = [];
+	const startNode = (node) => {
+		indexOf.set(node, index);
+		lowlink.set(node, index);
+		index += 1;
+		stack.push(node);
+		onStack.add(node);
+		callStack.push({
+			node,
+			childIdx: 0
+		});
+	};
+	for (const root of Object.keys(edges)) {
+		if (indexOf.has(root)) continue;
+		startNode(root);
+		while (callStack.length > 0) {
+			const frame = callStack[callStack.length - 1];
+			const children = edges[frame.node] ?? [];
+			if (frame.childIdx < children.length) {
+				const child = children[frame.childIdx];
+				frame.childIdx += 1;
+				if (!indexOf.has(child)) {
+					startNode(child);
+					continue;
+				}
+				if (onStack.has(child)) lowlink.set(frame.node, Math.min(lowlink.get(frame.node), indexOf.get(child)));
+				continue;
+			}
+			if (lowlink.get(frame.node) === indexOf.get(frame.node)) {
+				const scc = [];
+				for (;;) {
+					const w = stack.pop();
+					onStack.delete(w);
+					scc.push(w);
+					if (w === frame.node) break;
+				}
+				if (scc.length > 1) for (const fqn of scc) cycleMembers.add(fqn);
+				else {
+					const only = scc[0];
+					if ((edges[only] ?? []).includes(only)) cycleMembers.add(only);
+				}
+			}
+			callStack.pop();
+			const parent = callStack[callStack.length - 1];
+			if (parent) {
+				const cur = lowlink.get(parent.node);
+				const childLow = lowlink.get(frame.node);
+				if (childLow < cur) lowlink.set(parent.node, childLow);
+			}
+		}
+	}
+	return cycleMembers;
+};
+
 //#endregion
 //#region lib/Plan.js
 const make = (stack, options = {}) => Effect.gen(function* () {
@@ -875,6 +948,7 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 			state: oldState
 		});
 	})), { concurrency: "unbounded" })).map((update) => [update.resource.FQN, update]));
+	const cycleMembers = findCycleMembers(allUpstreamDependencies);
 	{
 		const createReplaceNodes = new Set(Object.entries(resourceGraph).filter(([_, node]) => node.action === "create" || node.action === "replace").map(([fqn]) => fqn));
 		if (createReplaceNodes.size > 0) {
@@ -965,7 +1039,8 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 	return {
 		resources: resourceGraph,
 		deletions,
-		output: stack.output
+		output: stack.output,
+		cycleMembers
 	};
 }).pipe(ensureArtifactStore, Effect.withSpan("plan.make", { attributes: {
 	"alchemy.stack": stack.name,
@@ -1093,9 +1168,11 @@ const executePlan = Effect.fnUntraced(function* (plan, tracker, terminalStatuses
 	const ready = Object.fromEntries(yield* Effect.all(Object.keys(plan.resources).map((fqn) => Effect.map(Deferred.make(), (d) => [fqn, d]))));
 	const getOutputs = () => Object.fromEntries(Object.entries(tracker).map(([fqn, t]) => [fqn, t.output]));
 	const waitForDeps = (fqns) => Effect.all(fqns.filter((fqn) => fqn in ready).map((fqn) => Deferred.await(ready[fqn])), { concurrency: "unbounded" });
-	yield* Effect.all(Object.entries(plan.resources).map(([fqn, node]) => executeNode(fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps)), { concurrency: "unbounded" });
+	const failures = [];
+	yield* Effect.all(Object.entries(plan.resources).map(([fqn, node]) => executeNode(fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, plan.cycleMembers.has(fqn))), { concurrency: "unbounded" });
+	if (failures.length > 0) yield* Effect.failCause(failures.map((f) => f.cause).reduce(Cause.combine));
 });
-const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps) => Effect.gen(function* () {
+const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state, stackName, stage$1, getOutputs, waitForDeps, failures, inCycle) => Effect.gen(function* () {
 	const logicalId = node.resource.LogicalId;
 	const namespace = node.resource.Namespace;
 	const commit = (value) => state.set({
@@ -1272,7 +1349,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 			return;
 		}
 		if (node.action === "update") {
-			yield* storeAndSignal({
+			if (inCycle) yield* storeAndSignal({
 				output: node.state.attr,
 				props: node.state.props,
 				bindings: node.state.bindings ?? [],
@@ -1335,6 +1412,7 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 				bindings: bindingOutputs,
 				instanceId
 			};
+			yield* signalReady;
 			yield* markTerminal("updated");
 			return;
 		}
@@ -1445,7 +1523,21 @@ const executeNode = (fqn, node, tracker, ready, terminalStatuses, session, state
 		}
 		return yield* Effect.die(`Unknown action: ${node.action}`);
 	});
-}).pipe(Effect.withSpan("apply.resource", { attributes: {
+}).pipe(Effect.catchCause((cause) => Effect.gen(function* () {
+	failures.push({
+		fqn,
+		logicalId: node.resource.LogicalId,
+		type: node.resource.Type,
+		cause
+	});
+	yield* Deferred.failCause(ready[fqn], cause);
+	yield* session.emit({
+		kind: "status-change",
+		id: node.resource.LogicalId,
+		type: node.resource.Type,
+		status: "fail"
+	});
+})), Effect.withSpan("apply.resource", { attributes: {
 	"alchemy.resource.fqn": fqn,
 	"alchemy.resource.type": node.resource.Type,
 	"alchemy.resource.logical_id": node.resource.LogicalId,