@go-to-k/cdkd 0.276.0 → 0.276.2

package/dist/{deploy-engine-j0TmnJYJ.js → deploy-engine-CwVBPKqE.js}

@@ -7715,6 +7715,24 @@ var ReplacementRulesRegistry = class {
 			"KeyName",
 			"NetworkInterfaces"
 		]) });
+		this.rules.set("AWS::EC2::Volume", {
+			replacementProperties: /* @__PURE__ */ new Set([
+				"AvailabilityZone",
+				"AvailabilityZoneId",
+				"Encrypted",
+				"KmsKeyId",
+				"OutpostArn",
+				"SnapshotId"
+			]),
+			updateableProperties: /* @__PURE__ */ new Set([
+				"AutoEnableIO",
+				"Iops",
+				"Size",
+				"Throughput",
+				"VolumeType",
+				"Tags"
+			])
+		});
 		this.rules.set("AWS::ECS::TaskDefinition", { replacementProperties: /* @__PURE__ */ new Set([
 			"Family",
 			"ContainerDefinitions",
@@ -12072,7 +12090,7 @@ var CloudControlProvider = class {
 		if (context?.finalSnapshotIdentifier !== void 0) throw new ProvisioningError(`${logicalId} (${resourceType}) requires a final snapshot (DeletionPolicy: Snapshot), but the Cloud Control API delete route has no final-snapshot parameter. Re-run with --skip-final-snapshot after snapshotting manually, or retain the resource.`, resourceType, logicalId, physicalId);
 		if (context?.removeProtection === true && resourceType === "AWS::AutoScaling::AutoScalingGroup") {
 			this.logger.debug(`Delegating protected AutoScalingGroup ${logicalId} delete to the SDK ASGProvider (Cloud Control cannot force-delete a protected ASG)`);
-			const { ASGProvider } = await import("./asg-provider-DeLTuWlm.js").then((n) => n.n);
+			const { ASGProvider } = await import("./asg-provider-X-k9FXgs.js").then((n) => n.n);
 			await new ASGProvider().delete(logicalId, physicalId, resourceType, _properties, context);
 			return;
 		}
@@ -16787,6 +16805,7 @@ const STATEFUL_TYPES = /* @__PURE__ */ new Set([
 	"AWS::FSx::FileSystem",
 	"AWS::S3::Bucket",
 	"AWS::ECR::Repository",
+	"AWS::EC2::Volume",
 	"AWS::Kinesis::Stream",
 	"AWS::Elasticsearch::Domain",
 	"AWS::OpenSearchService::Domain",
@@ -17733,24 +17752,73 @@ async function withResourceDeadline(operation, opts) {
 
 //#endregion
 //#region src/deployment/rollback-executor.ts
+/** The `--skip-final-snapshot` flag name cited by every refusal below. */
+const SKIP_FINAL_SNAPSHOT_FLAG = "--skip-final-snapshot";
+/**
+* Which provisioning layer a delete must be judged against: the CURRENT
+* state record wins (it is what state says AWS holds right now), with the
+* journaled op's routing as the legacy-state fallback. Shared by both
+* Snapshot paths below so the cc-api test cannot drift between them.
+*/
+function effectiveProvisionedBy(record, fallbackProvisionedBy) {
+	return record?.provisionedBy ?? fallbackProvisionedBy;
+}
 /**
 * `UpdateReplacePolicy: Snapshot` on a rollback's delete-of-the-NEW-resource
 * (issue #1354): honor it where it costs nothing — an atomic-final-snapshot
 * type on the SDK route gets a generated identifier threaded into the delete
 * context. Every other Snapshot shape (pre-delete types, cc-api routing)
 * keeps the plain delete DELIBERATELY: the rollback executor's delete-new is
-* load-bearing for same-name re-creation (orphaning would break the revert),
-* it has no snapshot-client plumbing by design (registry + region only), and
-* the new resource was created by the deploy being reverted. Recorded as a
-* scope decision on issue #1354.
+* load-bearing for same-name re-creation (refusing it would strand the
+* revert half-done), and the new resource was created by the very deploy
+* being reverted. Recorded as a scope decision on issue #1354.
+*
+* NOT the same call as the rolled-back-CREATE path
+* ({@link prepareCreateRollbackFinalSnapshot}, issue #1358): there the
+* resource is being deleted under `DeletionPolicy` and a shape cdkd cannot
+* snapshot is REFUSED rather than plain-deleted, because the user is losing
+* a resource that existed before this op — nothing downstream depends on
+* that delete succeeding.
 */
 function rollbackFinalSnapshotId(resourceType, record, fallbackProvisionedBy) {
 	if (record.updateReplacePolicy !== "Snapshot") return void 0;
 	if (!ATOMIC_FINAL_SNAPSHOT_TYPES.has(resourceType)) return void 0;
-	if ((record.provisionedBy ?? fallbackProvisionedBy) === "cc-api") return void 0;
+	if (effectiveProvisionedBy(record, fallbackProvisionedBy) === "cc-api") return void 0;
 	return buildFinalSnapshotIdentifier(record.physicalId, resourceType);
 }
 /**
+* `DeletionPolicy: Snapshot` on a rolled-back CREATE (issue #1358) — the
+* executor's copy of the deploy engine's `prepareFinalSnapshotForDelete`
+* mechanism matrix, run BEFORE the delete:
+*
+*   - atomic type, SDK-routed → returns the generated identifier for the
+*     provider's atomic final-snapshot delete parameter.
+*   - atomic type, cc-api-routed → refuses (Cloud Control's DeleteResource
+*     has no final-snapshot parameter; `CloudControlProvider.delete` also
+*     fail-closes on the context field as defense-in-depth).
+*   - `PRE_DELETE_SNAPSHOT_TYPES` → creates the snapshot and waits for it
+*     here, then returns undefined (the subsequent delete is plain).
+*   - anything else Snapshot-tagged → refuses.
+*
+* Refusals are plain throws so `replaySingle`'s per-op catch counts them as
+* a failure (which blocks the segment pop and keeps the journal for a
+* re-run) — deliberately NOT a silent fall-back to orphaning, which is the
+* very leak #1358 fixes.
+*/
+async function prepareCreateRollbackFinalSnapshot(op, provisionedBy, ctx) {
+	const { logicalId, resourceType } = op;
+	const physicalId = op.physicalId;
+	if (ATOMIC_FINAL_SNAPSHOT_TYPES.has(resourceType)) {
+		if (provisionedBy === "cc-api") throw ccRoutedFinalSnapshotError(logicalId, resourceType, SKIP_FINAL_SNAPSHOT_FLAG);
+		return buildFinalSnapshotIdentifier(physicalId, resourceType);
+	}
+	if (PRE_DELETE_SNAPSHOT_TYPES.has(resourceType)) {
+		await createPreDeleteFinalSnapshot(resourceType, physicalId, logicalId, ctx.finalSnapshotClients ?? getAwsClients(), ctx.logger);
+		return;
+	}
+	throw unsupportedFinalSnapshotError(logicalId, resourceType, SKIP_FINAL_SNAPSHOT_FLAG);
+}
+/**
 * Retry schedule for a re-create that must wait out a name-release delay:
 * an async delete's late name release ("already exists") or the SQS 60s
 * same-name cooldown (issue #1206). 2s/4s/8s then capped at 10s over 8
@@ -17803,7 +17871,8 @@ function classifyRollbackOp(op, stateResources, orphanLogicalIds) {
 		if (!current) return "skip-already-done";
 		if (op.physicalId !== void 0 && current.physicalId !== op.physicalId) return "skip-mismatch";
 		const policy = current.deletionPolicy;
-		if (policy === "Retain" || policy === "Snapshot") return "orphan-retain";
+		if (policy === "Retain") return "orphan-retain";
+		if (policy === "Snapshot") return "delete-with-final-snapshot";
 		return "delete";
 	}
 	const current = stateResources[op.logicalId];
@@ -17957,7 +18026,7 @@ async function replaySingle(op, stateResources, stackName, ctx, orphanLogicalIds
 				return;
 			case "orphan-retain":
 				delete stateResources[op.logicalId];
-				logger.info(`  Rollback: Leaving ${op.logicalId} (${op.resourceType}) in AWS (DeletionPolicy: ${stateResourcesPolicyLabel(op, stateResources)}) — removed from state`);
+				logger.info(`  Rollback: Leaving ${op.logicalId} (${op.resourceType}) in AWS (DeletionPolicy: Retain) — removed from state`);
 				await afterOp?.(op.logicalId);
 				ctx.recordEvent?.({
 					eventType: "ROLLBACK_RESOURCE_SUCCEEDED",
@@ -17968,18 +18037,27 @@ async function replaySingle(op, stateResources, stackName, ctx, orphanLogicalIds
 					...op.provisionedBy && { provisionedBy: op.provisionedBy }
 				});
 				return;
-			case "delete": {
+			case "delete":
+			case "delete-with-final-snapshot": {
 				if (!op.physicalId) {
 					logger.warn(`  Rollback: Cannot delete ${op.logicalId} — no physical ID recorded`);
 					result.warnings++;
 					return;
 				}
-				logger.info(`  Rollback: Deleting created resource ${op.logicalId} (${op.resourceType})`);
+				const deleteProvisionedBy = effectiveProvisionedBy(stateResources[op.logicalId], op.provisionedBy);
+				const snapshotPolicy = action === "delete-with-final-snapshot";
+				const takeFinalSnapshot = snapshotPolicy && ctx.skipFinalSnapshot !== true;
+				let finalSnapshotIdentifier;
+				if (takeFinalSnapshot) finalSnapshotIdentifier = await prepareCreateRollbackFinalSnapshot(op, deleteProvisionedBy, ctx);
+				logger.info(`  Rollback: Deleting created resource ${op.logicalId} (${op.resourceType})` + (takeFinalSnapshot ? " — DeletionPolicy: Snapshot" : "") + (snapshotPolicy && !takeFinalSnapshot ? " — DeletionPolicy: Snapshot NOT taken (--skip-final-snapshot)" : ""));
 				const { provider } = ctx.providerRegistry.getProviderFor({
 					resourceType: op.resourceType,
-					provisionedBy: op.provisionedBy
+					provisionedBy: deleteProvisionedBy
+				});
+				await provider.delete(op.logicalId, op.physicalId, op.resourceType, op.properties, {
+					expectedRegion: ctx.region,
+					...finalSnapshotIdentifier !== void 0 && { finalSnapshotIdentifier }
 				});
-				await provider.delete(op.logicalId, op.physicalId, op.resourceType, op.properties, { expectedRegion: ctx.region });
 				delete stateResources[op.logicalId];
 				logger.info(`  Rollback: ${op.logicalId} deleted successfully`);
 				await afterOp?.(op.logicalId);
@@ -18262,9 +18340,6 @@ async function replayFailedOperations(failedOps, stateResources, stackName, ctx,
 	result.remainingFailedOps = failedOps.filter((op) => pending.has(op));
 	return result;
 }
-function stateResourcesPolicyLabel(op, stateResources) {
-	return stateResources[op.logicalId]?.deletionPolicy ?? "Retain";
-}
 /**
 * Sort CREATE rollback operations so that resources depending on others are
 * deleted first (reverse dependency order), using state dependencies. Same
@@ -18354,7 +18429,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.276.0";
+	return "0.276.2";
 }
 /**
 * Generate a time-sortable unique run id, e.g.
@@ -19746,7 +19821,9 @@ var DeployEngine = class {
 			providerRegistry: this.providerRegistry,
 			region: this.stackRegion,
 			logger: this.logger,
-			recordEvent: (event) => this.recordEvent(event)
+			recordEvent: (event) => this.recordEvent(event),
+			finalSnapshotClients: this.options.finalSnapshotClients,
+			skipFinalSnapshot: this.options.skipFinalSnapshot
 		};
 	}
 	/**
@@ -20464,4 +20541,4 @@ var DeployEngine = class {
 
 //#endregion
 export { TemplateParser as $, CdkdError as $t, yellow as A, resolveAutoAssetStorage as At, IntrinsicFunctionResolver as B, MIGRATE_TMP_PREFIX as Bt, renderStatefulReason as C, AssetManifestLoader as Ct, gray as D, getDefaultStateBucketName as Dt, cyan as E, synthesisStatusMessage as Et, findActionableSilentDrops as F, resolveUseCdkBootstrapAssets as Ft, resolveExplicitPhysicalId as G, processStackMessages as Gt, refStateLookupFromResource as H, uploadCfnTemplate as Ht, CloudControlProvider as I, stateBucketExistenceConfirmed as It, DiffCalculator as J, AwsClients as Jt, assertRegionMatch as K, clearBucketRegionCache as Kt, slowCcOperationTimeoutMs as L, warnDeprecatedNoPrefixCliFlag as Lt, collectInlinePolicyNamesManagedBySiblings as M, resolveSkipPrefix as Mt, clearOnUpdateRemoval as N, resolveStateBucketWithDefault as Nt, green as O, getLegacyStateBucketName as Ot, ProviderRegistry as P, resolveStateBucketWithDefaultAndSource as Pt, DagBuilder as Q, AssetError as Qt, disableInstanceApiTermination as R, CFN_TEMPLATE_BODY_LIMIT as Rt, isStatefulRecreateTargetSync as S, runDockerStreaming as St, bold as T, Synthesizer as Tt, WAFv2WebACLProvider as U, expectedOwnerParam as Ut, cfnRefValueFromPhysicalId as V, findLargeInlineResources as Vt, normalizeAwsTagsToCfn as W, AssemblyReader as Wt, withRetry as X, resetAwsClients as Xt, describeTypeWithThrottleRetry as Y, getAwsClients as Yt, isRetryableTransientError as Z, setAwsClients as Zt, createPreDeleteFinalSnapshot as _, formatError as _n, validateContainerRepoName as _t, DeploymentEventsStore as a, LocalStartServiceError as an, stringifyValue as at, extractDeploymentEventError as b, withErrorHandling as bn, getDockerCmd as bt, replayFailedOperations as c, NestedStackChildDirectDestroyError as cn, createAssetRedirectResolver as ct, IMPLICIT_DELETE_DEPENDENCIES as d, ResourceTimeoutError as dn, AssetModeResolver as dt, ConfigError as en, LockManager as et, computeImplicitDeleteEdges as f, ResourceUpdateNotSupportedError as fn, BOOTSTRAP_MARKER_PREFIX as ft, ccRoutedFinalSnapshotError as g, SynthesisError as gn, validateAssetBucketName as gt, buildFinalSnapshotIdentifier as h, StateError as hn, parseBootstrapMarker as ht, DeploymentEventsReader as i, LocalMigrateError as in, AssetPublisher as it, IAMRoleProvider as j, resolveCaptureObservedState as jt, red as k, resolveApp as kt, replayRollback as l, PartialFailureError as ln, loadPublishableAssetManifest as lt, PRE_DELETE_SNAPSHOT_TYPES as m, StackTerminationProtectionError as mn, getBootstrapMarkerKey as mt, DEFAULT_RESOURCE_WARN_AFTER_MS as n, DeployCancelledError as nn, rebuildClientForBucketRegion as nt, planFailedOps as o, LockError as on, WorkGraph as ot, ATOMIC_FINAL_SNAPSHOT_TYPES as p, StackHasActiveImportsError as pn, ensureAssetStorage as pt, applyRoleArnIfSet as q, resolveBucketRegion as qt, DeployEngine as r, LocalInvokeBuildError as rn, shouldRetainResource as rt, planRollback as s, MissingCdkCliError as sn, buildAssetRedirectMap as st, DEFAULT_RESOURCE_TIMEOUT_MS as t, DependencyError as tn, S3StateBackend as tt, withResourceDeadline as u, ProvisioningError as un, rewriteTemplateAssetReferences as ut, isFinalSnapshotError as v, isCdkdError as vn, buildDockerImage as vt, formatResourceLine as w, getDockerImageBySourceHash as wt, MULTI_REGION_RECREATE_BLOCKED_TYPES as x, __exportAll as xn, runDockerForeground as xt, unsupportedFinalSnapshotError as y, normalizeAwsError as yn, formatDockerLoginError as yt, isTerminationProtectionPropagationError as z, CFN_TEMPLATE_URL_LIMIT as zt };
-//# sourceMappingURL=deploy-engine-j0TmnJYJ.js.map
+//# sourceMappingURL=deploy-engine-CwVBPKqE.js.map