@go-to-k/cdkd 0.231.5 → 0.231.7

package/dist/cli.js

@@ -1445,7 +1445,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.231.5";
+	return "0.231.7";
 }
 /**
 * Generate a time-sortable unique run id, e.g.
@@ -10091,6 +10091,7 @@ var DynamoDBTableProvider = class {
 		this.logger.debug(`Updating DynamoDB table ${logicalId}: ${physicalId}`);
 		try {
 			const table = (await this.dynamoDBClient.send(new DescribeTableCommand({ TableName: physicalId }))).Table;
+			let latestStreamArn = table?.LatestStreamArn;
 			if (table?.TableArn) await this.applyTagDiff(table.TableArn, previousProperties["Tags"], properties["Tags"]);
 			const normalizeTableClass = (v) => typeof v === "string" && v.length > 0 ? v : "STANDARD";
 			const tableClassChanged = normalizeTableClass(properties["TableClass"]) !== normalizeTableClass(previousProperties["TableClass"]);
@@ -10140,6 +10141,46 @@ var DynamoDBTableProvider = class {
 					this.logger.debug(`Updated SSESpecification on DynamoDB table ${physicalId}`);
 				}
 			}
+			if (JSON.stringify(properties["StreamSpecification"]) !== JSON.stringify(previousProperties["StreamSpecification"])) {
+				const newViewType = this.extractStreamViewType(properties["StreamSpecification"]);
+				const prevViewType = this.extractStreamViewType(previousProperties["StreamSpecification"]);
+				if (newViewType && prevViewType && newViewType !== prevViewType) {
+					await this.dynamoDBClient.send(new UpdateTableCommand({
+						TableName: physicalId,
+						StreamSpecification: { StreamEnabled: false }
+					}));
+					await this.waitForTableActiveAfterUpdate(physicalId);
+					const reenable = await this.dynamoDBClient.send(new UpdateTableCommand({
+						TableName: physicalId,
+						StreamSpecification: {
+							StreamEnabled: true,
+							StreamViewType: newViewType
+						}
+					}));
+					await this.waitForTableActiveAfterUpdate(physicalId);
+					latestStreamArn = reenable.TableDescription?.LatestStreamArn ?? await this.describeLatestStreamArn(physicalId);
+					this.logger.debug(`Changed StreamViewType on DynamoDB table ${physicalId} to ${newViewType}`);
+				} else if (newViewType) {
+					const enable = await this.dynamoDBClient.send(new UpdateTableCommand({
+						TableName: physicalId,
+						StreamSpecification: {
+							StreamEnabled: true,
+							StreamViewType: newViewType
+						}
+					}));
+					await this.waitForTableActiveAfterUpdate(physicalId);
+					latestStreamArn = enable.TableDescription?.LatestStreamArn ?? await this.describeLatestStreamArn(physicalId);
+					this.logger.debug(`Enabled DynamoDB Stream on table ${physicalId} (${newViewType})`);
+				} else {
+					await this.dynamoDBClient.send(new UpdateTableCommand({
+						TableName: physicalId,
+						StreamSpecification: { StreamEnabled: false }
+					}));
+					await this.waitForTableActiveAfterUpdate(physicalId);
+					latestStreamArn = void 0;
+					this.logger.debug(`Disabled DynamoDB Stream on table ${physicalId}`);
+				}
+			}
 			if (JSON.stringify(properties["GlobalSecondaryIndexes"]) !== JSON.stringify(previousProperties["GlobalSecondaryIndexes"])) await this.applyGsiUpdates(physicalId, resourceType, logicalId, previousProperties["GlobalSecondaryIndexes"], properties["GlobalSecondaryIndexes"], properties["AttributeDefinitions"]);
 			if (JSON.stringify(properties["PointInTimeRecoverySpecification"]) !== JSON.stringify(previousProperties["PointInTimeRecoverySpecification"])) await this.applyPointInTimeRecovery(physicalId, properties["PointInTimeRecoverySpecification"], previousProperties["PointInTimeRecoverySpecification"]);
 			if (JSON.stringify(properties["TimeToLiveSpecification"]) !== JSON.stringify(previousProperties["TimeToLiveSpecification"])) {
@@ -10158,7 +10199,7 @@ var DynamoDBTableProvider = class {
 				attributes: {
 					Arn: table?.TableArn,
 					TableId: table?.TableId,
-					StreamArn: table?.LatestStreamArn,
+					StreamArn: latestStreamArn,
 					TableName: physicalId
 				}
 			};
@@ -10445,6 +10486,28 @@ var DynamoDBTableProvider = class {
 		return typeof arn === "string" ? arn : void 0;
 	}
 	/**
+	* Extract the `StreamViewType` from a CFn `StreamSpecification` block. Returns
+	* undefined when the spec is absent (no stream) — which is how update() tells
+	* an enable / disable apart from a view-type change. CDK always emits a
+	* StreamViewType when a stream is enabled (there is no valid enabled stream
+	* without one), so a present spec implies a present view type; defensively
+	* returns undefined for a malformed spec with no StreamViewType.
+	*/
+	extractStreamViewType(spec) {
+		if (spec === void 0 || spec === null) return void 0;
+		const viewType = spec["StreamViewType"];
+		return typeof viewType === "string" && viewType.length > 0 ? viewType : void 0;
+	}
+	/**
+	* Fetch the table's current `LatestStreamArn` via DescribeTable. Used as a
+	* fallback when an UpdateTable that enabled a stream did not echo the ARN
+	* back in its TableDescription, so `Fn::GetAtt [Table, StreamArn]` still
+	* resolves after an update-time enable.
+	*/
+	async describeLatestStreamArn(tableName) {
+		return (await this.dynamoDBClient.send(new DescribeTableCommand({ TableName: tableName }))).Table?.LatestStreamArn;
+	}
+	/**
 	* Apply the table's `ContributorInsightsSpecification` via the separate
 	* `UpdateContributorInsights` API (NOT a field on CreateTable). CFn shape is
 	* `{ Enabled: boolean, Mode?: 'ACCESSED_AND_THROTTLED_KEYS' | 'THROTTLED_KEYS' }`.
@@ -20068,9 +20131,9 @@ var StepFunctionsProvider = class {
 		this.logger.debug(`Updating Step Functions state machine ${logicalId}: ${physicalId}`);
 		try {
 			const definitionString = await this.buildDefinitionString(properties);
-			const encryptionConfiguration = mapEncryptionConfiguration(properties["EncryptionConfiguration"]);
-			const loggingConfiguration = mapLoggingConfiguration(properties["LoggingConfiguration"]);
-			const tracingConfiguration = mapTracingConfiguration(properties["TracingConfiguration"]);
+			const encryptionConfiguration = mapEncryptionConfiguration(properties["EncryptionConfiguration"]) ?? disabledEncryptionConfigurationOnRemoval(previousProperties["EncryptionConfiguration"], properties["EncryptionConfiguration"]);
+			const loggingConfiguration = mapLoggingConfiguration(properties["LoggingConfiguration"]) ?? disabledLoggingConfigurationOnRemoval(previousProperties["LoggingConfiguration"], properties["LoggingConfiguration"]);
+			const tracingConfiguration = mapTracingConfiguration(properties["TracingConfiguration"]) ?? disabledTracingConfigurationOnRemoval(previousProperties["TracingConfiguration"], properties["TracingConfiguration"]);
 			await this.getClient().send(new UpdateStateMachineCommand({
 				stateMachineArn: physicalId,
 				definition: definitionString,
@@ -20394,6 +20457,59 @@ function mapTracingConfiguration(value) {
 	if (cfg["Enabled"] === void 0) return void 0;
 	return { enabled: cfg["Enabled"] };
 }
+/**
+* Return the SDK disable payload for `EncryptionConfiguration` when it was
+* present+configured in the previous properties but is absent/placeholder in
+* the new ones; otherwise `undefined` (no clear needed). `AWS_OWNED_KEY` is
+* the AWS default, so this resets a customer-managed-key config back to default.
+*/
+function disabledEncryptionConfigurationOnRemoval(previous, next) {
+	if (!wasMeaningfullyConfigured(previous, "Type")) return void 0;
+	if (mapEncryptionConfiguration(next) !== void 0) return void 0;
+	return { type: "AWS_OWNED_KEY" };
+}
+/**
+* Return the SDK disable payload for `LoggingConfiguration` when it was
+* present+configured in the previous properties but is absent/placeholder in
+* the new ones; otherwise `undefined`. `level: OFF` disables logging;
+* `destinations: []` clears the log destinations (only required when level is
+* not OFF, so an empty list is accepted alongside OFF).
+*/
+function disabledLoggingConfigurationOnRemoval(previous, next) {
+	if (!wasMeaningfullyConfigured(previous, "Level")) return void 0;
+	if (mapLoggingConfiguration(next) !== void 0) return void 0;
+	return {
+		level: "OFF",
+		includeExecutionData: false,
+		destinations: []
+	};
+}
+/**
+* Return the SDK disable payload for `TracingConfiguration` when it was
+* present+enabled in the previous properties but is absent/placeholder in the
+* new ones; otherwise `undefined`. `enabled: false` turns X-Ray tracing off.
+*
+* Unlike logging/encryption, the "meaningful" signal here is `Enabled === true`
+* (a previous `{ Enabled: false }` is already the AWS default, so there is
+* nothing to clear).
+*/
+function disabledTracingConfigurationOnRemoval(previous, next) {
+	if (previous === null || typeof previous !== "object") return void 0;
+	if (previous["Enabled"] !== true) return void 0;
+	if (mapTracingConfiguration(next) !== void 0) return void 0;
+	return { enabled: false };
+}
+/**
+* True when `value` is an object that carries a defined `discriminatorKey`
+* field (`Level` for logging, `Type` for encryption) — i.e. it was a real,
+* non-placeholder config in the previous properties. The empty-placeholder
+* shape `{}` that `readCurrentState` emits has no discriminator, so it returns
+* false and no clear is emitted.
+*/
+function wasMeaningfullyConfigured(value, discriminatorKey) {
+	if (value === null || typeof value !== "object") return false;
+	return value[discriminatorKey] !== void 0;
+}
 
 //#endregion
 //#region src/provisioning/providers/ecs-provider.ts
@@ -55531,7 +55647,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.231.5");
+	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.231.7");
 	program.addCommand(createBootstrapCommand());
 	program.addCommand(createSynthCommand());
 	program.addCommand(createListCommand());