@go-to-k/cdkd 0.221.4 → 0.221.6

package/dist/cli.js

@@ -1553,7 +1553,7 @@ const FLUSH_INTERVAL_MS = 2e3;
 const FLUSH_EVENT_THRESHOLD = 50;
 /** Build-time cdkd version, with a dev fallback for non-built contexts. */
 function getCdkdVersion() {
-	return "0.221.4";
+	return "0.221.6";
 }
 /**
 * Generate a time-sortable unique run id, e.g.
@@ -6101,6 +6101,43 @@ function serializeRedriveAllowPolicy(value) {
 	return JSON.stringify(value);
 }
 /**
+* Reset value for a CDK-managed SQS attribute that was set on a previous
+* deploy but is ABSENT from the desired properties on an in-place UPDATE
+* (e.g. its `Fn::If` branch resolved to `AWS::NoValue`, so the resolved
+* desired properties no longer carry the key).
+*
+* cdkd's diff layer correctly classifies a property present in current
+* state but absent from the desired template as a change, but the provider
+* `update()` loop only acts on keys PRESENT in the new properties — so
+* without an explicit reset the stale value lingers on AWS (the
+* `conditions-update-2` integ exercises exactly this for `RedrivePolicy`).
+*
+* CloudFormation resets a removed property to the attribute's default. We
+* mirror that here:
+*   - The JSON policy attributes (`RedrivePolicy` / `RedriveAllowPolicy`)
+*     are cleared with the empty string the SQS API documents for removal.
+*   - `KmsMasterKeyId` is cleared with the empty string (removes a custom
+*     CMK; SQS falls back to its own default encryption behavior).
+*   - Numeric attributes reset to their documented `SetQueueAttributes`
+*     defaults (see the SQS API reference).
+*
+* Attributes NOT in this map (immutable / FIFO-discriminated ones such as
+* `FifoQueue` / `DeduplicationScope` / `FifoThroughputLimit`) are never
+* reset on removal — flipping them would either be rejected by AWS or
+* require a replacement, which the diff layer handles separately.
+*/
+const SQS_ATTRIBUTE_REMOVAL_RESET = {
+	RedrivePolicy: "",
+	RedriveAllowPolicy: "",
+	KmsMasterKeyId: "",
+	VisibilityTimeout: "30",
+	MaximumMessageSize: "262144",
+	MessageRetentionPeriod: "345600",
+	DelaySeconds: "0",
+	ReceiveMessageWaitTimeSeconds: "0",
+	KmsDataKeyReusePeriodSeconds: "300"
+};
+/**
 * CDK property name to SQS attribute name mapping
 */
 const CDK_TO_SQS_ATTRIBUTES = {
@@ -6207,7 +6244,7 @@ var SQSQueueProvider = class {
 					if (cdkKey === "RedrivePolicy" && typeof value === "object") attributes[sqsKey] = serializeRedrivePolicy(value);
 					else if (cdkKey === "RedriveAllowPolicy") attributes[sqsKey] = serializeRedriveAllowPolicy(value);
 					else attributes[sqsKey] = stringifyValue(value);
-				}
+				} else if (previousProperties[cdkKey] !== void 0 && cdkKey in SQS_ATTRIBUTE_REMOVAL_RESET) attributes[sqsKey] = SQS_ATTRIBUTE_REMOVAL_RESET[cdkKey];
 			}
 			if (Object.keys(attributes).length > 0) {
 				await this.sqsClient.send(new SetQueueAttributesCommand({
@@ -36843,17 +36880,55 @@ async function loadStateOrEmpty(stackName, region, stateBackend) {
 * Pure with respect to AWS state mutation — only reads state (the resolver
 * may read producer state for `Fn::ImportValue` / `Fn::GetStackOutput`).
 */
-async function computeStackDiff(currentState, template, region, stackName, stateBackend, diffCalculator) {
+async function computeStackDiff(currentState, template, region, stackName, stateBackend, diffCalculator, parameters) {
 	const intrinsicResolver = new IntrinsicFunctionResolver(region);
 	const resolveFn = (value) => intrinsicResolver.resolve(value, {
 		template,
 		resources: currentState.resources,
 		stateBackend,
-		stackName
+		stackName,
+		...parameters && { parameters }
 	});
 	return diffCalculator.calculateDiff(currentState, template, resolveFn);
 }
 /**
+* Resolve a nested-stack child's input `Parameters` (declared on the parent's
+* `AWS::CloudFormation::Stack` row under `Properties.Parameters`) to scalar
+* values against the PARENT's deployed state + already-resolved parameters.
+*
+* This is the diff-time analogue of `NestedStackProvider.extractParameters`:
+* the deploy engine resolves these same `Parameters` against the parent's
+* resolver context and forwards the scalar map to the child engine as
+* `DeployEngineOptions.parameters`, so a `Ref` to a child input parameter
+* resolves at deploy time. The recursive diff must do the same or it reports
+* spurious changes on every freshly-deployed nested child whose property
+* derives from a passed-down parameter.
+*
+* Each value is resolved independently and best-effort: a value that cannot
+* be resolved (e.g. a `Ref` to a resource not yet in state) is dropped from
+* the map rather than forwarded as a raw intrinsic — leaving it out means the
+* child's `Ref` to that parameter falls through to the existing
+* intrinsic-vs-resolved comparison path (no behavior change for the
+* unresolvable case), while resolvable parameters (the freshly-deployed tree)
+* get exact scalar values.
+*/
+async function resolveChildStackParameters(parentStackRow, parentTemplate, parentState, region, parentStackName, stateBackend, parentParameters) {
+	const rawParams = parentStackRow.Properties?.["Parameters"];
+	if (!rawParams || typeof rawParams !== "object" || Array.isArray(rawParams)) return {};
+	const resolver = new IntrinsicFunctionResolver(region);
+	const resolved = {};
+	for (const [name, value] of Object.entries(rawParams)) try {
+		resolved[name] = await resolver.resolve(value, {
+			template: parentTemplate,
+			resources: parentState.resources,
+			stateBackend,
+			stackName: parentStackName,
+			...parentParameters && { parameters: parentParameters }
+		});
+	} catch {}
+	return resolved;
+}
+/**
 * Build the diff tree for one stack and (when `recursive`) every nested
 * `AWS::CloudFormation::Stack` descendant.
 *
@@ -36874,13 +36949,13 @@ async function computeStackDiff(currentState, template, region, stackName, state
 * fail at deploy time.
 */
 async function buildDiffTree(args) {
-	const { stackName, displayName, region, template, nestedTemplates, recursive, stateBackend, diffCalculator } = args;
+	const { stackName, displayName, region, template, nestedTemplates, recursive, stateBackend, diffCalculator, parameters } = args;
 	const state = await loadStateOrEmpty(stackName, region, stateBackend);
 	const node = {
 		stackName,
 		displayName,
 		region,
-		changes: await computeStackDiff(state, template, region, stackName, stateBackend, diffCalculator),
+		changes: await computeStackDiff(state, template, region, stackName, stateBackend, diffCalculator, parameters),
 		ccApiRoutes: collectCcApiRoutes(template, state),
 		children: []
 	};
@@ -36894,6 +36969,7 @@ async function buildDiffTree(args) {
 		const childStackName = `${stackName}~${logicalId}`;
 		const childTemplate = readNestedTemplate(childTemplatePath);
 		const grandchildTemplates = indexNestedChildTemplates(childTemplate, childTemplatePath);
+		const childParameters = await resolveChildStackParameters(resource, template, state, region, stackName, stateBackend, parameters);
 		node.children.push(await buildDiffTree({
 			stackName: childStackName,
 			displayName: childStackName,
@@ -36902,7 +36978,8 @@ async function buildDiffTree(args) {
 			nestedTemplates: grandchildTemplates,
 			recursive: true,
 			stateBackend,
-			diffCalculator
+			diffCalculator,
+			parameters: childParameters
 		}));
 	}
 	for (const [logicalId, resource] of Object.entries(state.resources)) {
@@ -53802,7 +53879,7 @@ function reorderArgs(argv) {
 async function main() {
 	installPipeCloseHandler();
 	const program = new Command();
-	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.221.4");
+	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.221.6");
 	program.addCommand(createBootstrapCommand());
 	program.addCommand(createSynthCommand());
 	program.addCommand(createListCommand());