@go-to-k/cdkd 0.221.10 → 0.221.12

package/dist/{deploy-engine-U63EpLKn.js → deploy-engine-DZLu8l6Z.js}

@@ -25,6 +25,7 @@ import { DescribeImagesCommand as DescribeImagesCommand$1, ECRClient, GetAuthori
 import { hostname } from "os";
 import graphlib from "graphlib";
 import { DescribeDBClustersCommand, DescribeDBInstancesCommand, RDSClient } from "@aws-sdk/client-rds";
+import { DescribeReplicationGroupsCommand, ElastiCacheClient } from "@aws-sdk/client-elasticache";
 import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
 
 //#region src/utils/aws-region-resolver.ts
@@ -7550,6 +7551,28 @@ var CloudControlProvider = class {
 					this.logger.debug(`Failed to get Lambda URL config for ${physicalId}: ${error instanceof Error ? error.message : String(error)}`);
 				}
 				break;
+			case "AWS::ElastiCache::ReplicationGroup":
+				try {
+					const rg = (await new ElastiCacheClient({}).send(new DescribeReplicationGroupsCommand({ ReplicationGroupId: physicalId }))).ReplicationGroups?.[0];
+					if (rg) {
+						const primaryNode = rg.NodeGroups?.[0];
+						if (primaryNode?.PrimaryEndpoint?.Address) enriched["PrimaryEndPoint.Address"] = primaryNode.PrimaryEndpoint.Address;
+						if (primaryNode?.PrimaryEndpoint?.Port !== void 0) enriched["PrimaryEndPoint.Port"] = String(primaryNode.PrimaryEndpoint.Port);
+						if (primaryNode?.ReaderEndpoint?.Address) enriched["ReaderEndPoint.Address"] = primaryNode.ReaderEndpoint.Address;
+						if (primaryNode?.ReaderEndpoint?.Port !== void 0) enriched["ReaderEndPoint.Port"] = String(primaryNode.ReaderEndpoint.Port);
+						if (rg.ConfigurationEndpoint?.Address) enriched["ConfigurationEndPoint.Address"] = rg.ConfigurationEndpoint.Address;
+						if (rg.ConfigurationEndpoint?.Port !== void 0) enriched["ConfigurationEndPoint.Port"] = String(rg.ConfigurationEndpoint.Port);
+						const readEndpoints = (rg.NodeGroups ?? []).flatMap((ng) => [ng.PrimaryEndpoint, ng.ReaderEndpoint]);
+						const readAddrs = readEndpoints.map((ep) => ep?.Address).filter((a) => typeof a === "string" && a.length > 0);
+						const readPorts = readEndpoints.map((ep) => ep?.Port).filter((p) => p !== void 0);
+						if (readAddrs.length > 0) enriched["ReadEndPoint.Addresses"] = readAddrs.join(",");
+						if (readPorts.length > 0) enriched["ReadEndPoint.Ports"] = readPorts.map(String).join(",");
+						this.logger.debug(`Enriched ElastiCache ReplicationGroup ${physicalId} with endpoint attributes from DescribeReplicationGroups`);
+					}
+				} catch (error) {
+					this.logger.debug(`Failed to enrich ElastiCache ReplicationGroup ${physicalId}: ${error instanceof Error ? error.message : String(error)}`);
+				}
+				break;
 			default: break;
 		}
 		return enriched;
@@ -11624,7 +11647,8 @@ const RETRYABLE_ERROR_MESSAGE_PATTERNS = [
 	"Could not deliver test message",
 	"wait 60 seconds",
 	"concurrent update operation",
-	"because it is in use"
+	"because it is in use",
+	"Rate exceeded"
 ];
 /**
 * HTTP status codes that always indicate a transient failure worth retrying.
@@ -11632,18 +11656,62 @@ const RETRYABLE_ERROR_MESSAGE_PATTERNS = [
 */
 const RETRYABLE_HTTP_STATUS_CODES = new Set([429, 503]);
 /**
+* AWS SDK v3 canonical throttling error names. Mirrors
+* `@aws-sdk/service-error-classification`'s `THROTTLING_ERROR_CODES` — any
+* error (or wrapped cause) whose `name` is one of these is a transient rate-
+* limit rejection worth retrying with backoff. Detecting by NAME is more
+* robust than by HTTP status because most AWS throttles surface as HTTP 400
+* (not 429) with the throttling signal carried only in the error code / name
+* (e.g. SSM `ThrottlingException` for the `Rate exceeded` message).
+*/
+const THROTTLING_ERROR_NAMES = new Set([
+	"BandwidthLimitExceeded",
+	"EC2ThrottledException",
+	"LimitExceededException",
+	"PriorRequestNotComplete",
+	"ProvisionedThroughputExceededException",
+	"RequestLimitExceeded",
+	"RequestThrottled",
+	"RequestThrottledException",
+	"SlowDown",
+	"ThrottledException",
+	"Throttling",
+	"ThrottlingException",
+	"TooManyRequestsException",
+	"TransactionInProgressException"
+]);
+/**
+* Walk the error + its `.cause` chain (bounded) looking for an AWS SDK v3
+* throttling error `name`. cdkd wraps the original AWS error in a
+* `ProvisioningError`, so the throttling signal is typically one cause-link
+* deep; the bounded walk also tolerates SDK errors that nest a `$response`/
+* cause without exploding on a cyclic chain.
+*/
+function isThrottlingError(error) {
+	let current = error;
+	for (let depth = 0; depth < 5 && current != null; depth++) {
+		const name = current.name;
+		if (typeof name === "string" && THROTTLING_ERROR_NAMES.has(name)) return true;
+		current = current.cause;
+	}
+	return false;
+}
+/**
 * Determine whether an AWS error should be retried.
 *
 * Checks (in order):
 *   1. HTTP status code on the error itself (`$metadata.httpStatusCode`)
 *   2. HTTP status code on a wrapped cause (`cause.$metadata.httpStatusCode`)
-*   3. Substring match against {@link RETRYABLE_ERROR_MESSAGE_PATTERNS}
+*   3. Throttling error `name` on the error or any wrapped cause (most AWS
+*      throttles are HTTP 400, not 429 — see {@link THROTTLING_ERROR_NAMES})
+*   4. Substring match against {@link RETRYABLE_ERROR_MESSAGE_PATTERNS}
 */
 function isRetryableTransientError(error, message) {
 	const statusCode = error.$metadata?.httpStatusCode;
 	if (statusCode !== void 0 && RETRYABLE_HTTP_STATUS_CODES.has(statusCode)) return true;
 	const causeStatus = error.cause?.$metadata?.httpStatusCode;
 	if (causeStatus !== void 0 && RETRYABLE_HTTP_STATUS_CODES.has(causeStatus)) return true;
+	if (isThrottlingError(error)) return true;
 	return RETRYABLE_ERROR_MESSAGE_PATTERNS.some((p) => message.includes(p));
 }
 
@@ -13095,4 +13163,4 @@ var DeployEngine = class {
 
 //#endregion
 export { AssemblyReader as $, shouldRetainResource as A, getDefaultStateBucketName as B, applyRoleArnIfSet as C, LockManager as D, TemplateParser as E, formatDockerLoginError as F, resolveStateBucketWithDefault as G, resolveApp as H, getDockerCmd as I, CFN_TEMPLATE_BODY_LIMIT as J, resolveStateBucketWithDefaultAndSource as K, runDockerForeground as L, stringifyValue as M, WorkGraph as N, S3StateBackend as O, buildDockerImage as P, uploadCfnTemplate as Q, runDockerStreaming as R, IntrinsicFunctionResolver as S, DagBuilder as T, resolveCaptureObservedState as U, getLegacyStateBucketName as V, resolveSkipPrefix as W, MIGRATE_TMP_PREFIX as X, CFN_TEMPLATE_URL_LIMIT as Y, findLargeInlineResources as Z, IAMRoleProvider as _, withRetry as a, findActionableSilentDrops as b, computeImplicitDeleteEdges as c, bold as d, clearBucketRegionCache as et, cyan as f, yellow as g, red as h, withResourceDeadline as i, AssetPublisher as j, rebuildClientForBucketRegion as k, extractDeploymentEventError as l, green as m, DEFAULT_RESOURCE_WARN_AFTER_MS as n, isRetryableTransientError as o, gray as p, warnDeprecatedNoPrefixCliFlag as q, DeployEngine as r, IMPLICIT_DELETE_DEPENDENCIES as s, DEFAULT_RESOURCE_TIMEOUT_MS as t, resolveBucketRegion as tt, formatResourceLine as u, collectInlinePolicyNamesManagedBySiblings as v, DiffCalculator as w, CloudControlProvider as x, ProviderRegistry as y, Synthesizer as z };
-//# sourceMappingURL=deploy-engine-U63EpLKn.js.map
+//# sourceMappingURL=deploy-engine-DZLu8l6Z.js.map