@aws-cdk/cloudformation-diff 2.187.1 → 2.187.2

package/lib/diff/template-and-changeset-diff-merger.js

@@ -1,7 +1,41 @@
 "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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateAndChangeSetDiffMerger = void 0;
-const types = require("../diff/types");
+const diff_1 = require("../diff");
+const types = __importStar(require("../diff/types"));
 /**
  * The purpose of this class is to include differences from the ChangeSet to differences in the TemplateDiff.
  */
@@ -23,6 +57,10 @@ class TemplateAndChangeSetDiffMerger {
         }
         return propertyChange.Target.RequiresRecreation;
     }
+    // If we somehow cannot find the resourceType, then we'll mark it as UNKNOWN, so that can be seen in the diff.
+    static UNKNOWN_RESOURCE_TYPE = 'UNKNOWN_RESOURCE_TYPE';
+    changeSet;
+    changeSetResources;
     constructor(props) {
         this.changeSet = props.changeSet;
         this.changeSetResources = props.changeSetResources ?? this.convertDescribeChangeSetOutputToChangeSetResources(this.changeSet);
@@ -98,6 +136,243 @@ class TemplateAndChangeSetDiffMerger {
             }
         });
     }
+    /**
+     * Adds property changes that the change set reports for a resource that the template diff already
+     * surfaced, but that the template diff did not pick up on its own.
+     *
+     * Without this, a resource that has an ordinary (textual) change to one property would hide a
+     * second change to a *different* property that is only resolved at deploy time (e.g. a property
+     * whose value comes from an SSM parameter or a CloudFormation dynamic reference). That hidden
+     * change might even be a replacement, so silently dropping it is exactly the class of bug that
+     * issue #641 is about - just on a resource that happens to also have a visible change.
+     *
+     * This complements `addChangeSetResourcesNotInTemplateDiff`, which handles resources that are
+     * entirely absent from the template diff.
+     *
+     * @param logicalId - the logical ID of the resource (already present in the template diff)
+     * @param change - the resource difference to augment (mutated in place)
+     */
+    addChangeSetPropertiesNotInTemplateDiff(logicalId, change) {
+        // Same guard as the impact-refinement path: the change set describes the post-transform
+        // resource for SAM, so its property information does not line up with the template.
+        // `resourceType` getter throws if the type changed, so check that first.
+        if ((change.resourceTypeChanged === true) || change.resourceType?.includes('AWS::Serverless')) {
+            return;
+        }
+        const propertyReplacementModes = this.changeSetResources[logicalId]?.propertyReplacementModes;
+        if (!propertyReplacementModes) {
+            return;
+        }
+        const resourceChange = this.findResourceChange(logicalId);
+        for (const [propertyName, { replacementMode }] of Object.entries(propertyReplacementModes)) {
+            // Properties the template diff already flagged are owned by the impact-refinement path.
+            if (propertyName in change.propertyUpdates) {
+                continue;
+            }
+            const changeImpact = changeImpactForReplacementMode(replacementMode);
+            if (changeImpact === undefined) {
+                // The change set does not actually consider this a (meaningful) change.
+                continue;
+            }
+            const { oldValue, newValue } = this.changeSetPropertyValues(resourceChange, propertyName);
+            const propertyDiff = new types.PropertyDifference(oldValue, newValue, { changeImpact });
+            propertyDiff.isDifferent = true;
+            change.setPropertyChange(propertyName, propertyDiff);
+        }
+    }
+    /**
+     * Adds resources to the template diff that the change set reports as changing, but that the
+     * template diff did not surface on its own.
+     *
+     * This happens when the local template is byte-for-byte identical between the current and
+     * target state, yet a value that is only resolved at deploy time changes - for example an
+     * SSM parameter referenced through `AWS::SSM::Parameter::Value<...>` or a CloudFormation
+     * dynamic reference (`{{resolve:ssm:...}}`). CloudFormation detects these in the change set
+     * even though a pure template diff cannot, so we synthesize a `ResourceDifference` from the
+     * change set's before/after data.
+     *
+     * @param resourceDiffs - the resource differences to add to (mutated in place)
+     * @param resourcesInTemplateDiff - the logical IDs that the template diff already reported as
+     *   changed, captured *before* any change-set overrides were applied. Those resources are
+     *   owned by the override path and are skipped here so we never clobber more accurate
+     *   template-derived information with change-set-only data.
+     */
+    addChangeSetResourcesNotInTemplateDiff(resourceDiffs, resourcesInTemplateDiff) {
+        for (const resourceChange of this.changeSet?.Changes ?? []) {
+            const rc = resourceChange.ResourceChange;
+            const logicalId = rc?.LogicalResourceId;
+            if (!rc || !logicalId) {
+                continue;
+            }
+            // Additions, removals and imports are already reflected in the template diff (a new or
+            // deleted resource shows up textually), or are handled by the dedicated import path. We
+            // only need to synthesize changes for modifications that are invisible to a textual diff.
+            if (rc.Action !== 'Modify') {
+                continue;
+            }
+            // The template diff already produced a difference for this resource, so the override path
+            // is responsible for it. Don't replace it with change-set-only data.
+            if (resourcesInTemplateDiff.has(logicalId)) {
+                continue;
+            }
+            // CFN applies the SAM transform before creating the changeset, so changeset entries for
+            // SAM resources describe the transformed (e.g. Lambda) resource and won't line up with the
+            // SAM resource in the template. Skip them to avoid rendering a bogus diff.
+            if (rc.ResourceType?.includes('AWS::Serverless')) {
+                continue;
+            }
+            const resourceDiff = this.resourceDifferenceFromChangeSetResource(rc);
+            if (resourceDiff?.isDifferent) {
+                resourceDiffs.set(logicalId, resourceDiff);
+            }
+        }
+    }
+    /**
+     * Build a `ResourceDifference` purely from a change set's `ResourceChange`.
+     *
+     * Prefers the rich `BeforeContext`/`AfterContext` (the full resource definition before and
+     * after the change, included when the change set is described with `IncludePropertyValues`),
+     * and falls back to the per-property `BeforeValue`/`AfterValue` carried in the change details.
+     *
+     * @returns the synthesized difference, or `undefined` if there is not enough information to
+     *   build a meaningful before/after comparison.
+     */
+    resourceDifferenceFromChangeSetResource(rc) {
+        const resourceType = rc.ResourceType;
+        let oldResource;
+        let newResource;
+        const oldFromContext = this.parseResourceContext(rc.BeforeContext, resourceType);
+        const newFromContext = this.parseResourceContext(rc.AfterContext, resourceType);
+        if (oldFromContext !== undefined && newFromContext !== undefined) {
+            oldResource = oldFromContext;
+            newResource = newFromContext;
+        }
+        else {
+            // The full before/after context was not requested/returned; reconstruct the resource
+            // from the individual property changes instead.
+            const fromDetails = this.resourcesFromChangeDetails(rc, resourceType);
+            oldResource = fromDetails.oldResource;
+            newResource = fromDetails.newResource;
+        }
+        if (oldResource === undefined || newResource === undefined) {
+            return undefined;
+        }
+        const resourceDiff = (0, diff_1.diffResource)(oldResource, newResource, rc.LogicalResourceId);
+        // Refine the change impact (replacement vs. update) using the change set, exactly like we do
+        // for resources that originate from the template diff.
+        this.overrideDiffResourceChangeImpactWithChangeSetChangeImpact(rc.LogicalResourceId, resourceDiff);
+        return resourceDiff;
+    }
+    /**
+     * Parse a change set `BeforeContext`/`AfterContext` into a resource object.
+     *
+     * The context is the resource's definition (Properties, Metadata, etc.) but does *not* include
+     * the resource `Type`, so we splice it back in (using the change set's reported type) to allow
+     * the diff machinery to compare like-for-like and look up replacement information.
+     */
+    parseResourceContext(context, resourceType) {
+        if (context === undefined || context === null) {
+            return undefined;
+        }
+        let parsed;
+        if (typeof context === 'string') {
+            try {
+                parsed = JSON.parse(context);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        else {
+            parsed = context;
+        }
+        if (typeof parsed !== 'object' || parsed === null) {
+            return undefined;
+        }
+        return {
+            Type: resourceType ?? TemplateAndChangeSetDiffMerger.UNKNOWN_RESOURCE_TYPE,
+            ...parsed,
+        };
+    }
+    /**
+     * Reconstruct (partial) before/after resource definitions from the per-property change details.
+     *
+     * This is the fallback used when `BeforeContext`/`AfterContext` are not available (for example
+     * when the change set was described without `IncludePropertyValues`). Only properties that
+     * carry a before or after value contribute to the reconstructed resources.
+     */
+    resourcesFromChangeDetails(rc, resourceType) {
+        const oldProperties = {};
+        const newProperties = {};
+        let hasData = false;
+        for (const detail of rc.Details ?? []) {
+            const target = detail.Target;
+            if (target?.Attribute !== 'Properties' || !target.Name) {
+                continue;
+            }
+            if (target.BeforeValue !== undefined) {
+                oldProperties[target.Name] = tryJsonParse(target.BeforeValue);
+                hasData = true;
+            }
+            if (target.AfterValue !== undefined) {
+                newProperties[target.Name] = tryJsonParse(target.AfterValue);
+                hasData = true;
+            }
+        }
+        if (!hasData) {
+            return { oldResource: undefined, newResource: undefined };
+        }
+        const type = resourceType ?? TemplateAndChangeSetDiffMerger.UNKNOWN_RESOURCE_TYPE;
+        return {
+            oldResource: { Type: type, Properties: oldProperties },
+            newResource: { Type: type, Properties: newProperties },
+        };
+    }
+    /**
+     * Find the raw `ResourceChange` for a given logical ID in the change set.
+     */
+    findResourceChange(logicalId) {
+        for (const resourceChange of this.changeSet?.Changes ?? []) {
+            if (resourceChange.ResourceChange?.LogicalResourceId === logicalId) {
+                return resourceChange.ResourceChange;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Determine the before/after value of a single property from the change set.
+     *
+     * Prefers the per-property `BeforeValue`/`AfterValue` carried in the change details, then the
+     * `BeforeContext`/`AfterContext` resource snapshots, and finally falls back to empty-object
+     * placeholders so the property still renders as a change (with the impact derived from the
+     * change set) even when no concrete values were returned.
+     */
+    changeSetPropertyValues(resourceChange, propertyName) {
+        let oldValue;
+        let newValue;
+        for (const detail of resourceChange?.Details ?? []) {
+            const target = detail.Target;
+            if (target?.Attribute === 'Properties' && target.Name === propertyName) {
+                if (target.BeforeValue !== undefined) {
+                    oldValue = tryJsonParse(target.BeforeValue);
+                }
+                if (target.AfterValue !== undefined) {
+                    newValue = tryJsonParse(target.AfterValue);
+                }
+            }
+        }
+        if (oldValue === undefined) {
+            oldValue = contextProperties(resourceChange?.BeforeContext)?.[propertyName];
+        }
+        if (newValue === undefined) {
+            newValue = contextProperties(resourceChange?.AfterContext)?.[propertyName];
+        }
+        // PropertyDifference requires at least one defined side; use a placeholder otherwise.
+        return {
+            oldValue: oldValue !== undefined ? oldValue : {},
+            newValue: newValue !== undefined ? newValue : {},
+        };
+    }
     addImportInformationFromChangeset(resourceDiffs) {
         const imports = this.findResourceImports();
         resourceDiffs.forEachDifference((logicalId, change) => {
@@ -117,6 +392,57 @@ class TemplateAndChangeSetDiffMerger {
     }
 }
 exports.TemplateAndChangeSetDiffMerger = TemplateAndChangeSetDiffMerger;
-// If we somehow cannot find the resourceType, then we'll mark it as UNKNOWN, so that can be seen in the diff.
-TemplateAndChangeSetDiffMerger.UNKNOWN_RESOURCE_TYPE = 'UNKNOWN_RESOURCE_TYPE';
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-and-changeset-diff-merger.js","sourceRoot":"","sources":["template-and-changeset-diff-merger.ts"],"names":[],"mappings":";;;AAGA,uCAAuC;AAsBvC;;GAEG;AACH,MAAa,8BAA8B;IAClC,MAAM,CAAC,iCAAiC,CAAC,cAA6C;QAC3F,IAAI,cAAc,CAAC,MAAM,EAAE,kBAAkB,KAAK,SAAS,EAAE,CAAC;YAC5D,+FAA+F;YAC/F,OAAO,eAAe,CAAC;QACzB,CAAC;QAED,IAAI,cAAc,CAAC,MAAM,CAAC,kBAAkB,KAAK,QAAQ,EAAE,CAAC;YAC1D,QAAQ,cAAc,CAAC,UAAU,EAAE,CAAC;gBAClC,KAAK,QAAQ;oBACX,OAAO,QAAQ,CAAC;gBAClB,KAAK,SAAS;oBACZ,8EAA8E;oBAC9E,+GAA+G;oBAC/G,OAAO,eAAe,CAAC;YAC3B,CAAC;QACH,CAAC;QAED,OAAO,cAAc,CAAC,MAAM,CAAC,kBAA4C,CAAC;IAC5E,CAAC;IAQD,YAAY,KAA0C;QACpD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC;QACjC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,IAAI,IAAI,CAAC,kDAAkD,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAChI,CAAC;IAED;;OAEG;IACK,kDAAkD,CAAC,SAAkC;QAC3F,MAAM,kBAAkB,GAA6B,EAAE,CAAC;QACxD,KAAK,MAAM,cAAc,IAAI,SAAS,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC;YACrD,IAAI,cAAc,CAAC,cAAc,EAAE,iBAAiB,KAAK,SAAS,EAAE,CAAC;gBACnE,SAAS,CAAC,yBAAyB;YACrC,CAAC;YAED,MAAM,wBAAwB,GAAqC,EAAE,CAAC;YACtE,KAAK,MAAM,cAAc,IAAI,cAAc,CAAC,cAAc,CAAC,OAAO,IAAI,EAAE,EAAE,CAAC,CAAC,iEAAiE;gBAC3I,IAAI,cAAc,CAAC,MAAM,EAAE,SAAS,KAAK,YAAY,IAAI,cAAc,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;oBACpF,wBAAwB,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG;wBACrD,eAAe,EAAE,8BAA8B,CAAC,iCAAiC,CAAC,cAAc,CAAC;qBAClG,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,kBAAkB,CAAC,cAAc,CAAC,cAAc,CAAC,iBAAiB,CAAC,GAAG;gBACpE,mBAAmB,EAAE,cAAc,CAAC,cAAc,CAAC,WAAW,KAAK,MAAM;gBACzE,YAAY,EAAE,cAAc,CAAC,cAAc,CAAC,YAAY,IAAI,8BAA8B,CAAC,qBAAqB,EAAE,gEAAgE;gBAClL,wBAAwB,EAAE,wBAAwB;aACnD,CAAC;QACJ,CAAC;QAED,OAAO,kBAAkB,CAAC;IAC5B,CAAC;IAED;;;;OAIG;IACI,yDAAyD,CAAC,SAAiB,EAAE,MAAgC;QAClH,6DAA6D;QAC7D,IAAI,CAAC,MAAM,CAAC,mBAAmB,KAAK,IAAI,CAAC,IAAI,MAAM,CAAC,YAAY,EAAE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC;YAC9F,4HAA4H;YAC5H,OAAO;QACT,CAAC;QACD,MAAM,CAAC,iBAAiB,CAAC,CAAC,IAA0B,EAAE,IAAY,EAAE,KAA4D,EAAE,EAAE;YAClI,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;gBACxB,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE,CAAC;oBACvC,KAAuC,CAAC,YAAY,GAAG,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC;oBACtF,KAAuC,CAAC,WAAW,GAAG,KAAK,CAAC;oBAC7D,OAAO;gBACT,CAAC;gBAED,MAAM,yCAAyC,GAAG,CAAC,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,eAAe,CAAC;gBAC7I,QAAQ,yCAAyC,EAAE,CAAC;oBAClD,KAAK,QAAQ;wBACV,KAAuC,CAAC,YAAY,GAAG,KAAK,CAAC,cAAc,CAAC,YAAY,CAAC;wBAC1F,MAAM;oBACR,KAAK,OAAO;wBACT,KAAuC,CAAC,YAAY,GAAG,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC;wBACzF,MAAM;oBACR,KAAK,eAAe;wBACjB,KAAuC,CAAC,YAAY,GAAG,KAAK,CAAC,cAAc,CAAC,WAAW,CAAC;wBACzF,MAAM;oBACR,KAAK,SAAS;wBACX,KAAuC,CAAC,YAAY,GAAG,KAAK,CAAC,cAAc,CAAC,SAAS,CAAC;wBACtF,KAAuC,CAAC,WAAW,GAAG,KAAK,CAAC;wBAC7D,MAAM;oBACR,8DAA8D;gBAChE,CAAC;YACH,CAAC;iBAAM,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;gBAC5B,QAAQ,IAAI,EAAE,CAAC;oBACb,KAAK,UAAU;wBACb,wFAAwF;wBACxF,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,IAAI,KAAK,CAAC,UAAU,CAAS,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;wBAChG,MAAM;gBACV,CAAC;YACH,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,iCAAiC,CAAC,aAAmF;QAC1H,MAAM,OAAO,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3C,aAAa,CAAC,iBAAiB,CAAC,CAAC,SAAiB,EAAE,MAAgC,EAAE,EAAE;YACtF,IAAI,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;gBAChC,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC;YACzB,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,mBAAmB;QACxB,MAAM,0BAA0B,GAAG,EAAE,CAAC;QACtC,KAAK,MAAM,cAAc,IAAI,IAAI,CAAC,SAAS,EAAE,OAAO,IAAI,EAAE,EAAE,CAAC;YAC3D,IAAI,cAAc,CAAC,cAAc,EAAE,MAAM,KAAK,QAAQ,EAAE,CAAC;gBACvD,0BAA0B,CAAC,IAAI,CAAC,cAAc,CAAC,cAAc,CAAC,iBAAiB,CAAC,CAAC;YACnF,CAAC;QACH,CAAC;QAED,OAAO,0BAA0B,CAAC;IACpC,CAAC;;AA9HH,wEA+HC;AA1GC,8GAA8G;AAC/F,oDAAqB,GAAG,uBAAuB,CAAC","sourcesContent":["// The SDK is only used to reference `DescribeChangeSetOutput`, so the SDK is added as a devDependency.\n// The SDK should not make network calls here\nimport type { DescribeChangeSetOutput as DescribeChangeSet, ResourceChangeDetail as RCD } from '@aws-sdk/client-cloudformation';\nimport * as types from '../diff/types';\n\nexport type DescribeChangeSetOutput = DescribeChangeSet;\ntype ChangeSetResourceChangeDetail = RCD;\n\ninterface TemplateAndChangeSetDiffMergerOptions {\n  /*\n   * Only specifiable for testing. Otherwise, this is the datastructure that the changeSet is converted into so\n   * that we only pay attention to the subset of changeSet properties that are relevant for computing the diff.\n   *\n   * @default - the changeSet is converted into this datastructure.\n  */\n  readonly changeSetResources?: types.ChangeSetResources;\n}\n\nexport interface TemplateAndChangeSetDiffMergerProps extends TemplateAndChangeSetDiffMergerOptions {\n  /*\n   * The changeset that will be read and merged into the template diff.\n  */\n  readonly changeSet: DescribeChangeSetOutput;\n}\n\n/**\n * The purpose of this class is to include differences from the ChangeSet to differences in the TemplateDiff.\n */\nexport class TemplateAndChangeSetDiffMerger {\n  public static determineChangeSetReplacementMode(propertyChange: ChangeSetResourceChangeDetail): types.ReplacementModes {\n    if (propertyChange.Target?.RequiresRecreation === undefined) {\n      // We can't determine if the resource will be replaced or not. That's what conditionally means.\n      return 'Conditionally';\n    }\n\n    if (propertyChange.Target.RequiresRecreation === 'Always') {\n      switch (propertyChange.Evaluation) {\n        case 'Static':\n          return 'Always';\n        case 'Dynamic':\n          // If Evaluation is 'Dynamic', then this may cause replacement, or it may not.\n          // see 'Replacement': https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ResourceChange.html\n          return 'Conditionally';\n      }\n    }\n\n    return propertyChange.Target.RequiresRecreation as types.ReplacementModes;\n  }\n\n  // If we somehow cannot find the resourceType, then we'll mark it as UNKNOWN, so that can be seen in the diff.\n  private static UNKNOWN_RESOURCE_TYPE = 'UNKNOWN_RESOURCE_TYPE';\n\n  public changeSet: DescribeChangeSetOutput | undefined;\n  public changeSetResources: types.ChangeSetResources;\n\n  constructor(props: TemplateAndChangeSetDiffMergerProps) {\n    this.changeSet = props.changeSet;\n    this.changeSetResources = props.changeSetResources ?? this.convertDescribeChangeSetOutputToChangeSetResources(this.changeSet);\n  }\n\n  /**\n   * Read resources from the changeSet, extracting information into ChangeSetResources.\n   */\n  private convertDescribeChangeSetOutputToChangeSetResources(changeSet: DescribeChangeSetOutput): types.ChangeSetResources {\n    const changeSetResources: types.ChangeSetResources = {};\n    for (const resourceChange of changeSet.Changes ?? []) {\n      if (resourceChange.ResourceChange?.LogicalResourceId === undefined) {\n        continue; // Being defensive, here.\n      }\n\n      const propertyReplacementModes: types.PropertyReplacementModeMap = {};\n      for (const propertyChange of resourceChange.ResourceChange.Details ?? []) { // Details is only included if resourceChange.Action === 'Modify'\n        if (propertyChange.Target?.Attribute === 'Properties' && propertyChange.Target.Name) {\n          propertyReplacementModes[propertyChange.Target.Name] = {\n            replacementMode: TemplateAndChangeSetDiffMerger.determineChangeSetReplacementMode(propertyChange),\n          };\n        }\n      }\n\n      changeSetResources[resourceChange.ResourceChange.LogicalResourceId] = {\n        resourceWasReplaced: resourceChange.ResourceChange.Replacement === 'True',\n        resourceType: resourceChange.ResourceChange.ResourceType ?? TemplateAndChangeSetDiffMerger.UNKNOWN_RESOURCE_TYPE, // DescribeChangeSet doesn't promise to have the ResourceType...\n        propertyReplacementModes: propertyReplacementModes,\n      };\n    }\n\n    return changeSetResources;\n  }\n\n  /**\n   * This is writing over the \"ChangeImpact\" that was computed from the template difference, and instead using the ChangeImpact that is included from the ChangeSet.\n   * Using the ChangeSet ChangeImpact is more accurate. The ChangeImpact tells us what the consequence is of changing the field. If changing the field causes resource\n   * replacement (e.g., changing the name of an IAM role requires deleting and replacing the role), then ChangeImpact is \"Always\".\n   */\n  public overrideDiffResourceChangeImpactWithChangeSetChangeImpact(logicalId: string, change: types.ResourceDifference) {\n    // resourceType getter throws an error if resourceTypeChanged\n    if ((change.resourceTypeChanged === true) || change.resourceType?.includes('AWS::Serverless')) {\n      // CFN applies the SAM transform before creating the changeset, so the changeset contains no information about SAM resources\n      return;\n    }\n    change.forEachDifference((type: 'Property' | 'Other', name: string, value: types.Difference<any> | types.PropertyDifference<any>) => {\n      if (type === 'Property') {\n        if (!this.changeSetResources[logicalId]) {\n          (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.NO_CHANGE;\n          (value as types.PropertyDifference<any>).isDifferent = false;\n          return;\n        }\n\n        const changingPropertyCausesResourceReplacement = (this.changeSetResources[logicalId].propertyReplacementModes ?? {})[name]?.replacementMode;\n        switch (changingPropertyCausesResourceReplacement) {\n          case 'Always':\n            (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.WILL_REPLACE;\n            break;\n          case 'Never':\n            (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.WILL_UPDATE;\n            break;\n          case 'Conditionally':\n            (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.MAY_REPLACE;\n            break;\n          case undefined:\n            (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.NO_CHANGE;\n            (value as types.PropertyDifference<any>).isDifferent = false;\n            break;\n          // otherwise, defer to the changeImpact from the template diff\n        }\n      } else if (type === 'Other') {\n        switch (name) {\n          case 'Metadata':\n            // we want to ignore metadata changes in the diff, so compare newValue against newValue.\n            change.setOtherChange('Metadata', new types.Difference<string>(value.newValue, value.newValue));\n            break;\n        }\n      }\n    });\n  }\n\n  public addImportInformationFromChangeset(resourceDiffs: types.DifferenceCollection<types.Resource, types.ResourceDifference>) {\n    const imports = this.findResourceImports();\n    resourceDiffs.forEachDifference((logicalId: string, change: types.ResourceDifference) => {\n      if (imports.includes(logicalId)) {\n        change.isImport = true;\n      }\n    });\n  }\n\n  public findResourceImports(): (string | undefined)[] {\n    const importedResourceLogicalIds = [];\n    for (const resourceChange of this.changeSet?.Changes ?? []) {\n      if (resourceChange.ResourceChange?.Action === 'Import') {\n        importedResourceLogicalIds.push(resourceChange.ResourceChange.LogicalResourceId);\n      }\n    }\n\n    return importedResourceLogicalIds;\n  }\n}\n"]}
+/**
+ * Parse a change set property value as JSON, falling back to the raw value.
+ *
+ * Change set property values (e.g. `BeforeValue`/`AfterValue`) are always strings. Some of them
+ * are serialized JSON (such as an IAM `PolicyDocument`), while others are plain scalars. Parsing
+ * lets us compare structured values structurally; if parsing fails we keep the original string.
+ */
+function tryJsonParse(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+/**
+ * Map a change set replacement mode to the corresponding diff `ResourceImpact`.
+ *
+ * Returns `undefined` when the change set does not consider the property a (meaningful) change.
+ */
+function changeImpactForReplacementMode(replacementMode) {
+    switch (replacementMode) {
+        case 'Always':
+            return types.ResourceImpact.WILL_REPLACE;
+        case 'Never':
+            return types.ResourceImpact.WILL_UPDATE;
+        case 'Conditionally':
+            return types.ResourceImpact.MAY_REPLACE;
+        default:
+            return undefined;
+    }
+}
+/**
+ * Parse the `Properties` block out of a change set `BeforeContext`/`AfterContext` snapshot.
+ */
+function contextProperties(context) {
+    if (context === undefined || context === null) {
+        return undefined;
+    }
+    let parsed;
+    if (typeof context === 'string') {
+        try {
+            parsed = JSON.parse(context);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    else {
+        parsed = context;
+    }
+    return parsed && typeof parsed === 'object' ? parsed.Properties : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-and-changeset-diff-merger.js","sourceRoot":"","sources":["template-and-changeset-diff-merger.ts"],"names":[],"mappings":"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","sourcesContent":["// The SDK is only used to reference `DescribeChangeSetOutput`, so the SDK is added as a devDependency.\n// The SDK should not make network calls here\nimport type { DescribeChangeSetOutput as DescribeChangeSet, ResourceChange as RC, ResourceChangeDetail as RCD } from '@aws-sdk/client-cloudformation';\nimport { diffResource } from '../diff';\nimport * as types from '../diff/types';\n\nexport type DescribeChangeSetOutput = DescribeChangeSet;\ntype ChangeSetResourceChangeDetail = RCD;\ntype ChangeSetResourceChange = RC;\n\ninterface TemplateAndChangeSetDiffMergerOptions {\n  /*\n   * Only specifiable for testing. Otherwise, this is the datastructure that the changeSet is converted into so\n   * that we only pay attention to the subset of changeSet properties that are relevant for computing the diff.\n   *\n   * @default - the changeSet is converted into this datastructure.\n  */\n  readonly changeSetResources?: types.ChangeSetResources;\n}\n\nexport interface TemplateAndChangeSetDiffMergerProps extends TemplateAndChangeSetDiffMergerOptions {\n  /*\n   * The changeset that will be read and merged into the template diff.\n  */\n  readonly changeSet: DescribeChangeSetOutput;\n}\n\n/**\n * The purpose of this class is to include differences from the ChangeSet to differences in the TemplateDiff.\n */\nexport class TemplateAndChangeSetDiffMerger {\n  public static determineChangeSetReplacementMode(propertyChange: ChangeSetResourceChangeDetail): types.ReplacementModes {\n    if (propertyChange.Target?.RequiresRecreation === undefined) {\n      // We can't determine if the resource will be replaced or not. That's what conditionally means.\n      return 'Conditionally';\n    }\n\n    if (propertyChange.Target.RequiresRecreation === 'Always') {\n      switch (propertyChange.Evaluation) {\n        case 'Static':\n          return 'Always';\n        case 'Dynamic':\n          // If Evaluation is 'Dynamic', then this may cause replacement, or it may not.\n          // see 'Replacement': https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_ResourceChange.html\n          return 'Conditionally';\n      }\n    }\n\n    return propertyChange.Target.RequiresRecreation as types.ReplacementModes;\n  }\n\n  // If we somehow cannot find the resourceType, then we'll mark it as UNKNOWN, so that can be seen in the diff.\n  private static UNKNOWN_RESOURCE_TYPE = 'UNKNOWN_RESOURCE_TYPE';\n\n  public changeSet: DescribeChangeSetOutput | undefined;\n  public changeSetResources: types.ChangeSetResources;\n\n  constructor(props: TemplateAndChangeSetDiffMergerProps) {\n    this.changeSet = props.changeSet;\n    this.changeSetResources = props.changeSetResources ?? this.convertDescribeChangeSetOutputToChangeSetResources(this.changeSet);\n  }\n\n  /**\n   * Read resources from the changeSet, extracting information into ChangeSetResources.\n   */\n  private convertDescribeChangeSetOutputToChangeSetResources(changeSet: DescribeChangeSetOutput): types.ChangeSetResources {\n    const changeSetResources: types.ChangeSetResources = {};\n    for (const resourceChange of changeSet.Changes ?? []) {\n      if (resourceChange.ResourceChange?.LogicalResourceId === undefined) {\n        continue; // Being defensive, here.\n      }\n\n      const propertyReplacementModes: types.PropertyReplacementModeMap = {};\n      for (const propertyChange of resourceChange.ResourceChange.Details ?? []) { // Details is only included if resourceChange.Action === 'Modify'\n        if (propertyChange.Target?.Attribute === 'Properties' && propertyChange.Target.Name) {\n          propertyReplacementModes[propertyChange.Target.Name] = {\n            replacementMode: TemplateAndChangeSetDiffMerger.determineChangeSetReplacementMode(propertyChange),\n          };\n        }\n      }\n\n      changeSetResources[resourceChange.ResourceChange.LogicalResourceId] = {\n        resourceWasReplaced: resourceChange.ResourceChange.Replacement === 'True',\n        resourceType: resourceChange.ResourceChange.ResourceType ?? TemplateAndChangeSetDiffMerger.UNKNOWN_RESOURCE_TYPE, // DescribeChangeSet doesn't promise to have the ResourceType...\n        propertyReplacementModes: propertyReplacementModes,\n      };\n    }\n\n    return changeSetResources;\n  }\n\n  /**\n   * This is writing over the \"ChangeImpact\" that was computed from the template difference, and instead using the ChangeImpact that is included from the ChangeSet.\n   * Using the ChangeSet ChangeImpact is more accurate. The ChangeImpact tells us what the consequence is of changing the field. If changing the field causes resource\n   * replacement (e.g., changing the name of an IAM role requires deleting and replacing the role), then ChangeImpact is \"Always\".\n   */\n  public overrideDiffResourceChangeImpactWithChangeSetChangeImpact(logicalId: string, change: types.ResourceDifference) {\n    // resourceType getter throws an error if resourceTypeChanged\n    if ((change.resourceTypeChanged === true) || change.resourceType?.includes('AWS::Serverless')) {\n      // CFN applies the SAM transform before creating the changeset, so the changeset contains no information about SAM resources\n      return;\n    }\n    change.forEachDifference((type: 'Property' | 'Other', name: string, value: types.Difference<any> | types.PropertyDifference<any>) => {\n      if (type === 'Property') {\n        if (!this.changeSetResources[logicalId]) {\n          (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.NO_CHANGE;\n          (value as types.PropertyDifference<any>).isDifferent = false;\n          return;\n        }\n\n        const changingPropertyCausesResourceReplacement = (this.changeSetResources[logicalId].propertyReplacementModes ?? {})[name]?.replacementMode;\n        switch (changingPropertyCausesResourceReplacement) {\n          case 'Always':\n            (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.WILL_REPLACE;\n            break;\n          case 'Never':\n            (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.WILL_UPDATE;\n            break;\n          case 'Conditionally':\n            (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.MAY_REPLACE;\n            break;\n          case undefined:\n            (value as types.PropertyDifference<any>).changeImpact = types.ResourceImpact.NO_CHANGE;\n            (value as types.PropertyDifference<any>).isDifferent = false;\n            break;\n          // otherwise, defer to the changeImpact from the template diff\n        }\n      } else if (type === 'Other') {\n        switch (name) {\n          case 'Metadata':\n            // we want to ignore metadata changes in the diff, so compare newValue against newValue.\n            change.setOtherChange('Metadata', new types.Difference<string>(value.newValue, value.newValue));\n            break;\n        }\n      }\n    });\n  }\n\n  /**\n   * Adds property changes that the change set reports for a resource that the template diff already\n   * surfaced, but that the template diff did not pick up on its own.\n   *\n   * Without this, a resource that has an ordinary (textual) change to one property would hide a\n   * second change to a *different* property that is only resolved at deploy time (e.g. a property\n   * whose value comes from an SSM parameter or a CloudFormation dynamic reference). That hidden\n   * change might even be a replacement, so silently dropping it is exactly the class of bug that\n   * issue #641 is about - just on a resource that happens to also have a visible change.\n   *\n   * This complements `addChangeSetResourcesNotInTemplateDiff`, which handles resources that are\n   * entirely absent from the template diff.\n   *\n   * @param logicalId - the logical ID of the resource (already present in the template diff)\n   * @param change - the resource difference to augment (mutated in place)\n   */\n  public addChangeSetPropertiesNotInTemplateDiff(logicalId: string, change: types.ResourceDifference) {\n    // Same guard as the impact-refinement path: the change set describes the post-transform\n    // resource for SAM, so its property information does not line up with the template.\n    // `resourceType` getter throws if the type changed, so check that first.\n    if ((change.resourceTypeChanged === true) || change.resourceType?.includes('AWS::Serverless')) {\n      return;\n    }\n\n    const propertyReplacementModes = this.changeSetResources[logicalId]?.propertyReplacementModes;\n    if (!propertyReplacementModes) {\n      return;\n    }\n\n    const resourceChange = this.findResourceChange(logicalId);\n\n    for (const [propertyName, { replacementMode }] of Object.entries(propertyReplacementModes)) {\n      // Properties the template diff already flagged are owned by the impact-refinement path.\n      if (propertyName in change.propertyUpdates) {\n        continue;\n      }\n\n      const changeImpact = changeImpactForReplacementMode(replacementMode);\n      if (changeImpact === undefined) {\n        // The change set does not actually consider this a (meaningful) change.\n        continue;\n      }\n\n      const { oldValue, newValue } = this.changeSetPropertyValues(resourceChange, propertyName);\n      const propertyDiff = new types.PropertyDifference<any>(oldValue, newValue, { changeImpact });\n      propertyDiff.isDifferent = true;\n      change.setPropertyChange(propertyName, propertyDiff);\n    }\n  }\n\n  /**\n   * Adds resources to the template diff that the change set reports as changing, but that the\n   * template diff did not surface on its own.\n   *\n   * This happens when the local template is byte-for-byte identical between the current and\n   * target state, yet a value that is only resolved at deploy time changes - for example an\n   * SSM parameter referenced through `AWS::SSM::Parameter::Value<...>` or a CloudFormation\n   * dynamic reference (`{{resolve:ssm:...}}`). CloudFormation detects these in the change set\n   * even though a pure template diff cannot, so we synthesize a `ResourceDifference` from the\n   * change set's before/after data.\n   *\n   * @param resourceDiffs - the resource differences to add to (mutated in place)\n   * @param resourcesInTemplateDiff - the logical IDs that the template diff already reported as\n   *   changed, captured *before* any change-set overrides were applied. Those resources are\n   *   owned by the override path and are skipped here so we never clobber more accurate\n   *   template-derived information with change-set-only data.\n   */\n  public addChangeSetResourcesNotInTemplateDiff(\n    resourceDiffs: types.DifferenceCollection<types.Resource, types.ResourceDifference>,\n    resourcesInTemplateDiff: Set<string>,\n  ) {\n    for (const resourceChange of this.changeSet?.Changes ?? []) {\n      const rc = resourceChange.ResourceChange;\n      const logicalId = rc?.LogicalResourceId;\n      if (!rc || !logicalId) {\n        continue;\n      }\n\n      // Additions, removals and imports are already reflected in the template diff (a new or\n      // deleted resource shows up textually), or are handled by the dedicated import path. We\n      // only need to synthesize changes for modifications that are invisible to a textual diff.\n      if (rc.Action !== 'Modify') {\n        continue;\n      }\n\n      // The template diff already produced a difference for this resource, so the override path\n      // is responsible for it. Don't replace it with change-set-only data.\n      if (resourcesInTemplateDiff.has(logicalId)) {\n        continue;\n      }\n\n      // CFN applies the SAM transform before creating the changeset, so changeset entries for\n      // SAM resources describe the transformed (e.g. Lambda) resource and won't line up with the\n      // SAM resource in the template. Skip them to avoid rendering a bogus diff.\n      if (rc.ResourceType?.includes('AWS::Serverless')) {\n        continue;\n      }\n\n      const resourceDiff = this.resourceDifferenceFromChangeSetResource(rc);\n      if (resourceDiff?.isDifferent) {\n        resourceDiffs.set(logicalId, resourceDiff);\n      }\n    }\n  }\n\n  /**\n   * Build a `ResourceDifference` purely from a change set's `ResourceChange`.\n   *\n   * Prefers the rich `BeforeContext`/`AfterContext` (the full resource definition before and\n   * after the change, included when the change set is described with `IncludePropertyValues`),\n   * and falls back to the per-property `BeforeValue`/`AfterValue` carried in the change details.\n   *\n   * @returns the synthesized difference, or `undefined` if there is not enough information to\n   *   build a meaningful before/after comparison.\n   */\n  private resourceDifferenceFromChangeSetResource(rc: ChangeSetResourceChange): types.ResourceDifference | undefined {\n    const resourceType = rc.ResourceType;\n\n    let oldResource: types.Resource | undefined;\n    let newResource: types.Resource | undefined;\n\n    const oldFromContext = this.parseResourceContext(rc.BeforeContext, resourceType);\n    const newFromContext = this.parseResourceContext(rc.AfterContext, resourceType);\n    if (oldFromContext !== undefined && newFromContext !== undefined) {\n      oldResource = oldFromContext;\n      newResource = newFromContext;\n    } else {\n      // The full before/after context was not requested/returned; reconstruct the resource\n      // from the individual property changes instead.\n      const fromDetails = this.resourcesFromChangeDetails(rc, resourceType);\n      oldResource = fromDetails.oldResource;\n      newResource = fromDetails.newResource;\n    }\n\n    if (oldResource === undefined || newResource === undefined) {\n      return undefined;\n    }\n\n    const resourceDiff = diffResource(oldResource, newResource, rc.LogicalResourceId);\n\n    // Refine the change impact (replacement vs. update) using the change set, exactly like we do\n    // for resources that originate from the template diff.\n    this.overrideDiffResourceChangeImpactWithChangeSetChangeImpact(rc.LogicalResourceId!, resourceDiff);\n\n    return resourceDiff;\n  }\n\n  /**\n   * Parse a change set `BeforeContext`/`AfterContext` into a resource object.\n   *\n   * The context is the resource's definition (Properties, Metadata, etc.) but does *not* include\n   * the resource `Type`, so we splice it back in (using the change set's reported type) to allow\n   * the diff machinery to compare like-for-like and look up replacement information.\n   */\n  private parseResourceContext(context: string | object | undefined, resourceType: string | undefined): types.Resource | undefined {\n    if (context === undefined || context === null) {\n      return undefined;\n    }\n\n    let parsed: any;\n    if (typeof context === 'string') {\n      try {\n        parsed = JSON.parse(context);\n      } catch {\n        return undefined;\n      }\n    } else {\n      parsed = context;\n    }\n\n    if (typeof parsed !== 'object' || parsed === null) {\n      return undefined;\n    }\n\n    return {\n      Type: resourceType ?? TemplateAndChangeSetDiffMerger.UNKNOWN_RESOURCE_TYPE,\n      ...parsed,\n    };\n  }\n\n  /**\n   * Reconstruct (partial) before/after resource definitions from the per-property change details.\n   *\n   * This is the fallback used when `BeforeContext`/`AfterContext` are not available (for example\n   * when the change set was described without `IncludePropertyValues`). Only properties that\n   * carry a before or after value contribute to the reconstructed resources.\n   */\n  private resourcesFromChangeDetails(\n    rc: ChangeSetResourceChange,\n    resourceType: string | undefined,\n  ): { oldResource: types.Resource | undefined; newResource: types.Resource | undefined } {\n    const oldProperties: types.PropertyMap = {};\n    const newProperties: types.PropertyMap = {};\n    let hasData = false;\n\n    for (const detail of rc.Details ?? []) {\n      const target = detail.Target;\n      if (target?.Attribute !== 'Properties' || !target.Name) {\n        continue;\n      }\n      if (target.BeforeValue !== undefined) {\n        oldProperties[target.Name] = tryJsonParse(target.BeforeValue);\n        hasData = true;\n      }\n      if (target.AfterValue !== undefined) {\n        newProperties[target.Name] = tryJsonParse(target.AfterValue);\n        hasData = true;\n      }\n    }\n\n    if (!hasData) {\n      return { oldResource: undefined, newResource: undefined };\n    }\n\n    const type = resourceType ?? TemplateAndChangeSetDiffMerger.UNKNOWN_RESOURCE_TYPE;\n    return {\n      oldResource: { Type: type, Properties: oldProperties },\n      newResource: { Type: type, Properties: newProperties },\n    };\n  }\n\n  /**\n   * Find the raw `ResourceChange` for a given logical ID in the change set.\n   */\n  private findResourceChange(logicalId: string): ChangeSetResourceChange | undefined {\n    for (const resourceChange of this.changeSet?.Changes ?? []) {\n      if (resourceChange.ResourceChange?.LogicalResourceId === logicalId) {\n        return resourceChange.ResourceChange;\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Determine the before/after value of a single property from the change set.\n   *\n   * Prefers the per-property `BeforeValue`/`AfterValue` carried in the change details, then the\n   * `BeforeContext`/`AfterContext` resource snapshots, and finally falls back to empty-object\n   * placeholders so the property still renders as a change (with the impact derived from the\n   * change set) even when no concrete values were returned.\n   */\n  private changeSetPropertyValues(\n    resourceChange: ChangeSetResourceChange | undefined,\n    propertyName: string,\n  ): { oldValue: any; newValue: any } {\n    let oldValue: any;\n    let newValue: any;\n\n    for (const detail of resourceChange?.Details ?? []) {\n      const target = detail.Target;\n      if (target?.Attribute === 'Properties' && target.Name === propertyName) {\n        if (target.BeforeValue !== undefined) {\n          oldValue = tryJsonParse(target.BeforeValue);\n        }\n        if (target.AfterValue !== undefined) {\n          newValue = tryJsonParse(target.AfterValue);\n        }\n      }\n    }\n\n    if (oldValue === undefined) {\n      oldValue = contextProperties(resourceChange?.BeforeContext)?.[propertyName];\n    }\n    if (newValue === undefined) {\n      newValue = contextProperties(resourceChange?.AfterContext)?.[propertyName];\n    }\n\n    // PropertyDifference requires at least one defined side; use a placeholder otherwise.\n    return {\n      oldValue: oldValue !== undefined ? oldValue : {},\n      newValue: newValue !== undefined ? newValue : {},\n    };\n  }\n\n  public addImportInformationFromChangeset(resourceDiffs: types.DifferenceCollection<types.Resource, types.ResourceDifference>) {\n    const imports = this.findResourceImports();\n    resourceDiffs.forEachDifference((logicalId: string, change: types.ResourceDifference) => {\n      if (imports.includes(logicalId)) {\n        change.isImport = true;\n      }\n    });\n  }\n\n  public findResourceImports(): (string | undefined)[] {\n    const importedResourceLogicalIds = [];\n    for (const resourceChange of this.changeSet?.Changes ?? []) {\n      if (resourceChange.ResourceChange?.Action === 'Import') {\n        importedResourceLogicalIds.push(resourceChange.ResourceChange.LogicalResourceId);\n      }\n    }\n\n    return importedResourceLogicalIds;\n  }\n}\n\n/**\n * Parse a change set property value as JSON, falling back to the raw value.\n *\n * Change set property values (e.g. `BeforeValue`/`AfterValue`) are always strings. Some of them\n * are serialized JSON (such as an IAM `PolicyDocument`), while others are plain scalars. Parsing\n * lets us compare structured values structurally; if parsing fails we keep the original string.\n */\nfunction tryJsonParse(value: string): any {\n  try {\n    return JSON.parse(value);\n  } catch {\n    return value;\n  }\n}\n\n/**\n * Map a change set replacement mode to the corresponding diff `ResourceImpact`.\n *\n * Returns `undefined` when the change set does not consider the property a (meaningful) change.\n */\nfunction changeImpactForReplacementMode(replacementMode: types.ReplacementModes | undefined): types.ResourceImpact | undefined {\n  switch (replacementMode) {\n    case 'Always':\n      return types.ResourceImpact.WILL_REPLACE;\n    case 'Never':\n      return types.ResourceImpact.WILL_UPDATE;\n    case 'Conditionally':\n      return types.ResourceImpact.MAY_REPLACE;\n    default:\n      return undefined;\n  }\n}\n\n/**\n * Parse the `Properties` block out of a change set `BeforeContext`/`AfterContext` snapshot.\n */\nfunction contextProperties(context: string | object | undefined): { [name: string]: any } | undefined {\n  if (context === undefined || context === null) {\n    return undefined;\n  }\n  let parsed: any;\n  if (typeof context === 'string') {\n    try {\n      parsed = JSON.parse(context);\n    } catch {\n      return undefined;\n    }\n  } else {\n    parsed = context;\n  }\n  return parsed && typeof parsed === 'object' ? parsed.Properties : undefined;\n}\n"]}

package/lib/diff/types.d.ts

@@ -188,6 +188,17 @@ export declare class DifferenceCollection<V, T extends IDifference<V>> {
     get differenceCount(): number;
     get(logicalId: string): T;
     remove(logicalId: string): void;
+    /**
+     * Whether a difference (changed or not) is tracked for the given logical ID.
+     *
+     * Note this is different from `logicalIds`, which only returns IDs that have
+     * an actual change. A logical ID may be present here with a "no-op" difference.
+     */
+    has(logicalId: string): boolean;
+    /**
+     * Set (or replace) the difference tracked for the given logical ID.
+     */
+    set(logicalId: string, diff: T): void;
     get logicalIds(): string[];
     /**
      * Returns a new TemplateDiff which only contains changes for which `predicate`