fix: do not print event diff when the ids have changed (#2252)

Fixes #2248

### Description of the bug
When checking for the database diff, the `eventRootProperty` and
`eventResourcesField` of events were shown as changing like:
```│       └ events
│          ├[~]  event aws.autoscaling@EC2InstanceLaunchLifecycleAction
│          │  └      - rootProperty: EC2InstanceLaunchLifecycleAction
│          │         + rootProperty: EC2InstanceLaunchLifecycleAction
│          │         - resourcesField: [EC2InstanceLaunchLifecycleAction.AutoScalingGroupName]
│          │         + resourcesField: [EC2InstanceLaunchLifecycleAction.AutoScalingGroupName]
```
This was caused because they used `JsonEq` for comparison, which also
checked if they has the same `$id` in the db, which is not always true
(e.g. when adding a new resource to the db, ids will change).

### Solution
Do not compare the ids, but use the existing functions to compare the
`EvenTypeDefinition` in these properties.

### Testing
- Ran the diff script on databases where the ids had changed, diff is
now correct.
  - Added a unit test

Co-authored-by: Leon Michalski <[email protected]>

Author: leonmk-aws

packages/@aws-cdk/service-spec-importers/src/db-diff.ts

@@ -22,7 +22,9 @@ import {
   UpdatedEvent,
   UpdatedEventTypeDefinition,
   UpdatedEventProperty,
+  ResourceField,
 } from '@aws-cdk/service-spec-types';
+import { Reference } from '@cdklabs/tskb';
 import {
   diffByKey,
   collapseUndefined,
@@ -204,8 +206,8 @@ export class DbDiff {
       description: diffScalar(a, b, 'description'),
       source: diffScalar(a, b, 'source'),
       detailType: diffScalar(a, b, 'detailType'),
-      resourcesField: diffField(a, b, 'resourcesField', jsonEq),
-      rootProperty: diffField(a, b, 'rootProperty', jsonEq),
+      resourcesField: diffField(a, b, 'resourcesField', this.eqEventResourcesField.bind(this)),
+      rootProperty: diffField(a, b, 'rootProperty', this.eqEventRootProperty.bind(this)),
       typeDefinitionDiff: this.diffEventTypeDefinitions(a, b),
     } satisfies AllFieldsGiven<UpdatedEvent>);
   }
@@ -254,6 +256,23 @@ export class DbDiff {
     return this.stringifyGenericType(a, this.db1) === this.stringifyGenericType(b, this.db2);
   }
 
+  private eqEventRootProperty(a: Reference<EventTypeDefinition>, b: Reference<EventTypeDefinition>): boolean {
+    return this.eqEventPropertyType({ type: 'ref', reference: a }, { type: 'ref', reference: b });
+  }
+
+  private eqEventResourcesField(a: ResourceField[], b: ResourceField[]): boolean {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (
+        !this.eqEventPropertyType({ type: 'ref', reference: a[i].type }, { type: 'ref', reference: b[i].type }) ||
+        a[i].fieldName !== b[i].fieldName
+      ) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   /**
    * Stringify a generic property type for comparison.
    */

packages/@aws-cdk/service-spec-importers/test/db-diff.test.ts

@@ -41,3 +41,29 @@ test('metrics diff only on statistic and ignore dedup key for diff', () => {
     statistic: { new: 'Maximum', old: 'Average' },
   });
 });
+
+test('event diff ignores different $ref IDs when event type definitions have same name', () => {
+  const eventType1 = db1.allocate('eventTypeDefinition', { name: 'WorkSpacesAccess', properties: {} });
+  const eventType2 = db2.allocate('eventTypeDefinition', { name: 'WorkSpacesAccess', properties: {} });
+
+  const event1 = db1.allocate('event', {
+    name: 'aws.workspaces@WorkSpacesAccess',
+    description: 'Test event',
+    source: 'aws.workspaces',
+    detailType: 'WorkSpaces Access',
+    rootProperty: ref(eventType1),
+    resourcesField: [{ type: ref(eventType1), fieldName: 'workspaceId' }],
+  });
+
+  const event2 = db2.allocate('event', {
+    name: 'aws.workspaces@WorkSpacesAccess',
+    description: 'Test event',
+    source: 'aws.workspaces',
+    detailType: 'WorkSpaces Access',
+    rootProperty: ref(eventType2),
+    resourcesField: [{ type: ref(eventType2), fieldName: 'workspaceId' }],
+  });
+
+  const ed = diff.diffEvent(event1, event2);
+  expect(ed).toBeUndefined();
+});