@go-to-k/cdkd 0.108.0 → 0.109.1

package/dist/cli.js

@@ -35,7 +35,7 @@ import { Command, Option } from "commander";
 import { writeFileSync as writeFileSync$1 } from "fs";
 import { join as join$1 } from "path";
 import * as zlib from "node:zlib";
-import { ApplicationAutoScalingClient, DescribeScalableTargetsCommand, DescribeScalingPoliciesCommand } from "@aws-sdk/client-application-auto-scaling";
+import { ApplicationAutoScalingClient, DeleteScalingPolicyCommand, DeregisterScalableTargetCommand, DescribeScalableTargetsCommand, DescribeScalingPoliciesCommand, PutScalingPolicyCommand, RegisterScalableTargetCommand } from "@aws-sdk/client-application-auto-scaling";
 import { ApiGatewayV2Client, CreateApiCommand, CreateAuthorizerCommand as CreateAuthorizerCommand$1, CreateIntegrationCommand, CreateRouteCommand as CreateRouteCommand$1, CreateStageCommand as CreateStageCommand$1, DeleteApiCommand, DeleteAuthorizerCommand as DeleteAuthorizerCommand$1, DeleteIntegrationCommand, DeleteRouteCommand as DeleteRouteCommand$1, DeleteStageCommand as DeleteStageCommand$1, GetApiCommand, GetApisCommand, GetAuthorizerCommand as GetAuthorizerCommand$1, GetIntegrationCommand, GetRouteCommand, GetStageCommand as GetStageCommand$1, NotFoundException as NotFoundException$3, UpdateApiCommand, UpdateAuthorizerCommand as UpdateAuthorizerCommand$1, UpdateIntegrationCommand, UpdateRouteCommand, UpdateStageCommand as UpdateStageCommand$1 } from "@aws-sdk/client-apigatewayv2";
 import { CreateStateMachineCommand, DeleteStateMachineCommand, DescribeStateMachineCommand, ListStateMachinesCommand, ListTagsForResourceCommand as ListTagsForResourceCommand$9, SFNClient, StateMachineDoesNotExist, TagResourceCommand as TagResourceCommand$10, UntagResourceCommand as UntagResourceCommand$9, UpdateStateMachineCommand } from "@aws-sdk/client-sfn";
 import { CreateClusterCommand, CreateServiceCommand, DeleteClusterCommand, DeleteServiceCommand, DeregisterTaskDefinitionCommand, DescribeClustersCommand, DescribeServicesCommand, DescribeTaskDefinitionCommand, ECSClient, ListClustersCommand, ListServicesCommand, ListTagsForResourceCommand as ListTagsForResourceCommand$10, PutClusterCapacityProvidersCommand, RegisterTaskDefinitionCommand, TagResourceCommand as TagResourceCommand$11, UntagResourceCommand as UntagResourceCommand$10, UpdateClusterCommand, UpdateServiceCommand } from "@aws-sdk/client-ecs";
@@ -7984,6 +7984,20 @@ var DynamoDBGlobalTableProvider = class {
 		return client;
 	}
 	/**
+	* Lazy-init + cache the local-region `ApplicationAutoScalingClient`.
+	* Previously `applyAutoScalingDiff` constructed a fresh client per
+	* call when no `client` arg was passed, leaking SDK clients (each
+	* holds its own HTTP agent) on multi-stack runs with many
+	* GlobalTables (PR #403 review minor #4).
+	*/
+	localAutoScalingClient;
+	async getLocalAutoScalingClient() {
+		if (this.localAutoScalingClient) return this.localAutoScalingClient;
+		const region = await this.dynamoDBClient.config.region() ?? "";
+		this.localAutoScalingClient = new ApplicationAutoScalingClient({ region });
+		return this.localAutoScalingClient;
+	}
+	/**
 	* Construct the regional table ARN for a cross-region replica of a
 	* GlobalTable. AWS replicates the same `TableName` across every
 	* replica region, with each replica's ARN differing only in the
@@ -8237,10 +8251,19 @@ var DynamoDBGlobalTableProvider = class {
 				await this.dynamoDBClient.send(new UpdateTableCommand(billingUpdate));
 				await this.waitForTableActiveAfterUpdate(physicalId, logicalId);
 			}
+			const writeAutoScalingOld = (previousProperties["WriteProvisionedThroughputSettings"] ?? {})["WriteCapacityAutoScalingSettings"];
+			const writeAutoScalingNew = (properties["WriteProvisionedThroughputSettings"] ?? {})["WriteCapacityAutoScalingSettings"];
+			const effectiveNewAutoScaling = oldBilling === "PROVISIONED" && newBilling === "PAY_PER_REQUEST" ? void 0 : writeAutoScalingNew;
+			if ((newBilling === "PROVISIONED" || oldBilling === "PROVISIONED") && !deepEqual$1(writeAutoScalingOld, effectiveNewAutoScaling)) await this.applyAutoScalingDiff(physicalId, "dynamodb:table:WriteCapacityUnits", writeAutoScalingOld, effectiveNewAutoScaling);
 			const replicaDiff = diffReplicas(previousProperties["Replicas"] ?? [], properties["Replicas"] ?? []);
 			for (const replica of replicaDiff.removed) {
 				const region = replica["Region"];
 				if (!region || region === currentRegion) continue;
+				const removedReadAutoScaling = (replica["ReadProvisionedThroughputSettings"] ?? {})["ReadCapacityAutoScalingSettings"];
+				if (removedReadAutoScaling) {
+					const regionalAutoScalingClient = this.getRegionalAutoScalingClient(region);
+					await this.applyAutoScalingDiff(physicalId, "dynamodb:table:ReadCapacityUnits", removedReadAutoScaling, void 0, regionalAutoScalingClient);
+				}
 				await this.dynamoDBClient.send(new UpdateTableCommand({
 					TableName: physicalId,
 					ReplicaUpdates: [{ Delete: { RegionName: region } }]
@@ -8251,11 +8274,17 @@ var DynamoDBGlobalTableProvider = class {
 				const region = replica["Region"];
 				if (!region || region === currentRegion) continue;
 				await this.addReplica(physicalId, replica, region, logicalId);
+				const newReadAutoScaling = (replica["ReadProvisionedThroughputSettings"] ?? {})["ReadCapacityAutoScalingSettings"];
+				if (newBilling === "PROVISIONED" && newReadAutoScaling) {
+					const regionalAutoScalingClient = this.getRegionalAutoScalingClient(region);
+					await this.applyAutoScalingDiff(physicalId, "dynamodb:table:ReadCapacityUnits", void 0, newReadAutoScaling, regionalAutoScalingClient);
+				}
 			}
 			for (const replica of replicaDiff.modified) {
 				const region = replica["Region"];
 				if (!region || region === currentRegion) continue;
-				const oldReplicaTags = (previousProperties["Replicas"] ?? []).find((r) => r["Region"] === region)?.["Tags"];
+				const oldReplica = (previousProperties["Replicas"] ?? []).find((r) => r["Region"] === region);
+				const oldReplicaTags = oldReplica?.["Tags"];
 				const newReplicaTags = replica["Tags"];
 				if (!deepEqual$1(oldReplicaTags, newReplicaTags)) if (tableArn) {
 					const replicaArn = this.replicaArnForRegion(tableArn, region);
@@ -8267,6 +8296,13 @@ var DynamoDBGlobalTableProvider = class {
 					}
 					else this.logger.warn(`Could not derive replica ARN for region ${region} from ${tableArn} — skipping Tags propagation for ${physicalId}`);
 				} else this.logger.warn(`Local DescribeTable returned no TableArn — cannot propagate Tags to cross-region replica ${region} of ${physicalId}`);
+				const oldReadAutoScaling = (oldReplica?.["ReadProvisionedThroughputSettings"] ?? {})["ReadCapacityAutoScalingSettings"];
+				const newReadAutoScaling = (replica["ReadProvisionedThroughputSettings"] ?? {})["ReadCapacityAutoScalingSettings"];
+				const effectiveNewReadAutoScaling = newBilling === "PAY_PER_REQUEST" ? void 0 : newReadAutoScaling;
+				if ((newBilling === "PROVISIONED" || oldBilling === "PROVISIONED") && !deepEqual$1(oldReadAutoScaling, effectiveNewReadAutoScaling)) {
+					const regionalAutoScalingClient = this.getRegionalAutoScalingClient(region);
+					await this.applyAutoScalingDiff(physicalId, "dynamodb:table:ReadCapacityUnits", oldReadAutoScaling, effectiveNewReadAutoScaling, regionalAutoScalingClient);
+				}
 				const updateAction = { RegionName: region };
 				if (replica["KMSMasterKeyId"] !== void 0) updateAction.KMSMasterKeyId = replica["KMSMasterKeyId"];
 				if (replica["GlobalSecondaryIndexes"]) updateAction.GlobalSecondaryIndexes = replica["GlobalSecondaryIndexes"];
@@ -8405,6 +8441,127 @@ var DynamoDBGlobalTableProvider = class {
 		}
 	}
 	/**
+	* Apply an application-autoscaling diff for one (tableName, dimension)
+	* pair (Issue #402 / PR closing Issue #395's deferred items).
+	*
+	* Dimension is either:
+	*  - `dynamodb:table:WriteCapacityUnits` (table-level write capacity),
+	*    paired with the local-region autoscaling client.
+	*  - `dynamodb:table:ReadCapacityUnits` (per-replica read capacity),
+	*    paired with a region-scoped autoscaling client returned by
+	*    `getRegionalAutoScalingClient`.
+	*
+	* Diff semantics (idempotent upsert, per Issue #402 spec):
+	*  - new auto-scaling settings present (Min/Max + TargetValue) →
+	*    `RegisterScalableTarget` (upsert) + `PutScalingPolicy` (upsert).
+	*    AWS's `RegisterScalableTarget` accepts no-op Min/Max changes
+	*    silently, and `PutScalingPolicy` is idempotent on the same
+	*    policy name (`DynamoDB{Write,Read}CapacityUtilization:table/<name>`).
+	*  - old auto-scaling settings present but new ones absent (= null) →
+	*    `DeleteScalingPolicy` + `DeregisterScalableTarget`. AWS rejects
+	*    `DeregisterScalableTarget` on a still-policy-attached target,
+	*    so the policy must be deleted FIRST.
+	*  - neither side has auto-scaling settings → no-op.
+	*
+	* **Best-effort**: any AWS error is logged at WARN with the per-API
+	* recovery command and the deploy continues — auto-scaling drift is
+	* recoverable on the next deploy, and an aborted deploy is much worse
+	* UX than a transient auto-scaling miss. This matches the cross-region
+	* Tags propagation contract (PR #393).
+	*
+	* **Policy naming** matches AWS's CDK / console default:
+	*   `DynamoDBWriteCapacityUtilization:table/<table-name>` (write)
+	*   `DynamoDBReadCapacityUtilization:table/<table-name>`  (read)
+	* so re-imports against a console-created target also match.
+	*
+	* **`SeedCapacity` is intentionally NOT forwarded** — it is a CFn
+	* create-only field with no corresponding `RegisterScalableTarget`
+	* surface; `readAutoScalingSettings` also explicitly skips it.
+	*/
+	async applyAutoScalingDiff(tableName, dimension, oldSettings, newSettings, client) {
+		const isWrite = dimension === "dynamodb:table:WriteCapacityUnits";
+		const policyName = isWrite ? `DynamoDBWriteCapacityUtilization:table/${tableName}` : `DynamoDBReadCapacityUtilization:table/${tableName}`;
+		const metricType = isWrite ? "DynamoDBWriteCapacityUtilization" : "DynamoDBReadCapacityUtilization";
+		const resourceId = `table/${tableName}`;
+		const asClient = client ?? await this.getLocalAutoScalingClient();
+		const oldEnabled = oldSettings !== void 0 && oldSettings !== null;
+		const newEnabled = newSettings !== void 0 && newSettings !== null;
+		if (!oldEnabled && !newEnabled) return;
+		if (newEnabled) {
+			const minCapacity = Number(newSettings["MinCapacity"] ?? 0);
+			const maxCapacity = Number(newSettings["MaxCapacity"] ?? 0);
+			if (!Number.isFinite(minCapacity) || !Number.isFinite(maxCapacity)) {
+				this.logger.warn(`Cannot apply auto-scaling diff on ${tableName} (${dimension}): MinCapacity / MaxCapacity must be numbers, got ${String(newSettings["MinCapacity"])} / ${String(newSettings["MaxCapacity"])}`);
+				return;
+			}
+			try {
+				await asClient.send(new RegisterScalableTargetCommand({
+					ServiceNamespace: "dynamodb",
+					ResourceId: resourceId,
+					ScalableDimension: dimension,
+					MinCapacity: minCapacity,
+					MaxCapacity: maxCapacity
+				}));
+			} catch (err) {
+				this.logger.warn(`Could not register auto-scaling target on ${tableName} (${dimension}): ${err instanceof Error ? err.message : String(err)}. Run: aws application-autoscaling register-scalable-target --service-namespace dynamodb --resource-id ${resourceId} --scalable-dimension ${dimension} --min-capacity ${minCapacity} --max-capacity ${maxCapacity}`);
+				return;
+			}
+			const tttCfg = newSettings["TargetTrackingScalingPolicyConfiguration"] ?? {};
+			const targetValue = Number(tttCfg["TargetValue"]);
+			if (!Number.isFinite(targetValue)) {
+				this.logger.warn(`Auto-scaling target registered on ${tableName} (${dimension}) but TargetValue is missing or non-numeric — skipping PutScalingPolicy. Provide TargetTrackingScalingPolicyConfiguration.TargetValue in the template.`);
+				return;
+			}
+			const targetTrackingConfig = {
+				PredefinedMetricSpecification: { PredefinedMetricType: metricType },
+				TargetValue: targetValue
+			};
+			if (tttCfg["ScaleInCooldown"] !== void 0) targetTrackingConfig["ScaleInCooldown"] = Number(tttCfg["ScaleInCooldown"]);
+			if (tttCfg["ScaleOutCooldown"] !== void 0) targetTrackingConfig["ScaleOutCooldown"] = Number(tttCfg["ScaleOutCooldown"]);
+			if (tttCfg["DisableScaleIn"] !== void 0) targetTrackingConfig["DisableScaleIn"] = Boolean(tttCfg["DisableScaleIn"]);
+			try {
+				await asClient.send(new PutScalingPolicyCommand({
+					PolicyName: policyName,
+					ServiceNamespace: "dynamodb",
+					ResourceId: resourceId,
+					ScalableDimension: dimension,
+					PolicyType: "TargetTrackingScaling",
+					TargetTrackingScalingPolicyConfiguration: targetTrackingConfig
+				}));
+				this.logger.debug(`Upserted auto-scaling policy ${policyName} on ${tableName} (${dimension})`);
+			} catch (err) {
+				this.logger.warn(`Could not put auto-scaling policy on ${tableName} (${dimension}): ${err instanceof Error ? err.message : String(err)}. Run: aws application-autoscaling put-scaling-policy --policy-name ${policyName} --service-namespace dynamodb --resource-id ${resourceId} --scalable-dimension ${dimension} --policy-type TargetTrackingScaling`);
+			}
+			return;
+		}
+		const isObjectNotFound = (err) => {
+			if (!(err instanceof Error)) return false;
+			const name = err.name ?? "";
+			const msg = err.message ?? "";
+			return name === "ObjectNotFoundException" || msg.includes("No scaling policy found") || msg.includes("No scalable target found");
+		};
+		try {
+			await asClient.send(new DeleteScalingPolicyCommand({
+				PolicyName: policyName,
+				ServiceNamespace: "dynamodb",
+				ResourceId: resourceId,
+				ScalableDimension: dimension
+			}));
+		} catch (err) {
+			if (!isObjectNotFound(err)) this.logger.warn(`Could not delete auto-scaling policy on ${tableName} (${dimension}): ${err instanceof Error ? err.message : String(err)}. Run: aws application-autoscaling delete-scaling-policy --policy-name ${policyName} --service-namespace dynamodb --resource-id ${resourceId} --scalable-dimension ${dimension}`);
+		}
+		try {
+			await asClient.send(new DeregisterScalableTargetCommand({
+				ServiceNamespace: "dynamodb",
+				ResourceId: resourceId,
+				ScalableDimension: dimension
+			}));
+			this.logger.debug(`Deregistered auto-scaling target ${resourceId} (${dimension})`);
+		} catch (err) {
+			if (!isObjectNotFound(err)) this.logger.warn(`Could not deregister auto-scaling target on ${tableName} (${dimension}): ${err instanceof Error ? err.message : String(err)}. Run: aws application-autoscaling deregister-scalable-target --service-namespace dynamodb --resource-id ${resourceId} --scalable-dimension ${dimension}`);
+		}
+	}
+	/**
 	* Delete a DynamoDB Global Table.
 	*
 	* Order is load-bearing:
@@ -8450,6 +8607,7 @@ var DynamoDBGlobalTableProvider = class {
 				const region = replica.RegionName;
 				if (!region || region === currentRegion) continue;
 				try {
+					await this.applyAutoScalingDiff(physicalId, "dynamodb:table:ReadCapacityUnits", {}, void 0, this.getRegionalAutoScalingClient(region));
 					await this.dynamoDBClient.send(new UpdateTableCommand({
 						TableName: physicalId,
 						ReplicaUpdates: [{ Delete: { RegionName: region } }]
@@ -8459,6 +8617,9 @@ var DynamoDBGlobalTableProvider = class {
 					if (!(replicaErr instanceof ResourceNotFoundException$1)) throw replicaErr;
 				}
 			}
+			const localAsClient = await this.getLocalAutoScalingClient();
+			await this.applyAutoScalingDiff(physicalId, "dynamodb:table:ReadCapacityUnits", {}, void 0, localAsClient);
+			await this.applyAutoScalingDiff(physicalId, "dynamodb:table:WriteCapacityUnits", {}, void 0, localAsClient);
 		} catch (describeErr) {
 			if (!(describeErr instanceof ResourceNotFoundException$1)) {
 				const cause = describeErr instanceof Error ? describeErr : void 0;
@@ -18396,7 +18557,7 @@ var RDSProvider = class {
 //#endregion
 //#region src/provisioning/providers/rds-dbproxy-provider.ts
 const POLL_INTERVAL_MS$1 = 5e3;
-const POLL_TIMEOUT_MS$1 = 900 * 1e3;
+const POLL_TIMEOUT_MS$1 = 1800 * 1e3;
 /**
 * AWS RDS DBProxy Provider
 *
@@ -18541,8 +18702,8 @@ var RDSDBProxyProvider = class {
 				throw this.wrapError(error, "UPDATE", resourceType, logicalId, physicalId);
 			}
 		}
-		await this.applyTagDiff(physicalId, previousProperties["Tags"], properties["Tags"], resourceType, logicalId);
 		this.invalidateAttributeCache(physicalId);
+		await this.applyTagDiff(physicalId, previousProperties["Tags"], properties["Tags"], resourceType, logicalId);
 		return {
 			physicalId,
 			wasReplaced: false
@@ -18664,6 +18825,9 @@ var RDSDBProxyProvider = class {
 		return result;
 	}
 	async applyTagDiff(physicalId, oldTags, newTags, resourceType, logicalId) {
+		const oldMap = this.toTagMap(oldTags);
+		const newMap = this.toTagMap(newTags);
+		if (oldMap.size === newMap.size && [...oldMap.keys()].every((k) => newMap.has(k)) && [...oldMap.entries()].every(([k, v]) => newMap.get(k) === v)) return;
 		const client = this.getClient();
 		const arnCacheKey = `${physicalId}:DBProxyArn`;
 		let arn = this.attributeCache.get(arnCacheKey);
@@ -18675,8 +18839,6 @@ var RDSDBProxyProvider = class {
 			return;
 		}
 		if (!arn) return;
-		const oldMap = this.toTagMap(oldTags);
-		const newMap = this.toTagMap(newTags);
 		const toRemove = [];
 		const toAdd = [];
 		for (const k of oldMap.keys()) if (!newMap.has(k)) toRemove.push(k);
@@ -18750,7 +18912,7 @@ var RDSDBProxyProvider = class {
 //#endregion
 //#region src/provisioning/providers/rds-dbproxy-endpoint-provider.ts
 const POLL_INTERVAL_MS = 5e3;
-const POLL_TIMEOUT_MS = 900 * 1e3;
+const POLL_TIMEOUT_MS = 1800 * 1e3;
 /**
 * AWS RDS DBProxyEndpoint Provider
 *
@@ -18832,11 +18994,9 @@ var RDSDBProxyEndpointProvider = class {
 		let status;
 		while (Date.now() < deadline) {
 			try {
-				const ep = (await client.send(new DescribeDBProxyEndpointsCommand({
-					DBProxyName: dbProxyName,
-					DBProxyEndpointName: dbProxyEndpointName
-				}))).DBProxyEndpoints?.[0];
+				const ep = (await client.send(new DescribeDBProxyEndpointsCommand({ DBProxyEndpointName: dbProxyEndpointName }))).DBProxyEndpoints?.[0];
 				status = ep?.Status;
+				this.logger.debug(`DBProxyEndpoint ${dbProxyEndpointName} poll: status=${status ?? "not-yet-visible"}`);
 				if (status === "available") {
 					endpoint = ep?.Endpoint;
 					arn = ep?.DBProxyEndpointArn;
@@ -18883,8 +19043,8 @@ var RDSDBProxyEndpointProvider = class {
 				throw this.wrapError(error, "UPDATE", resourceType, logicalId, physicalId);
 			}
 		}
-		await this.applyTagDiff(physicalId, previousProperties["Tags"], properties["Tags"], resourceType, logicalId);
 		this.invalidateAttributeCache(physicalId);
+		await this.applyTagDiff(physicalId, previousProperties["Tags"], properties["Tags"], resourceType, logicalId);
 		return {
 			physicalId,
 			wasReplaced: false
@@ -45026,7 +45186,7 @@ function reorderArgs(argv) {
 */
 async function main() {
 	const program = new Command();
-	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.108.0");
+	program.name("cdkd").description("CDK Direct - Deploy AWS CDK apps directly via SDK/Cloud Control API").version("0.109.1");
 	program.addCommand(createBootstrapCommand());
 	program.addCommand(createSynthCommand());
 	program.addCommand(createListCommand());