@go-to-k/cdkd 0.219.7 → 0.219.8

package/dist/{deploy-engine-BWfGeCMs.js → deploy-engine-Bl8wyosc.js}

@@ -3763,6 +3763,22 @@ var TemplateParser = class {
 		return dependencies;
 	}
 	/**
+	* Extract resource references (Ref / Fn::GetAtt / Fn::Sub / Fn::Join /
+	* Fn::Select / Fn::Split) from an arbitrary template value.
+	*
+	* Public wrapper over the same recursive extraction `extractDependencies`
+	* uses for Properties — exposed so the diff phase can compute
+	* per-property reference edges (issue #807 replacement propagation)
+	* without duplicating the intrinsic walk. Unlike `extractDependencies`
+	* this does NOT include `DependsOn` (which is pure ordering, not a data
+	* reference — a replaced dependency carries no new value to propagate).
+	*/
+	extractReferences(value) {
+		const references = /* @__PURE__ */ new Set();
+		this.extractRefsFromValue(value, references);
+		return references;
+	}
+	/**
 	* Recursively extract Ref and Fn::GetAtt from a value
 	*/
 	extractRefsFromValue(value, dependencies) {
@@ -4585,6 +4601,7 @@ var ReplacementRulesRegistry = class {
 var DiffCalculator = class DiffCalculator {
 	logger = getLogger().child("DiffCalculator");
 	replacementRules = new ReplacementRulesRegistry();
+	parser = new TemplateParser();
 	/**
 	* Calculate changes needed to reach desired state
 	*
@@ -4674,11 +4691,103 @@ var DiffCalculator = class DiffCalculator {
 			});
 			this.logger.debug(`DELETE: ${logicalId} (${currentResource.resourceType})`);
 		}
+		this.promoteReplacementDependents(changes, desiredTemplate);
 		const summary = this.getSummary(changes);
 		this.logger.debug(`Diff calculated: ${summary.create} CREATE, ${summary.update} UPDATE, ${summary.delete} DELETE, ${summary.noChange} NO_CHANGE`);
 		return changes;
 	}
 	/**
+	* Promote transitive dependents of to-be-replaced resources from
+	* NO_CHANGE to UPDATE (issue #807).
+	*
+	* Diff-time intrinsic resolution runs against the CURRENT state, so a
+	* dependent referencing a resource that will be REPLACED (new physical
+	* ID — e.g. an `AWS::ECS::TaskDefinition` revision) compares equal and
+	* stays NO_CHANGE; the deploy engine then never re-points it at the new
+	* physical resource (for ECS: `UpdateService` is never issued and the
+	* service keeps running the old, now-deregistered revision).
+	* CloudFormation propagates the new physical ID to dependents — mirror
+	* that here by walking reverse reference edges (`Ref` / `Fn::GetAtt` /
+	* `Fn::Sub` and intrinsics nesting them — the same extraction the DAG
+	* builder uses) from every replacement-triggering UPDATE and promoting
+	* NO_CHANGE dependents to UPDATE.
+	*
+	* Promotion is safe even when speculative: the deploy engine re-resolves
+	* the promoted resource's properties against the in-flight state map
+	* (which the DAG guarantees already carries the dependency's new
+	* physical ID) and skips the provider call if nothing actually changed.
+	*
+	* Promotion is transitive: each referencing property of a promoted
+	* dependent is re-evaluated against the replacement rules, and if the
+	* dependent is itself replacement-triggering (the referencing property
+	* is immutable for its type), its own dependents are promoted in turn.
+	* The same re-evaluation also applies to dependents that already had
+	* their own (non-replacement) property changes — their referencing
+	* property gains a synthetic PropertyChange so a replacement cascade is
+	* not masked by an unrelated in-place change.
+	*/
+	promoteReplacementDependents(changes, desiredTemplate) {
+		const queue = [];
+		for (const [logicalId, change] of changes) if (change.changeType === "UPDATE" && change.propertyChanges?.some((pc) => pc.requiresReplacement)) queue.push(logicalId);
+		if (queue.length === 0) return;
+		const dependentsOf = /* @__PURE__ */ new Map();
+		for (const [logicalId, resource] of Object.entries(desiredTemplate.Resources)) {
+			if (resource.Type === "AWS::CDK::Metadata") continue;
+			for (const [propKey, propValue] of Object.entries(resource.Properties ?? {})) for (const referencedId of this.parser.extractReferences(propValue)) {
+				if (referencedId === logicalId) continue;
+				let dependents = dependentsOf.get(referencedId);
+				if (!dependents) {
+					dependents = /* @__PURE__ */ new Map();
+					dependentsOf.set(referencedId, dependents);
+				}
+				let propKeys = dependents.get(logicalId);
+				if (!propKeys) {
+					propKeys = /* @__PURE__ */ new Set();
+					dependents.set(logicalId, propKeys);
+				}
+				propKeys.add(propKey);
+			}
+		}
+		const enqueued = new Set(queue);
+		while (queue.length > 0) {
+			const replacedId = queue.shift();
+			const dependents = dependentsOf.get(replacedId);
+			if (!dependents) continue;
+			for (const [dependentId, refPropKeys] of dependents) {
+				const change = changes.get(dependentId);
+				if (!change) continue;
+				if (change.changeType !== "NO_CHANGE" && change.changeType !== "UPDATE") continue;
+				const existingPaths = new Set((change.propertyChanges ?? []).map((pc) => pc.path));
+				const syntheticChanges = [];
+				for (const propKey of refPropKeys) {
+					if (existingPaths.has(propKey)) continue;
+					const oldValue = change.currentProperties?.[propKey];
+					const newValue = change.desiredProperties?.[propKey];
+					syntheticChanges.push({
+						path: propKey,
+						oldValue,
+						newValue,
+						replacementPropagated: true,
+						requiresReplacement: this.replacementRules.requiresReplacement(change.resourceType, propKey, void 0, void 0)
+					});
+				}
+				if (syntheticChanges.length === 0) continue;
+				if (change.changeType === "NO_CHANGE") {
+					change.changeType = "UPDATE";
+					change.propertyChanges = syntheticChanges;
+					this.logger.debug(`UPDATE (promoted): ${dependentId} references replaced resource ${replacedId} via ${[...refPropKeys].join(", ")}`);
+				} else {
+					change.propertyChanges = [...change.propertyChanges ?? [], ...syntheticChanges];
+					this.logger.debug(`UPDATE (augmented): ${dependentId} references replaced resource ${replacedId} via ${[...refPropKeys].join(", ")}`);
+				}
+				if (!enqueued.has(dependentId) && change.propertyChanges.some((pc) => pc.requiresReplacement)) {
+					enqueued.add(dependentId);
+					queue.push(dependentId);
+				}
+			}
+		}
+	}
+	/**
 	* Best-effort resolution of template property intrinsics against current state.
 	*
 	* Iterates top-level properties and resolves each independently: if resolution
@@ -12379,4 +12488,4 @@ var DeployEngine = class {
 
 //#endregion
 export { WorkGraph as A, resolveCaptureObservedState as B, DagBuilder as C, shouldRetainResource as D, S3StateBackend as E, runDockerStreaming as F, CFN_TEMPLATE_BODY_LIMIT as G, resolveStateBucketWithDefault as H, Synthesizer as I, findLargeInlineResources as J, CFN_TEMPLATE_URL_LIMIT as K, getDefaultStateBucketName as L, formatDockerLoginError as M, getDockerCmd as N, AssetPublisher as O, runDockerForeground as P, resolveBucketRegion as Q, getLegacyStateBucketName as R, DiffCalculator as S, LockManager as T, resolveStateBucketWithDefaultAndSource as U, resolveSkipPrefix as V, warnDeprecatedNoPrefixCliFlag as W, AssemblyReader as X, uploadCfnTemplate as Y, clearBucketRegionCache as Z, ProviderRegistry as _, withRetry as a, IntrinsicFunctionResolver as b, formatResourceLine as c, gray as d, green as f, collectInlinePolicyNamesManagedBySiblings as g, IAMRoleProvider as h, withResourceDeadline as i, buildDockerImage as j, stringifyValue as k, bold as l, yellow as m, DEFAULT_RESOURCE_WARN_AFTER_MS as n, isRetryableTransientError as o, red as p, MIGRATE_TMP_PREFIX as q, DeployEngine as r, IMPLICIT_DELETE_DEPENDENCIES as s, DEFAULT_RESOURCE_TIMEOUT_MS as t, cyan as u, findActionableSilentDrops as v, TemplateParser as w, applyRoleArnIfSet as x, CloudControlProvider as y, resolveApp as z };
-//# sourceMappingURL=deploy-engine-BWfGeCMs.js.map
+//# sourceMappingURL=deploy-engine-Bl8wyosc.js.map