fix(core): addPropertyOverride doesn't work for all intrinsics (aws#2…

…2294)

There was a previous fix in aws#20608 that attempted to fix addPropertyOverride when intrinisics were involved. This PR fixes an edge case where overrides do not work correctly an object is being replaced with an intrinsic.

For example, there might be the case where the override is an intrinsic and it is overriding an object, not a value.

```
   original: {
     Type: 'MyResourceType',
     Properties: {
       prop1: { subprop: { name: { 'Fn::GetAtt': 'abc' } } }
     }
   }
   override: {
     Properties: {
       prop1: { subprop: { 'Fn::If': ['SomeCondition', {...}, {...}] }}
     }
   }
```

The previous fix only handled cases where the original had an intrinsic, but in the above example the override is the first to hit an intrinsic. This PR adds logic to handle cases where we hit an intrinsic in the original _or_ the override.

fixes aws#19971


----

### All Submissions:

* [ ] Have you followed the guidelines in our [Contributing guide?](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md)

### Adding new Unconventional Dependencies:

* [ ] This PR adds new unconventional dependencies following the process described [here](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md/#adding-new-unconventional-dependencies)

### New Features

* [ ] Have you added the new feature to an [integration test](https://github.com/aws/aws-cdk/blob/main/INTEGRATION_TESTS.md)?
	* [ ] Did you use `yarn integ` to deploy the infrastructure and generate the snapshot (i.e. `yarn integ` without `--dry-run`)?

*By submitting this pull request, I confirm that my contribution is made under the terms of the Apache-2.0 license*

packages/@aws-cdk/core/lib/cfn-resource.ts

@@ -609,6 +609,35 @@ function deepMerge(target: any, ...sources: any[]) {
           }
         }
 
+        /**
+         * There might also be the case where the source is an intrinsic
+         *
+         *    target: {
+         *      Type: 'MyResourceType',
+         *      Properties: {
+         *        prop1: { subprop: { name: { 'Fn::GetAtt': 'abc' } } }
+         *      }
+         *    }
+         *    sources: [ {
+         *      Properties: {
+         *        prop1: { subprop: { 'Fn::If': ['SomeCondition', {...}, {...}] }}
+         *      }
+         *    } ]
+         *
+         * We end up in a place that is the reverse of the above check, the source
+         * becomes an intrinsic before the target
+         *
+         *   target: { subprop: { name: { 'Fn::GetAtt': 'abc' } } }
+         *   sources: [{
+         *     'Fn::If': [ 'MyCondition', {...}, {...} ]
+         *   }]
+         */
+        if (Object.keys(value).length === 1) {
+          if (MERGE_EXCLUDE_KEYS.includes(Object.keys(value)[0])) {
+            target[key] = {};
+          }
+        }
+
         deepMerge(target[key], value);
 
         // if the result of the merge is an empty object, it's because the

packages/@aws-cdk/core/test/resource.test.ts

@@ -726,6 +726,59 @@ describe('resource', () => {
       });
     });
 
+    test('Can override a an object with an intrinsic', () => {
+      // GIVEN
+      const stack = new Stack();
+
+      const condition = new CfnCondition(stack, 'MyCondition', {
+        expression: Fn.conditionEquals('us-east-1', 'us-east-1'),
+      });
+      const resource = new CfnResource(stack, 'MyResource', {
+        type: 'MyResourceType',
+        properties: {
+          prop1: {
+            subprop: {
+              name: Fn.getAtt('resource', 'abc'),
+            },
+          },
+        },
+      });
+      const isEnabled = Fn.conditionIf(condition.logicalId, {
+        Ref: 'AWS::NoValue',
+      }, {
+        name: Fn.getAtt('resource', 'abc'),
+      });
+
+      // WHEN
+      resource.addPropertyOverride('prop1.subprop', isEnabled);
+      const cfn = toCloudFormation(stack);
+
+      // THEN
+      expect(cfn.Resources.MyResource).toEqual({
+        Type: 'MyResourceType',
+        Properties: {
+          prop1: {
+            subprop: {
+              'Fn::If': [
+                'MyCondition',
+                {
+                  Ref: 'AWS::NoValue',
+                },
+                {
+                  name: {
+                    'Fn::GetAtt': [
+                      'resource',
+                      'abc',
+                    ],
+                  },
+                },
+              ],
+            },
+          },
+        },
+      });
+    });
+
     test('overrides allow overriding a nested intrinsic', () => {
       // GIVEN
       const stack = new Stack();