aws-cdk 0.0.0

package/lib/api/deployments/hotswap-deployments.js

@@ -0,0 +1,357 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryHotswapDeployment = tryHotswapDeployment;
+const cfn_diff = require("@aws-cdk/cloudformation-diff");
+const chalk = require("chalk");
+const nested_stack_helpers_1 = require("./nested-stack-helpers");
+const logging_1 = require("../../logging");
+const error_1 = require("../../toolkit/error");
+const error_2 = require("../../util/error");
+const evaluate_cloudformation_template_1 = require("../evaluate-cloudformation-template");
+const appsync_mapping_templates_1 = require("../hotswap/appsync-mapping-templates");
+const code_build_projects_1 = require("../hotswap/code-build-projects");
+const common_1 = require("../hotswap/common");
+const ecs_services_1 = require("../hotswap/ecs-services");
+const lambda_functions_1 = require("../hotswap/lambda-functions");
+const s3_bucket_deployments_1 = require("../hotswap/s3-bucket-deployments");
+const stepfunctions_state_machines_1 = require("../hotswap/stepfunctions-state-machines");
+const plugin_1 = require("../plugin");
+// Must use a require() otherwise esbuild complains about calling a namespace
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const pLimit = require('p-limit');
+const RESOURCE_DETECTORS = {
+    // Lambda
+    'AWS::Lambda::Function': lambda_functions_1.isHotswappableLambdaFunctionChange,
+    'AWS::Lambda::Version': lambda_functions_1.isHotswappableLambdaFunctionChange,
+    'AWS::Lambda::Alias': lambda_functions_1.isHotswappableLambdaFunctionChange,
+    // AppSync
+    'AWS::AppSync::Resolver': appsync_mapping_templates_1.isHotswappableAppSyncChange,
+    'AWS::AppSync::FunctionConfiguration': appsync_mapping_templates_1.isHotswappableAppSyncChange,
+    'AWS::AppSync::GraphQLSchema': appsync_mapping_templates_1.isHotswappableAppSyncChange,
+    'AWS::AppSync::ApiKey': appsync_mapping_templates_1.isHotswappableAppSyncChange,
+    'AWS::ECS::TaskDefinition': ecs_services_1.isHotswappableEcsServiceChange,
+    'AWS::CodeBuild::Project': code_build_projects_1.isHotswappableCodeBuildProjectChange,
+    'AWS::StepFunctions::StateMachine': stepfunctions_state_machines_1.isHotswappableStateMachineChange,
+    'Custom::CDKBucketDeployment': s3_bucket_deployments_1.isHotswappableS3BucketDeploymentChange,
+    'AWS::IAM::Policy': async (logicalId, change, evaluateCfnTemplate) => {
+        // If the policy is for a S3BucketDeploymentChange, we can ignore the change
+        if (await (0, s3_bucket_deployments_1.skipChangeForS3DeployCustomResourcePolicy)(logicalId, change, evaluateCfnTemplate)) {
+            return [];
+        }
+        return (0, common_1.reportNonHotswappableResource)(change, 'This resource type is not supported for hotswap deployments');
+    },
+    'AWS::CDK::Metadata': async () => [],
+};
+/**
+ * Perform a hotswap deployment, short-circuiting CloudFormation if possible.
+ * If it's not possible to short-circuit the deployment
+ * (because the CDK Stack contains changes that cannot be deployed without CloudFormation),
+ * returns `undefined`.
+ */
+async function tryHotswapDeployment(sdkProvider, assetParams, cloudFormationStack, stackArtifact, hotswapMode, hotswapPropertyOverrides) {
+    // resolve the environment, so we can substitute things like AWS::Region in CFN expressions
+    const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);
+    // create a new SDK using the CLI credentials, because the default one will not work for new-style synthesis -
+    // it assumes the bootstrap deploy Role, which doesn't have permissions to update Lambda functions
+    const sdk = (await sdkProvider.forEnvironment(resolvedEnv, plugin_1.Mode.ForWriting)).sdk;
+    const currentTemplate = await (0, nested_stack_helpers_1.loadCurrentTemplateWithNestedStacks)(stackArtifact, sdk);
+    const evaluateCfnTemplate = new evaluate_cloudformation_template_1.EvaluateCloudFormationTemplate({
+        stackName: stackArtifact.stackName,
+        template: stackArtifact.template,
+        parameters: assetParams,
+        account: resolvedEnv.account,
+        region: resolvedEnv.region,
+        partition: (await sdk.currentAccount()).partition,
+        sdk,
+        nestedStacks: currentTemplate.nestedStacks,
+    });
+    const stackChanges = cfn_diff.fullDiff(currentTemplate.deployedRootTemplate, stackArtifact.template);
+    const { hotswappableChanges, nonHotswappableChanges } = await classifyResourceChanges(stackChanges, evaluateCfnTemplate, sdk, currentTemplate.nestedStacks, hotswapPropertyOverrides);
+    logNonHotswappableChanges(nonHotswappableChanges, hotswapMode);
+    // preserve classic hotswap behavior
+    if (hotswapMode === common_1.HotswapMode.FALL_BACK) {
+        if (nonHotswappableChanges.length > 0) {
+            return undefined;
+        }
+    }
+    // apply the short-circuitable changes
+    await applyAllHotswappableChanges(sdk, hotswappableChanges);
+    return {
+        type: 'did-deploy-stack',
+        noOp: hotswappableChanges.length === 0,
+        stackArn: cloudFormationStack.stackId,
+        outputs: cloudFormationStack.outputs,
+    };
+}
+/**
+ * Classifies all changes to all resources as either hotswappable or not.
+ * Metadata changes are excluded from the list of (non)hotswappable resources.
+ */
+async function classifyResourceChanges(stackChanges, evaluateCfnTemplate, sdk, nestedStackNames, hotswapPropertyOverrides) {
+    var _a, _b;
+    const resourceDifferences = getStackResourceDifferences(stackChanges);
+    const promises = [];
+    const hotswappableResources = new Array();
+    const nonHotswappableResources = new Array();
+    for (const logicalId of Object.keys(stackChanges.outputs.changes)) {
+        nonHotswappableResources.push({
+            hotswappable: false,
+            reason: 'output was changed',
+            logicalId,
+            rejectedChanges: [],
+            resourceType: 'Stack Output',
+        });
+    }
+    // gather the results of the detector functions
+    for (const [logicalId, change] of Object.entries(resourceDifferences)) {
+        if (((_a = change.newValue) === null || _a === void 0 ? void 0 : _a.Type) === 'AWS::CloudFormation::Stack' && ((_b = change.oldValue) === null || _b === void 0 ? void 0 : _b.Type) === 'AWS::CloudFormation::Stack') {
+            const nestedHotswappableResources = await findNestedHotswappableChanges(logicalId, change, nestedStackNames, evaluateCfnTemplate, sdk, hotswapPropertyOverrides);
+            hotswappableResources.push(...nestedHotswappableResources.hotswappableChanges);
+            nonHotswappableResources.push(...nestedHotswappableResources.nonHotswappableChanges);
+            continue;
+        }
+        const hotswappableChangeCandidate = isCandidateForHotswapping(change, logicalId);
+        // we don't need to run this through the detector functions, we can already judge this
+        if ('hotswappable' in hotswappableChangeCandidate) {
+            if (!hotswappableChangeCandidate.hotswappable) {
+                nonHotswappableResources.push(hotswappableChangeCandidate);
+            }
+            continue;
+        }
+        const resourceType = hotswappableChangeCandidate.newValue.Type;
+        if (resourceType in RESOURCE_DETECTORS) {
+            // run detector functions lazily to prevent unhandled promise rejections
+            promises.push(() => RESOURCE_DETECTORS[resourceType](logicalId, hotswappableChangeCandidate, evaluateCfnTemplate, hotswapPropertyOverrides));
+        }
+        else {
+            (0, common_1.reportNonHotswappableChange)(nonHotswappableResources, hotswappableChangeCandidate, undefined, 'This resource type is not supported for hotswap deployments');
+        }
+    }
+    // resolve all detector results
+    const changesDetectionResults = [];
+    for (const detectorResultPromises of promises) {
+        // Constant set of promises per resource
+        // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+        const hotswapDetectionResults = await Promise.all(await detectorResultPromises());
+        changesDetectionResults.push(hotswapDetectionResults);
+    }
+    for (const resourceDetectionResults of changesDetectionResults) {
+        for (const propertyResult of resourceDetectionResults) {
+            propertyResult.hotswappable
+                ? hotswappableResources.push(propertyResult)
+                : nonHotswappableResources.push(propertyResult);
+        }
+    }
+    return {
+        hotswappableChanges: hotswappableResources,
+        nonHotswappableChanges: nonHotswappableResources,
+    };
+}
+/**
+ * Returns all changes to resources in the given Stack.
+ *
+ * @param stackChanges the collection of all changes to a given Stack
+ */
+function getStackResourceDifferences(stackChanges) {
+    // we need to collapse logical ID rename changes into one change,
+    // as they are represented in stackChanges as a pair of two changes: one addition and one removal
+    const allResourceChanges = stackChanges.resources.changes;
+    const allRemovalChanges = filterDict(allResourceChanges, (resChange) => resChange.isRemoval);
+    const allNonRemovalChanges = filterDict(allResourceChanges, (resChange) => !resChange.isRemoval);
+    for (const [logId, nonRemovalChange] of Object.entries(allNonRemovalChanges)) {
+        if (nonRemovalChange.isAddition) {
+            const addChange = nonRemovalChange;
+            // search for an identical removal change
+            const identicalRemovalChange = Object.entries(allRemovalChanges).find(([_, remChange]) => {
+                return changesAreForSameResource(remChange, addChange);
+            });
+            // if we found one, then this means this is a rename change
+            if (identicalRemovalChange) {
+                const [removedLogId, removedResourceChange] = identicalRemovalChange;
+                allNonRemovalChanges[logId] = makeRenameDifference(removedResourceChange, addChange);
+                // delete the removal change that forms the rename pair
+                delete allRemovalChanges[removedLogId];
+            }
+        }
+    }
+    // the final result are all of the remaining removal changes,
+    // plus all of the non-removal changes
+    // (we saved the rename changes in that object already)
+    return {
+        ...allRemovalChanges,
+        ...allNonRemovalChanges,
+    };
+}
+/** Filters an object with string keys based on whether the callback returns 'true' for the given value in the object. */
+function filterDict(dict, func) {
+    return Object.entries(dict).reduce((acc, [key, t]) => {
+        if (func(t)) {
+            acc[key] = t;
+        }
+        return acc;
+    }, {});
+}
+/** Finds any hotswappable changes in all nested stacks. */
+async function findNestedHotswappableChanges(logicalId, change, nestedStackTemplates, evaluateCfnTemplate, sdk, hotswapPropertyOverrides) {
+    var _a, _b;
+    const nestedStack = nestedStackTemplates[logicalId];
+    if (!nestedStack.physicalName) {
+        return {
+            hotswappableChanges: [],
+            nonHotswappableChanges: [
+                {
+                    hotswappable: false,
+                    logicalId,
+                    reason: `physical name for AWS::CloudFormation::Stack '${logicalId}' could not be found in CloudFormation, so this is a newly created nested stack and cannot be hotswapped`,
+                    rejectedChanges: [],
+                    resourceType: 'AWS::CloudFormation::Stack',
+                },
+            ],
+        };
+    }
+    const evaluateNestedCfnTemplate = await evaluateCfnTemplate.createNestedEvaluateCloudFormationTemplate(nestedStack.physicalName, nestedStack.generatedTemplate, (_b = (_a = change.newValue) === null || _a === void 0 ? void 0 : _a.Properties) === null || _b === void 0 ? void 0 : _b.Parameters);
+    const nestedDiff = cfn_diff.fullDiff(nestedStackTemplates[logicalId].deployedTemplate, nestedStackTemplates[logicalId].generatedTemplate);
+    return classifyResourceChanges(nestedDiff, evaluateNestedCfnTemplate, sdk, nestedStackTemplates[logicalId].nestedStackTemplates, hotswapPropertyOverrides);
+}
+/** Returns 'true' if a pair of changes is for the same resource. */
+function changesAreForSameResource(oldChange, newChange) {
+    return (oldChange.oldResourceType === newChange.newResourceType &&
+        // this isn't great, but I don't want to bring in something like underscore just for this comparison
+        JSON.stringify(oldChange.oldProperties) === JSON.stringify(newChange.newProperties));
+}
+function makeRenameDifference(remChange, addChange) {
+    return new cfn_diff.ResourceDifference(
+    // we have to fill in the old value, because otherwise this will be classified as a non-hotswappable change
+    remChange.oldValue, addChange.newValue, {
+        resourceType: {
+            oldType: remChange.oldResourceType,
+            newType: addChange.newResourceType,
+        },
+        propertyDiffs: addChange.propertyDiffs,
+        otherDiffs: addChange.otherDiffs,
+    });
+}
+/**
+ * Returns a `HotswappableChangeCandidate` if the change is hotswappable
+ * Returns an empty `HotswappableChange` if the change is to CDK::Metadata
+ * Returns a `NonHotswappableChange` if the change is not hotswappable
+ */
+function isCandidateForHotswapping(change, logicalId) {
+    var _a, _b, _c, _d, _e;
+    // a resource has been removed OR a resource has been added; we can't short-circuit that change
+    if (!change.oldValue) {
+        return {
+            hotswappable: false,
+            resourceType: change.newValue.Type,
+            logicalId,
+            rejectedChanges: [],
+            reason: `resource '${logicalId}' was created by this deployment`,
+        };
+    }
+    else if (!change.newValue) {
+        return {
+            hotswappable: false,
+            resourceType: change.oldValue.Type,
+            logicalId,
+            rejectedChanges: [],
+            reason: `resource '${logicalId}' was destroyed by this deployment`,
+        };
+    }
+    // a resource has had its type changed
+    if (((_a = change.newValue) === null || _a === void 0 ? void 0 : _a.Type) !== ((_b = change.oldValue) === null || _b === void 0 ? void 0 : _b.Type)) {
+        return {
+            hotswappable: false,
+            resourceType: (_c = change.newValue) === null || _c === void 0 ? void 0 : _c.Type,
+            logicalId,
+            rejectedChanges: [],
+            reason: `resource '${logicalId}' had its type changed from '${(_d = change.oldValue) === null || _d === void 0 ? void 0 : _d.Type}' to '${(_e = change.newValue) === null || _e === void 0 ? void 0 : _e.Type}'`,
+        };
+    }
+    return {
+        logicalId,
+        oldValue: change.oldValue,
+        newValue: change.newValue,
+        propertyUpdates: change.propertyUpdates,
+    };
+}
+async function applyAllHotswappableChanges(sdk, hotswappableChanges) {
+    if (hotswappableChanges.length > 0) {
+        (0, logging_1.info)(`\n${common_1.ICON} hotswapping resources:`);
+    }
+    const limit = pLimit(10);
+    // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism
+    return Promise.all(hotswappableChanges.map(hotswapOperation => limit(() => {
+        return applyHotswappableChange(sdk, hotswapOperation);
+    })));
+}
+async function applyHotswappableChange(sdk, hotswapOperation) {
+    // note the type of service that was successfully hotswapped in the User-Agent
+    const customUserAgent = `cdk-hotswap/success-${hotswapOperation.service}`;
+    sdk.appendCustomUserAgent(customUserAgent);
+    for (const name of hotswapOperation.resourceNames) {
+        (0, logging_1.info)(`   ${common_1.ICON} %s`, chalk.bold(name));
+    }
+    // if the SDK call fails, an error will be thrown by the SDK
+    // and will prevent the green 'hotswapped!' text from being displayed
+    try {
+        await hotswapOperation.apply(sdk);
+    }
+    catch (e) {
+        if (e.name === 'TimeoutError' || e.name === 'AbortError') {
+            const result = JSON.parse((0, error_2.formatErrorMessage)(e));
+            const error = new error_1.ToolkitError(formatWaiterErrorResult(result));
+            error.name = e.name;
+            throw error;
+        }
+        throw e;
+    }
+    for (const name of hotswapOperation.resourceNames) {
+        (0, logging_1.info)(`${common_1.ICON} %s %s`, chalk.bold(name), chalk.green('hotswapped!'));
+    }
+    sdk.removeCustomUserAgent(customUserAgent);
+}
+function formatWaiterErrorResult(result) {
+    const main = [
+        `Resource is not in the expected state due to waiter status: ${result.state}`,
+        result.reason ? `${result.reason}.` : '',
+    ].join('. ');
+    if (result.observedResponses != null) {
+        const observedResponses = Object
+            .entries(result.observedResponses)
+            .map(([msg, count]) => `  - ${msg} (${count})`)
+            .join('\n');
+        return `${main} Observed responses:\n${observedResponses}`;
+    }
+    return main;
+}
+function logNonHotswappableChanges(nonHotswappableChanges, hotswapMode) {
+    if (nonHotswappableChanges.length === 0) {
+        return;
+    }
+    /**
+     * EKS Services can have a task definition that doesn't refer to the task definition being updated.
+     * We have to log this as a non-hotswappable change to the task definition, but when we do,
+     * we wind up hotswapping the task definition and logging it as a non-hotswappable change.
+     *
+     * This logic prevents us from logging that change as non-hotswappable when we hotswap it.
+     */
+    if (hotswapMode === common_1.HotswapMode.HOTSWAP_ONLY) {
+        nonHotswappableChanges = nonHotswappableChanges.filter((change) => change.hotswapOnlyVisible === true);
+        if (nonHotswappableChanges.length === 0) {
+            return;
+        }
+    }
+    if (hotswapMode === common_1.HotswapMode.HOTSWAP_ONLY) {
+        (0, logging_1.info)('\n%s %s', chalk.red('⚠️'), chalk.red('The following non-hotswappable changes were found. To reconcile these using CloudFormation, specify --hotswap-fallback'));
+    }
+    else {
+        (0, logging_1.info)('\n%s %s', chalk.red('⚠️'), chalk.red('The following non-hotswappable changes were found:'));
+    }
+    for (const change of nonHotswappableChanges) {
+        change.rejectedChanges.length > 0
+            ? (0, logging_1.info)('    logicalID: %s, type: %s, rejected changes: %s, reason: %s', chalk.bold(change.logicalId), chalk.bold(change.resourceType), chalk.bold(change.rejectedChanges), chalk.red(change.reason))
+            : (0, logging_1.info)('    logicalID: %s, type: %s, reason: %s', chalk.bold(change.logicalId), chalk.bold(change.resourceType), chalk.red(change.reason));
+    }
+    (0, logging_1.info)(''); // newline
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hotswap-deployments.js","sourceRoot":"","sources":["hotswap-deployments.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cfn_diff from '@aws-cdk/cloudformation-diff';\nimport * as cxapi from '@aws-cdk/cx-api';\nimport { WaiterResult } from '@smithy/util-waiter';\nimport * as chalk from 'chalk';\nimport type { SDK, SdkProvider } from '../aws-auth';\nimport type { CloudFormationStack } from './cloudformation';\nimport { NestedStackTemplates, loadCurrentTemplateWithNestedStacks } from './nested-stack-helpers';\nimport { info } from '../../logging';\nimport { ToolkitError } from '../../toolkit/error';\nimport { formatErrorMessage } from '../../util/error';\nimport { EvaluateCloudFormationTemplate } from '../evaluate-cloudformation-template';\nimport { isHotswappableAppSyncChange } from '../hotswap/appsync-mapping-templates';\nimport { isHotswappableCodeBuildProjectChange } from '../hotswap/code-build-projects';\nimport {\n  ICON,\n  ChangeHotswapResult,\n  HotswapMode,\n  HotswappableChange,\n  NonHotswappableChange,\n  HotswappableChangeCandidate,\n  HotswapPropertyOverrides, ClassifiedResourceChanges,\n  reportNonHotswappableChange,\n  reportNonHotswappableResource,\n} from '../hotswap/common';\nimport { isHotswappableEcsServiceChange } from '../hotswap/ecs-services';\nimport { isHotswappableLambdaFunctionChange } from '../hotswap/lambda-functions';\nimport {\n  skipChangeForS3DeployCustomResourcePolicy,\n  isHotswappableS3BucketDeploymentChange,\n} from '../hotswap/s3-bucket-deployments';\nimport { isHotswappableStateMachineChange } from '../hotswap/stepfunctions-state-machines';\nimport { Mode } from '../plugin';\nimport { SuccessfulDeployStackResult } from './deployment-result';\n\n// Must use a require() otherwise esbuild complains about calling a namespace\n// eslint-disable-next-line @typescript-eslint/no-require-imports\nconst pLimit: typeof import('p-limit') = require('p-limit');\n\ntype HotswapDetector = (\n  logicalId: string,\n  change: HotswappableChangeCandidate,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n  hotswapPropertyOverrides: HotswapPropertyOverrides,\n) => Promise<ChangeHotswapResult>;\n\nconst RESOURCE_DETECTORS: { [key: string]: HotswapDetector } = {\n  // Lambda\n  'AWS::Lambda::Function': isHotswappableLambdaFunctionChange,\n  'AWS::Lambda::Version': isHotswappableLambdaFunctionChange,\n  'AWS::Lambda::Alias': isHotswappableLambdaFunctionChange,\n\n  // AppSync\n  'AWS::AppSync::Resolver': isHotswappableAppSyncChange,\n  'AWS::AppSync::FunctionConfiguration': isHotswappableAppSyncChange,\n  'AWS::AppSync::GraphQLSchema': isHotswappableAppSyncChange,\n  'AWS::AppSync::ApiKey': isHotswappableAppSyncChange,\n\n  'AWS::ECS::TaskDefinition': isHotswappableEcsServiceChange,\n  'AWS::CodeBuild::Project': isHotswappableCodeBuildProjectChange,\n  'AWS::StepFunctions::StateMachine': isHotswappableStateMachineChange,\n  'Custom::CDKBucketDeployment': isHotswappableS3BucketDeploymentChange,\n  'AWS::IAM::Policy': async (\n    logicalId: string,\n    change: HotswappableChangeCandidate,\n    evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n  ): Promise<ChangeHotswapResult> => {\n    // If the policy is for a S3BucketDeploymentChange, we can ignore the change\n    if (await skipChangeForS3DeployCustomResourcePolicy(logicalId, change, evaluateCfnTemplate)) {\n      return [];\n    }\n\n    return reportNonHotswappableResource(change, 'This resource type is not supported for hotswap deployments');\n  },\n\n  'AWS::CDK::Metadata': async () => [],\n};\n\n/**\n * Perform a hotswap deployment, short-circuiting CloudFormation if possible.\n * If it's not possible to short-circuit the deployment\n * (because the CDK Stack contains changes that cannot be deployed without CloudFormation),\n * returns `undefined`.\n */\nexport async function tryHotswapDeployment(\n  sdkProvider: SdkProvider,\n  assetParams: { [key: string]: string },\n  cloudFormationStack: CloudFormationStack,\n  stackArtifact: cxapi.CloudFormationStackArtifact,\n  hotswapMode: HotswapMode, hotswapPropertyOverrides: HotswapPropertyOverrides,\n): Promise<SuccessfulDeployStackResult | undefined> {\n  // resolve the environment, so we can substitute things like AWS::Region in CFN expressions\n  const resolvedEnv = await sdkProvider.resolveEnvironment(stackArtifact.environment);\n  // create a new SDK using the CLI credentials, because the default one will not work for new-style synthesis -\n  // it assumes the bootstrap deploy Role, which doesn't have permissions to update Lambda functions\n  const sdk = (await sdkProvider.forEnvironment(resolvedEnv, Mode.ForWriting)).sdk;\n\n  const currentTemplate = await loadCurrentTemplateWithNestedStacks(stackArtifact, sdk);\n\n  const evaluateCfnTemplate = new EvaluateCloudFormationTemplate({\n    stackName: stackArtifact.stackName,\n    template: stackArtifact.template,\n    parameters: assetParams,\n    account: resolvedEnv.account,\n    region: resolvedEnv.region,\n    partition: (await sdk.currentAccount()).partition,\n    sdk,\n    nestedStacks: currentTemplate.nestedStacks,\n  });\n\n  const stackChanges = cfn_diff.fullDiff(currentTemplate.deployedRootTemplate, stackArtifact.template);\n  const { hotswappableChanges, nonHotswappableChanges } = await classifyResourceChanges(\n    stackChanges,\n    evaluateCfnTemplate,\n    sdk,\n    currentTemplate.nestedStacks, hotswapPropertyOverrides,\n  );\n\n  logNonHotswappableChanges(nonHotswappableChanges, hotswapMode);\n\n  // preserve classic hotswap behavior\n  if (hotswapMode === HotswapMode.FALL_BACK) {\n    if (nonHotswappableChanges.length > 0) {\n      return undefined;\n    }\n  }\n\n  // apply the short-circuitable changes\n  await applyAllHotswappableChanges(sdk, hotswappableChanges);\n\n  return {\n    type: 'did-deploy-stack',\n    noOp: hotswappableChanges.length === 0,\n    stackArn: cloudFormationStack.stackId,\n    outputs: cloudFormationStack.outputs,\n  };\n}\n\n/**\n * Classifies all changes to all resources as either hotswappable or not.\n * Metadata changes are excluded from the list of (non)hotswappable resources.\n */\nasync function classifyResourceChanges(\n  stackChanges: cfn_diff.TemplateDiff,\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n  sdk: SDK,\n  nestedStackNames: { [nestedStackName: string]: NestedStackTemplates },\n  hotswapPropertyOverrides: HotswapPropertyOverrides,\n): Promise<ClassifiedResourceChanges> {\n  const resourceDifferences = getStackResourceDifferences(stackChanges);\n\n  const promises: Array<() => Promise<ChangeHotswapResult>> = [];\n  const hotswappableResources = new Array<HotswappableChange>();\n  const nonHotswappableResources = new Array<NonHotswappableChange>();\n  for (const logicalId of Object.keys(stackChanges.outputs.changes)) {\n    nonHotswappableResources.push({\n      hotswappable: false,\n      reason: 'output was changed',\n      logicalId,\n      rejectedChanges: [],\n      resourceType: 'Stack Output',\n    });\n  }\n  // gather the results of the detector functions\n  for (const [logicalId, change] of Object.entries(resourceDifferences)) {\n    if (change.newValue?.Type === 'AWS::CloudFormation::Stack' && change.oldValue?.Type === 'AWS::CloudFormation::Stack') {\n      const nestedHotswappableResources = await findNestedHotswappableChanges(\n        logicalId,\n        change,\n        nestedStackNames,\n        evaluateCfnTemplate,\n        sdk,\n        hotswapPropertyOverrides,\n      );\n      hotswappableResources.push(...nestedHotswappableResources.hotswappableChanges);\n      nonHotswappableResources.push(...nestedHotswappableResources.nonHotswappableChanges);\n\n      continue;\n    }\n\n    const hotswappableChangeCandidate = isCandidateForHotswapping(change, logicalId);\n    // we don't need to run this through the detector functions, we can already judge this\n    if ('hotswappable' in hotswappableChangeCandidate) {\n      if (!hotswappableChangeCandidate.hotswappable) {\n        nonHotswappableResources.push(hotswappableChangeCandidate);\n      }\n\n      continue;\n    }\n\n    const resourceType: string = hotswappableChangeCandidate.newValue.Type;\n    if (resourceType in RESOURCE_DETECTORS) {\n      // run detector functions lazily to prevent unhandled promise rejections\n      promises.push(() =>\n        RESOURCE_DETECTORS[resourceType](logicalId, hotswappableChangeCandidate, evaluateCfnTemplate, hotswapPropertyOverrides),\n      );\n    } else {\n      reportNonHotswappableChange(\n        nonHotswappableResources,\n        hotswappableChangeCandidate,\n        undefined,\n        'This resource type is not supported for hotswap deployments',\n      );\n    }\n  }\n\n  // resolve all detector results\n  const changesDetectionResults: Array<ChangeHotswapResult> = [];\n  for (const detectorResultPromises of promises) {\n    // Constant set of promises per resource\n    // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n    const hotswapDetectionResults = await Promise.all(await detectorResultPromises());\n    changesDetectionResults.push(hotswapDetectionResults);\n  }\n\n  for (const resourceDetectionResults of changesDetectionResults) {\n    for (const propertyResult of resourceDetectionResults) {\n      propertyResult.hotswappable\n        ? hotswappableResources.push(propertyResult)\n        : nonHotswappableResources.push(propertyResult);\n    }\n  }\n\n  return {\n    hotswappableChanges: hotswappableResources,\n    nonHotswappableChanges: nonHotswappableResources,\n  };\n}\n\n/**\n * Returns all changes to resources in the given Stack.\n *\n * @param stackChanges the collection of all changes to a given Stack\n */\nfunction getStackResourceDifferences(stackChanges: cfn_diff.TemplateDiff): {\n  [logicalId: string]: cfn_diff.ResourceDifference;\n} {\n  // we need to collapse logical ID rename changes into one change,\n  // as they are represented in stackChanges as a pair of two changes: one addition and one removal\n  const allResourceChanges: { [logId: string]: cfn_diff.ResourceDifference } = stackChanges.resources.changes;\n  const allRemovalChanges = filterDict(allResourceChanges, (resChange) => resChange.isRemoval);\n  const allNonRemovalChanges = filterDict(allResourceChanges, (resChange) => !resChange.isRemoval);\n  for (const [logId, nonRemovalChange] of Object.entries(allNonRemovalChanges)) {\n    if (nonRemovalChange.isAddition) {\n      const addChange = nonRemovalChange;\n      // search for an identical removal change\n      const identicalRemovalChange = Object.entries(allRemovalChanges).find(([_, remChange]) => {\n        return changesAreForSameResource(remChange, addChange);\n      });\n      // if we found one, then this means this is a rename change\n      if (identicalRemovalChange) {\n        const [removedLogId, removedResourceChange] = identicalRemovalChange;\n        allNonRemovalChanges[logId] = makeRenameDifference(removedResourceChange, addChange);\n        // delete the removal change that forms the rename pair\n        delete allRemovalChanges[removedLogId];\n      }\n    }\n  }\n  // the final result are all of the remaining removal changes,\n  // plus all of the non-removal changes\n  // (we saved the rename changes in that object already)\n  return {\n    ...allRemovalChanges,\n    ...allNonRemovalChanges,\n  };\n}\n\n/** Filters an object with string keys based on whether the callback returns 'true' for the given value in the object. */\nfunction filterDict<T>(dict: { [key: string]: T }, func: (t: T) => boolean): { [key: string]: T } {\n  return Object.entries(dict).reduce(\n    (acc, [key, t]) => {\n      if (func(t)) {\n        acc[key] = t;\n      }\n      return acc;\n    },\n    {} as { [key: string]: T },\n  );\n}\n\n/** Finds any hotswappable changes in all nested stacks. */\nasync function findNestedHotswappableChanges(\n  logicalId: string,\n  change: cfn_diff.ResourceDifference,\n  nestedStackTemplates: { [nestedStackName: string]: NestedStackTemplates },\n  evaluateCfnTemplate: EvaluateCloudFormationTemplate,\n  sdk: SDK,\n  hotswapPropertyOverrides: HotswapPropertyOverrides,\n): Promise<ClassifiedResourceChanges> {\n  const nestedStack = nestedStackTemplates[logicalId];\n  if (!nestedStack.physicalName) {\n    return {\n      hotswappableChanges: [],\n      nonHotswappableChanges: [\n        {\n          hotswappable: false,\n          logicalId,\n          reason: `physical name for AWS::CloudFormation::Stack '${logicalId}' could not be found in CloudFormation, so this is a newly created nested stack and cannot be hotswapped`,\n          rejectedChanges: [],\n          resourceType: 'AWS::CloudFormation::Stack',\n        },\n      ],\n    };\n  }\n\n  const evaluateNestedCfnTemplate = await evaluateCfnTemplate.createNestedEvaluateCloudFormationTemplate(\n    nestedStack.physicalName,\n    nestedStack.generatedTemplate,\n    change.newValue?.Properties?.Parameters,\n  );\n\n  const nestedDiff = cfn_diff.fullDiff(\n    nestedStackTemplates[logicalId].deployedTemplate,\n    nestedStackTemplates[logicalId].generatedTemplate,\n  );\n\n  return classifyResourceChanges(\n    nestedDiff,\n    evaluateNestedCfnTemplate,\n    sdk,\n    nestedStackTemplates[logicalId].nestedStackTemplates,\n    hotswapPropertyOverrides);\n}\n\n/** Returns 'true' if a pair of changes is for the same resource. */\nfunction changesAreForSameResource(\n  oldChange: cfn_diff.ResourceDifference,\n  newChange: cfn_diff.ResourceDifference,\n): boolean {\n  return (\n    oldChange.oldResourceType === newChange.newResourceType &&\n    // this isn't great, but I don't want to bring in something like underscore just for this comparison\n    JSON.stringify(oldChange.oldProperties) === JSON.stringify(newChange.newProperties)\n  );\n}\n\nfunction makeRenameDifference(\n  remChange: cfn_diff.ResourceDifference,\n  addChange: cfn_diff.ResourceDifference,\n): cfn_diff.ResourceDifference {\n  return new cfn_diff.ResourceDifference(\n    // we have to fill in the old value, because otherwise this will be classified as a non-hotswappable change\n    remChange.oldValue,\n    addChange.newValue,\n    {\n      resourceType: {\n        oldType: remChange.oldResourceType,\n        newType: addChange.newResourceType,\n      },\n      propertyDiffs: (addChange as any).propertyDiffs,\n      otherDiffs: (addChange as any).otherDiffs,\n    },\n  );\n}\n\n/**\n * Returns a `HotswappableChangeCandidate` if the change is hotswappable\n * Returns an empty `HotswappableChange` if the change is to CDK::Metadata\n * Returns a `NonHotswappableChange` if the change is not hotswappable\n */\nfunction isCandidateForHotswapping(\n  change: cfn_diff.ResourceDifference,\n  logicalId: string,\n): HotswappableChange | NonHotswappableChange | HotswappableChangeCandidate {\n  // a resource has been removed OR a resource has been added; we can't short-circuit that change\n  if (!change.oldValue) {\n    return {\n      hotswappable: false,\n      resourceType: change.newValue!.Type,\n      logicalId,\n      rejectedChanges: [],\n      reason: `resource '${logicalId}' was created by this deployment`,\n    };\n  } else if (!change.newValue) {\n    return {\n      hotswappable: false,\n      resourceType: change.oldValue!.Type,\n      logicalId,\n      rejectedChanges: [],\n      reason: `resource '${logicalId}' was destroyed by this deployment`,\n    };\n  }\n\n  // a resource has had its type changed\n  if (change.newValue?.Type !== change.oldValue?.Type) {\n    return {\n      hotswappable: false,\n      resourceType: change.newValue?.Type,\n      logicalId,\n      rejectedChanges: [],\n      reason: `resource '${logicalId}' had its type changed from '${change.oldValue?.Type}' to '${change.newValue?.Type}'`,\n    };\n  }\n\n  return {\n    logicalId,\n    oldValue: change.oldValue,\n    newValue: change.newValue,\n    propertyUpdates: change.propertyUpdates,\n  };\n}\n\nasync function applyAllHotswappableChanges(sdk: SDK, hotswappableChanges: HotswappableChange[]): Promise<void[]> {\n  if (hotswappableChanges.length > 0) {\n    info(`\\n${ICON} hotswapping resources:`);\n  }\n  const limit = pLimit(10);\n  // eslint-disable-next-line @cdklabs/promiseall-no-unbounded-parallelism\n  return Promise.all(hotswappableChanges.map(hotswapOperation => limit(() => {\n    return applyHotswappableChange(sdk, hotswapOperation);\n  })));\n}\n\nasync function applyHotswappableChange(sdk: SDK, hotswapOperation: HotswappableChange): Promise<void> {\n  // note the type of service that was successfully hotswapped in the User-Agent\n  const customUserAgent = `cdk-hotswap/success-${hotswapOperation.service}`;\n  sdk.appendCustomUserAgent(customUserAgent);\n\n  for (const name of hotswapOperation.resourceNames) {\n    info(`   ${ICON} %s`, chalk.bold(name));\n  }\n\n  // if the SDK call fails, an error will be thrown by the SDK\n  // and will prevent the green 'hotswapped!' text from being displayed\n  try {\n    await hotswapOperation.apply(sdk);\n  } catch (e: any) {\n    if (e.name === 'TimeoutError' || e.name === 'AbortError') {\n      const result: WaiterResult = JSON.parse(formatErrorMessage(e));\n      const error = new ToolkitError(formatWaiterErrorResult(result));\n      error.name = e.name;\n      throw error;\n    }\n    throw e;\n  }\n\n  for (const name of hotswapOperation.resourceNames) {\n    info(`${ICON} %s %s`, chalk.bold(name), chalk.green('hotswapped!'));\n  }\n\n  sdk.removeCustomUserAgent(customUserAgent);\n}\n\nfunction formatWaiterErrorResult(result: WaiterResult) {\n  const main = [\n    `Resource is not in the expected state due to waiter status: ${result.state}`,\n    result.reason ? `${result.reason}.` : '',\n  ].join('. ');\n\n  if (result.observedResponses != null) {\n    const observedResponses = Object\n      .entries(result.observedResponses)\n      .map(([msg, count]) => `  - ${msg} (${count})`)\n      .join('\\n');\n\n    return `${main} Observed responses:\\n${observedResponses}`;\n  }\n\n  return main;\n}\n\nfunction logNonHotswappableChanges(nonHotswappableChanges: NonHotswappableChange[], hotswapMode: HotswapMode): void {\n  if (nonHotswappableChanges.length === 0) {\n    return;\n  }\n  /**\n   * EKS Services can have a task definition that doesn't refer to the task definition being updated.\n   * We have to log this as a non-hotswappable change to the task definition, but when we do,\n   * we wind up hotswapping the task definition and logging it as a non-hotswappable change.\n   *\n   * This logic prevents us from logging that change as non-hotswappable when we hotswap it.\n   */\n  if (hotswapMode === HotswapMode.HOTSWAP_ONLY) {\n    nonHotswappableChanges = nonHotswappableChanges.filter((change) => change.hotswapOnlyVisible === true);\n\n    if (nonHotswappableChanges.length === 0) {\n      return;\n    }\n  }\n  if (hotswapMode === HotswapMode.HOTSWAP_ONLY) {\n    info(\n      '\\n%s %s',\n      chalk.red('⚠️'),\n      chalk.red(\n        'The following non-hotswappable changes were found. To reconcile these using CloudFormation, specify --hotswap-fallback',\n      ),\n    );\n  } else {\n    info('\\n%s %s', chalk.red('⚠️'), chalk.red('The following non-hotswappable changes were found:'));\n  }\n\n  for (const change of nonHotswappableChanges) {\n    change.rejectedChanges.length > 0\n      ? info(\n        '    logicalID: %s, type: %s, rejected changes: %s, reason: %s',\n        chalk.bold(change.logicalId),\n        chalk.bold(change.resourceType),\n        chalk.bold(change.rejectedChanges),\n        chalk.red(change.reason),\n      )\n      : info(\n        '    logicalID: %s, type: %s, reason: %s',\n        chalk.bold(change.logicalId),\n        chalk.bold(change.resourceType),\n        chalk.red(change.reason),\n      );\n  }\n\n  info(''); // newline\n}\n"]}

package/lib/api/deployments/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cloudformation';
+export * from './deployments';
+export * from './deployment-result';
+export * from './deployment-method';
+export * from './nested-stack-helpers';
+export * from './asset-manifest-builder';

package/lib/api/deployments/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cloudformation"), exports);
+__exportStar(require("./deployments"), exports);
+__exportStar(require("./deployment-result"), exports);
+__exportStar(require("./deployment-method"), exports);
+__exportStar(require("./nested-stack-helpers"), exports);
+__exportStar(require("./asset-manifest-builder"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbURBQWlDO0FBQ2pDLGdEQUE4QjtBQUM5QixzREFBb0M7QUFDcEMsc0RBQW9DO0FBQ3BDLHlEQUF1QztBQUN2QywyREFBeUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Nsb3VkZm9ybWF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vZGVwbG95bWVudHMnO1xuZXhwb3J0ICogZnJvbSAnLi9kZXBsb3ltZW50LXJlc3VsdCc7XG5leHBvcnQgKiBmcm9tICcuL2RlcGxveW1lbnQtbWV0aG9kJztcbmV4cG9ydCAqIGZyb20gJy4vbmVzdGVkLXN0YWNrLWhlbHBlcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9hc3NldC1tYW5pZmVzdC1idWlsZGVyJztcbiJdfQ==

package/lib/api/deployments/nested-stack-helpers.d.ts

@@ -0,0 +1,25 @@
+import type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';
+import type { SDK } from '../aws-auth';
+import { type Template } from './cloudformation';
+export interface NestedStackTemplates {
+    readonly physicalName: string | undefined;
+    readonly deployedTemplate: Template;
+    readonly generatedTemplate: Template;
+    readonly nestedStackTemplates: {
+        [nestedStackLogicalId: string]: NestedStackTemplates;
+    };
+}
+export interface RootTemplateWithNestedStacks {
+    readonly deployedRootTemplate: Template;
+    readonly nestedStacks: {
+        [nestedStackLogicalId: string]: NestedStackTemplates;
+    };
+}
+/**
+ * Reads the currently deployed template and all of its nested stack templates from CloudFormation.
+ */
+export declare function loadCurrentTemplateWithNestedStacks(rootStackArtifact: CloudFormationStackArtifact, sdk: SDK, retrieveProcessedTemplate?: boolean): Promise<RootTemplateWithNestedStacks>;
+/**
+ * Returns the currently deployed template from CloudFormation that corresponds to `stackArtifact`.
+ */
+export declare function loadCurrentTemplate(stackArtifact: CloudFormationStackArtifact, sdk: SDK, retrieveProcessedTemplate?: boolean): Promise<Template>;

package/lib/api/deployments/nested-stack-helpers.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCurrentTemplateWithNestedStacks = loadCurrentTemplateWithNestedStacks;
+exports.loadCurrentTemplate = loadCurrentTemplate;
+const path = require("path");
+const fs = require("fs-extra");
+const cloudformation_1 = require("./cloudformation");
+const error_1 = require("../../util/error");
+const evaluate_cloudformation_template_1 = require("../evaluate-cloudformation-template");
+/**
+ * Reads the currently deployed template and all of its nested stack templates from CloudFormation.
+ */
+async function loadCurrentTemplateWithNestedStacks(rootStackArtifact, sdk, retrieveProcessedTemplate = false) {
+    const deployedRootTemplate = await loadCurrentTemplate(rootStackArtifact, sdk, retrieveProcessedTemplate);
+    const nestedStacks = await loadNestedStacks(rootStackArtifact, sdk, {
+        generatedTemplate: rootStackArtifact.template,
+        deployedTemplate: deployedRootTemplate,
+        deployedStackName: rootStackArtifact.stackName,
+    });
+    return {
+        deployedRootTemplate,
+        nestedStacks,
+    };
+}
+/**
+ * Returns the currently deployed template from CloudFormation that corresponds to `stackArtifact`.
+ */
+async function loadCurrentTemplate(stackArtifact, sdk, retrieveProcessedTemplate = false) {
+    return loadCurrentStackTemplate(stackArtifact.stackName, sdk, retrieveProcessedTemplate);
+}
+async function loadCurrentStackTemplate(stackName, sdk, retrieveProcessedTemplate = false) {
+    const cfn = sdk.cloudFormation();
+    const stack = await cloudformation_1.CloudFormationStack.lookup(cfn, stackName, retrieveProcessedTemplate);
+    return stack.template();
+}
+async function loadNestedStacks(rootStackArtifact, sdk, parentTemplates) {
+    var _a;
+    const listStackResources = parentTemplates.deployedStackName
+        ? new evaluate_cloudformation_template_1.LazyListStackResources(sdk, parentTemplates.deployedStackName)
+        : undefined;
+    const nestedStacks = {};
+    for (const [nestedStackLogicalId, generatedNestedStackResource] of Object.entries((_a = parentTemplates.generatedTemplate.Resources) !== null && _a !== void 0 ? _a : {})) {
+        if (!isCdkManagedNestedStack(generatedNestedStackResource)) {
+            continue;
+        }
+        const assetPath = generatedNestedStackResource.Metadata['aws:asset:path'];
+        const nestedStackTemplates = await getNestedStackTemplates(rootStackArtifact, assetPath, nestedStackLogicalId, listStackResources, sdk);
+        nestedStacks[nestedStackLogicalId] = {
+            deployedTemplate: nestedStackTemplates.deployedTemplate,
+            generatedTemplate: nestedStackTemplates.generatedTemplate,
+            physicalName: nestedStackTemplates.deployedStackName,
+            nestedStackTemplates: await loadNestedStacks(rootStackArtifact, sdk, nestedStackTemplates),
+        };
+    }
+    return nestedStacks;
+}
+async function getNestedStackTemplates(rootStackArtifact, nestedTemplateAssetPath, nestedStackLogicalId, listStackResources, sdk) {
+    const nestedTemplatePath = path.join(rootStackArtifact.assembly.directory, nestedTemplateAssetPath);
+    // CFN generates the nested stack name in the form `ParentStackName-NestedStackLogicalID-SomeHashWeCan'tCompute,
+    // the arn is of the form: arn:aws:cloudformation:region:123456789012:stack/NestedStackName/AnotherHashWeDon'tNeed
+    // so we get the ARN and manually extract the name.
+    const nestedStackArn = await getNestedStackArn(nestedStackLogicalId, listStackResources);
+    const deployedStackName = nestedStackArn === null || nestedStackArn === void 0 ? void 0 : nestedStackArn.slice(nestedStackArn.indexOf('/') + 1, nestedStackArn.lastIndexOf('/'));
+    return {
+        generatedTemplate: JSON.parse(fs.readFileSync(nestedTemplatePath, 'utf-8')),
+        deployedTemplate: deployedStackName ? await loadCurrentStackTemplate(deployedStackName, sdk) : {},
+        deployedStackName,
+    };
+}
+async function getNestedStackArn(nestedStackLogicalId, listStackResources) {
+    var _a;
+    try {
+        const stackResources = await (listStackResources === null || listStackResources === void 0 ? void 0 : listStackResources.listStackResources());
+        return (_a = stackResources === null || stackResources === void 0 ? void 0 : stackResources.find((sr) => sr.LogicalResourceId === nestedStackLogicalId)) === null || _a === void 0 ? void 0 : _a.PhysicalResourceId;
+    }
+    catch (e) {
+        if ((0, error_1.formatErrorMessage)(e).startsWith('Stack with id ') && (0, error_1.formatErrorMessage)(e).endsWith(' does not exist')) {
+            return;
+        }
+        throw e;
+    }
+}
+function isCdkManagedNestedStack(stackResource) {
+    return (stackResource.Type === 'AWS::CloudFormation::Stack' &&
+        stackResource.Metadata &&
+        stackResource.Metadata['aws:asset:path']);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nested-stack-helpers.js","sourceRoot":"","sources":["nested-stack-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport type { CloudFormationStackArtifact } from '@aws-cdk/cx-api';\nimport * as fs from 'fs-extra';\nimport type { SDK } from '../aws-auth';\nimport { CloudFormationStack, type Template } from './cloudformation';\nimport { formatErrorMessage } from '../../util/error';\nimport { LazyListStackResources, type ListStackResources } from '../evaluate-cloudformation-template';\n\nexport interface NestedStackTemplates {\n  readonly physicalName: string | undefined;\n  readonly deployedTemplate: Template;\n  readonly generatedTemplate: Template;\n  readonly nestedStackTemplates: {\n    [nestedStackLogicalId: string]: NestedStackTemplates;\n  };\n}\n\nexport interface RootTemplateWithNestedStacks {\n  readonly deployedRootTemplate: Template;\n  readonly nestedStacks: {\n    [nestedStackLogicalId: string]: NestedStackTemplates;\n  };\n}\n\n/**\n * Reads the currently deployed template and all of its nested stack templates from CloudFormation.\n */\nexport async function loadCurrentTemplateWithNestedStacks(\n  rootStackArtifact: CloudFormationStackArtifact,\n  sdk: SDK,\n  retrieveProcessedTemplate: boolean = false,\n): Promise<RootTemplateWithNestedStacks> {\n  const deployedRootTemplate = await loadCurrentTemplate(rootStackArtifact, sdk, retrieveProcessedTemplate);\n  const nestedStacks = await loadNestedStacks(rootStackArtifact, sdk, {\n    generatedTemplate: rootStackArtifact.template,\n    deployedTemplate: deployedRootTemplate,\n    deployedStackName: rootStackArtifact.stackName,\n  });\n\n  return {\n    deployedRootTemplate,\n    nestedStacks,\n  };\n}\n\n/**\n * Returns the currently deployed template from CloudFormation that corresponds to `stackArtifact`.\n */\nexport async function loadCurrentTemplate(\n  stackArtifact: CloudFormationStackArtifact,\n  sdk: SDK,\n  retrieveProcessedTemplate: boolean = false,\n): Promise<Template> {\n  return loadCurrentStackTemplate(stackArtifact.stackName, sdk, retrieveProcessedTemplate);\n}\n\nasync function loadCurrentStackTemplate(\n  stackName: string,\n  sdk: SDK,\n  retrieveProcessedTemplate: boolean = false,\n): Promise<Template> {\n  const cfn = sdk.cloudFormation();\n  const stack = await CloudFormationStack.lookup(cfn, stackName, retrieveProcessedTemplate);\n  return stack.template();\n}\n\nasync function loadNestedStacks(\n  rootStackArtifact: CloudFormationStackArtifact,\n  sdk: SDK,\n  parentTemplates: StackTemplates,\n): Promise<{ [nestedStackLogicalId: string]: NestedStackTemplates }> {\n  const listStackResources = parentTemplates.deployedStackName\n    ? new LazyListStackResources(sdk, parentTemplates.deployedStackName)\n    : undefined;\n  const nestedStacks: { [nestedStackLogicalId: string]: NestedStackTemplates } = {};\n  for (const [nestedStackLogicalId, generatedNestedStackResource] of Object.entries(\n    parentTemplates.generatedTemplate.Resources ?? {},\n  )) {\n    if (!isCdkManagedNestedStack(generatedNestedStackResource)) {\n      continue;\n    }\n\n    const assetPath = generatedNestedStackResource.Metadata['aws:asset:path'];\n    const nestedStackTemplates = await getNestedStackTemplates(\n      rootStackArtifact,\n      assetPath,\n      nestedStackLogicalId,\n      listStackResources,\n      sdk,\n    );\n\n    nestedStacks[nestedStackLogicalId] = {\n      deployedTemplate: nestedStackTemplates.deployedTemplate,\n      generatedTemplate: nestedStackTemplates.generatedTemplate,\n      physicalName: nestedStackTemplates.deployedStackName,\n      nestedStackTemplates: await loadNestedStacks(rootStackArtifact, sdk, nestedStackTemplates),\n    };\n  }\n\n  return nestedStacks;\n}\n\nasync function getNestedStackTemplates(\n  rootStackArtifact: CloudFormationStackArtifact,\n  nestedTemplateAssetPath: string,\n  nestedStackLogicalId: string,\n  listStackResources: ListStackResources | undefined,\n  sdk: SDK,\n): Promise<StackTemplates> {\n  const nestedTemplatePath = path.join(rootStackArtifact.assembly.directory, nestedTemplateAssetPath);\n\n  // CFN generates the nested stack name in the form `ParentStackName-NestedStackLogicalID-SomeHashWeCan'tCompute,\n  // the arn is of the form: arn:aws:cloudformation:region:123456789012:stack/NestedStackName/AnotherHashWeDon'tNeed\n  // so we get the ARN and manually extract the name.\n  const nestedStackArn = await getNestedStackArn(nestedStackLogicalId, listStackResources);\n  const deployedStackName = nestedStackArn?.slice(nestedStackArn.indexOf('/') + 1, nestedStackArn.lastIndexOf('/'));\n\n  return {\n    generatedTemplate: JSON.parse(fs.readFileSync(nestedTemplatePath, 'utf-8')),\n    deployedTemplate: deployedStackName ? await loadCurrentStackTemplate(deployedStackName, sdk) : {},\n    deployedStackName,\n  };\n}\n\nasync function getNestedStackArn(\n  nestedStackLogicalId: string,\n  listStackResources?: ListStackResources,\n): Promise<string | undefined> {\n  try {\n    const stackResources = await listStackResources?.listStackResources();\n    return stackResources?.find((sr) => sr.LogicalResourceId === nestedStackLogicalId)?.PhysicalResourceId;\n  } catch (e: any) {\n    if (formatErrorMessage(e).startsWith('Stack with id ') && formatErrorMessage(e).endsWith(' does not exist')) {\n      return;\n    }\n    throw e;\n  }\n}\n\nfunction isCdkManagedNestedStack(stackResource: any): stackResource is NestedStackResource {\n  return (\n    stackResource.Type === 'AWS::CloudFormation::Stack' &&\n    stackResource.Metadata &&\n    stackResource.Metadata['aws:asset:path']\n  );\n}\n\ninterface StackTemplates {\n  readonly generatedTemplate: any;\n  readonly deployedTemplate: any;\n  readonly deployedStackName: string | undefined;\n}\n\ninterface NestedStackResource {\n  readonly Metadata: { 'aws:asset:path': string };\n  readonly Properties: any;\n}\n"]}