alchemy 2.0.0-beta.68 → 2.0.0-beta.69

package/bin/exec.js

@@ -1610,6 +1610,101 @@ const make = (stack, options$7 = {}) => Effect.gen(function* () {
 		stage: stage$1,
 		fqn
 	})), { concurrency: "unbounded" });
+	const persistedRows = new Map(resourceFqns.map((fqn, i) => [fqn, oldResources[i]]));
+	const formerFqnClaims = /* @__PURE__ */ new Map();
+	for (const resource of resources) for (const formerFqn of resource.FormerFqns ?? []) {
+		if (formerFqn === resource.FQN) continue;
+		const claimant = formerFqnClaims.get(formerFqn);
+		if (claimant !== void 0 && claimant !== resource.FQN) return yield* Effect.die(/* @__PURE__ */ new Error(`Resources '${claimant}' and '${resource.FQN}' both claim former FQN '${formerFqn}' via renamedFrom(...). A former FQN can migrate to exactly one resource — remove the decoration from one of them.`));
+		formerFqnClaims.set(formerFqn, resource.FQN);
+	}
+	const renameMigrations = /* @__PURE__ */ new Map();
+	const migratedRowFqns = /* @__PURE__ */ new Set();
+	const resolveRenamer = Effect.fn(function* (resource) {
+		const provider = Option.getOrUndefined(yield* tryFindProviderByType(resource.Type));
+		const allowedTypes = new Set([resource.Type, ...provider?.aliases ?? []]);
+		const persisted = persistedRows.get(resource.FQN);
+		const persistedRow = isActionState(persisted) ? void 0 : persisted;
+		const rowTaken = migratedRowFqns.has(resource.FQN);
+		const ownRow = !rowTaken && persistedRow !== void 0 && allowedTypes.has(persistedRow.resourceType) ? persistedRow : void 0;
+		let source = ownRow;
+		let adopted = ownRow;
+		const renamedFrom = [];
+		for (const formerFqn of resource.FormerFqns) {
+			if (formerFqnClaims.get(formerFqn) !== resource.FQN) continue;
+			if (renamedFrom.includes(formerFqn)) continue;
+			const formerPersisted = persistedRows.get(formerFqn);
+			if (formerPersisted === void 0 || isActionState(formerPersisted)) continue;
+			const formerRow = formerPersisted;
+			if (!allowedTypes.has(formerRow.resourceType)) continue;
+			if (source === void 0) {
+				source = formerRow;
+				adopted = {
+					...formerRow,
+					fqn: resource.FQN,
+					logicalId: resource.LogicalId,
+					namespace: resource.Namespace
+				};
+				renamedFrom.push(formerFqn);
+			} else if (source.instanceId === formerRow.instanceId) renamedFrom.push(formerFqn);
+		}
+		if (renamedFrom.length === 0) return;
+		if (persistedRow !== void 0 && ownRow === void 0 && !rowTaken) return yield* Effect.die(/* @__PURE__ */ new Error(`Cannot migrate '${renamedFrom[0]}' to '${resource.FQN}': a state row of a different type ('${persistedRow.resourceType}') already occupies '${resource.FQN}'. Migrating over it would silently abandon that row's cloud resource. Delete or rename the conflicting resource first, then re-deploy.`));
+		renameMigrations.set(resource.FQN, {
+			row: adopted,
+			renamedFrom,
+			moved: adopted !== ownRow
+		});
+		for (const formerFqn of renamedFrom) migratedRowFqns.add(formerFqn);
+	});
+	let pendingRenamers = resources.filter((r) => r.FormerFqns?.length);
+	const resolvedRenamers = /* @__PURE__ */ new Set();
+	while (pendingRenamers.length > 0) {
+		const ready = pendingRenamers.filter((resource) => {
+			const claimant = formerFqnClaims.get(resource.FQN);
+			return claimant === void 0 || resolvedRenamers.has(claimant);
+		});
+		if (ready.length === 0) return yield* Effect.die(/* @__PURE__ */ new Error(`Rename cycle detected among [${pendingRenamers.map((r) => `'${r.FQN}'`).join(", ")}]: their renamedFrom(...) declarations claim each other's FQNs. Swapping ids in one deploy is not supported — rename through a temporary id across two deploys instead.`));
+		for (const resource of ready) {
+			yield* resolveRenamer(resource);
+			resolvedRenamers.add(resource.FQN);
+		}
+		pendingRenamers = pendingRenamers.filter((r) => !resolvedRenamers.has(r.FQN));
+	}
+	/**
+	* Fetch the persisted row for a declared resource, resolving renames
+	* (see the pre-computed `renameMigrations` above):
+	*
+	* - a renamer plans from its migrated row (`renamedFrom` rides onto
+	*   the plan node; apply persists the move before any lifecycle op)
+	* - a resource declared at a former FQN whose row is migrating away
+	*   starts from scratch — the row is NOT its state, whatever the FQN
+	*   says
+	*/
+	const getPersistedRow = Effect.fn(function* (resource) {
+		const migration = renameMigrations.get(resource.FQN);
+		if (migration !== void 0) return {
+			row: migration.row,
+			renamedFrom: migration.renamedFrom,
+			renameMoved: migration.moved
+		};
+		const persisted = yield* state.get({
+			stack: stackName,
+			stage: stage$1,
+			fqn: resource.FQN
+		});
+		const row = isActionState(persisted) ? void 0 : persisted;
+		if (row !== void 0 && migratedRowFqns.has(resource.FQN)) return {
+			row: void 0,
+			renamedFrom: void 0,
+			renameMoved: false
+		};
+		return {
+			row,
+			renamedFrom: void 0,
+			renameMoved: false
+		};
+	});
 	const resolvedResources = {};
 	const resolveResource = (resourceExpr) => Effect.gen(function* () {
 		if (isAction(resourceExpr.src)) return resourceExpr;
@@ -1617,12 +1712,7 @@ const make = (stack, options$7 = {}) => Effect.gen(function* () {
 			const resource = resourceExpr.src;
 			const { provider, mode } = yield* resolveProviderAndMode(resource);
 			const props = materializeStableRefs(yield* resolveInput(resource.Props));
-			const persisted = yield* state.get({
-				stack: stackName,
-				stage: stage$1,
-				fqn: resource.FQN
-			});
-			const oldState = isActionState(persisted) ? void 0 : persisted;
+			const { row: oldState } = yield* getPersistedRow(resource);
 			if (!oldState || oldState.status === "creating") return resourceExpr;
 			if (hasModeSwitched(mode, oldState)) return resourceExpr;
 			const oldProps = oldState.status === "updating" ? oldState.old.props : oldState.props;
@@ -1789,14 +1879,11 @@ const make = (stack, options$7 = {}) => Effect.gen(function* () {
 		const downstream = newDownstreamDependencies[fqn] ?? [];
 		const applyBindings = dedupeBindings(yield* resolveInput(stack.bindings[fqn] ?? []));
 		const newBindings = materializeStableRefs(applyBindings);
-		const persisted = yield* state.get({
-			stack: stackName,
-			stage: stage$1,
-			fqn
-		});
-		let oldState = isActionState(persisted) ? void 0 : persisted;
+		const { row: persistedRow, renamedFrom, renameMoved } = yield* getPersistedRow(resource);
+		let oldState = persistedRow;
+		const reusesMigratedFqn = migratedRowFqns.has(fqn);
 		let forceUpdateAfterAdoption = false;
-		if (oldState === void 0 && provider.read && isResolved(news)) {
+		if (oldState === void 0 && provider.read && isResolved(news) && !reusesMigratedFqn) {
 			const adoptInstanceId = yield* generateInstanceId();
 			const readResult = yield* provider.read({
 				id,
@@ -1844,7 +1931,8 @@ const make = (stack, options$7 = {}) => Effect.gen(function* () {
 			resource,
 			bindings: bindingDiffs,
 			downstream,
-			mode
+			mode,
+			renamedFrom
 		});
 		if (oldState === void 0) return Node({
 			action: "create",
@@ -1888,7 +1976,7 @@ const make = (stack, options$7 = {}) => Effect.gen(function* () {
 			news,
 			oldBindings,
 			newBindings
-		}).pipe(providePlanScope(fqn, oldState.instanceId))).pipe(Effect.map((diff$1) => diff$1 ?? { action: havePropsChanged(oldProps, news) || bindingDiffs.some((b) => b.action !== "noop") ? "update" : "noop" }), Effect.map((diff$1) => options$7.force && diff$1.action === "noop" ? { action: "update" } : diff$1), Effect.map((diff$1) => forceUpdateAfterAdoption && diff$1.action === "noop" ? { action: "update" } : diff$1));
+		}).pipe(providePlanScope(fqn, oldState.instanceId))).pipe(Effect.map((diff$1) => diff$1 ?? { action: havePropsChanged(oldProps, news) || bindingDiffs.some((b) => b.action !== "noop") ? "update" : "noop" }), Effect.map((diff$1) => options$7.force && diff$1.action === "noop" ? { action: "update" } : diff$1), Effect.map((diff$1) => (forceUpdateAfterAdoption || renameMoved) && diff$1.action === "noop" ? { action: "update" } : diff$1));
 		if (oldState.status === "creating") if (diff.action === "noop") return Node({
 			action: "create",
 			props: applyProps,
@@ -2086,6 +2174,7 @@ const make = (stack, options$7 = {}) => Effect.gen(function* () {
 		if (isActionState(persisted)) return;
 		const oldState = persisted;
 		if (oldState) {
+			if (migratedRowFqns.has(fqn)) return;
 			const { logicalId } = parseFqn(fqn);
 			const resourceType = oldState.resourceType;
 			const providerOption = yield* tryFindProviderByType(resourceType, oldState.providerMode);
@@ -2107,6 +2196,7 @@ const make = (stack, options$7 = {}) => Effect.gen(function* () {
 					RemovalPolicy: oldState.removalPolicy,
 					Adopt: void 0,
 					Mode: oldState.providerMode,
+					FormerFqns: void 0,
 					RuntimeContext: void 0,
 					Providers: void 0
 				},
@@ -2208,6 +2298,23 @@ const apply = (plan) => Effect.gen(function* () {
 	const stackName = stack.name;
 	const tracker = {};
 	const terminalStatuses = /* @__PURE__ */ new Map();
+	const migrationTargets = new Set(Object.values(plan.resources).filter((node) => node.renamedFrom?.length && node.state !== void 0).map((node) => node.resource.FQN));
+	yield* Effect.forEach(Object.values(plan.resources), (node) => {
+		const { renamedFrom, state: row } = node;
+		return renamedFrom === void 0 || renamedFrom.length === 0 || row === void 0 ? Effect.void : Effect.gen(function* () {
+			yield* state.set({
+				stack: stackName,
+				stage: stage$1,
+				fqn: node.resource.FQN,
+				value: row
+			});
+			yield* Effect.forEach(renamedFrom.filter((formerFqn) => !migrationTargets.has(formerFqn)), (formerFqn) => state.delete({
+				stack: stackName,
+				stage: stage$1,
+				fqn: formerFqn
+			}), { concurrency: "unbounded" });
+		});
+	}, { concurrency: "unbounded" });
 	yield* executePlan(plan, tracker, terminalStatuses, session, state, stackName, stage$1);
 	yield* collectGarbage(plan, session);
 	yield* converge(plan, tracker, terminalStatuses, session, state, stackName, stage$1);
@@ -5523,7 +5630,8 @@ const formatPlanLines = (plan) => {
 			priorMode: item.action === "replace" ? item.state.providerMode : void 0,
 			defaultMode: plan.defaultMode
 		});
-		lines.push(`${tag(item.resource.LogicalId)} ${action}${mode}`);
+		const renamed = item.action !== "delete" && item.renamedFrom?.length ? ` ${dim(`(renamed from ${item.renamedFrom.join(", ")})`)}` : "";
+		lines.push(`${tag(item.resource.LogicalId)} ${action}${mode}${renamed}`);
 		for (const binding of item.bindings) {
 			if (binding.action === "noop") continue;
 			const bindingAction = actionColor$1[binding.action](binding.action);