@cap-js/change-tracking 1.0.5 → 1.0.7

package/CHANGELOG.md

@@ -4,6 +4,48 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## Version 1.0.7 - 20.08.24
+
+### Added
+
+ - A global switch to preserve change logs for deleted data
+ - For hierarchical entities, a method to determine their structure and a flag to indicate whether it is a root entity was introduced. For child entities, information about the parent is recorded.
+
+
+### Fixed
+
+- CDS 8 does not support queries for draft-enabled entities on the application service anymore. This was causing: SqliteError: NOT NULL constraint failed: (...).DraftAdministrativeData_DraftUUID
+- CDS 8 deprecated cds.transaction, causing change logs of nested documents to be wrong, replaced with req.event
+- CDS 8 rejects all direct CRUD requests for auto-exposed Compositions in non-draft cases. This was affecting test cases, since the ChangeView falls into this category
+- req._params and req.context are not official APIs and stopped working with CDS 8, replaced with official APIs
+- When running test cases in CDS 8, some requests failed with a status code of 404
+- ServiceEntity is not captured in the ChangeLog table in some cases
+- When modeling an inline entity, a non-existent association and parent ID was recorded
+- Fixed handling, when reqData was undefined
+
+### Changed
+
+- Peer dependency to @sap/cds changed to ">=7"
+- Data marked as personal data using data privacy annotations won't get change-tracked anymore to satisfy product standards
+- Restructured Documentation
+
+
+## Version 1.0.6 - 29.04.24
+
+### Fixed
+
+ -  Storage of wrong ObjectID in some special scenarios
+ -  Missing localization of managed fields
+ -  Views without keys won't get the association and UI facet pushed anymore
+
+### Added
+
+ - A method to disable automatic generation of the UI Facet
+
+### Changed
+
+ - Improved documentation of the @changelog Annotation
+
 ## Version 1.0.5 - 15.01.24
 
 ### Fixed

package/README.md

@@ -1,41 +1,49 @@
 # Change Tracking Plugin for SAP Cloud Application Programming Model (CAP)
 
-[![REUSE status](https://api.reuse.software/badge/github.com/cap-js/change-tracking)](https://api.reuse.software/info/github.com/cap-js/change-tracking)
-
-The `@cap-js/change-tracking` package is a [CDS plugin](https://cap.cloud.sap/docs/node.js/cds-plugins#cds-plugin-packages) providing out-of-the box support for automatic capturing, storing, and viewing of the change records of modeled entities as simple as that:
+a [CDS plugin](https://cap.cloud.sap/docs/node.js/cds-plugins#cds-plugin-packages) for automatic capturing, storing, and viewing of the change records of modeled entities
 
-1. [Install the plugin: `npm add @cap-js/change-tracking`](#setup)
-2. [Add `@changelog` annotations to your CDS models](#annotations)
-3. [Et voilà:](#change-history-view)
-
-<img width="1300" alt="change-history-loading" src="_assets/change-history.gif">
+[![REUSE status](https://api.reuse.software/badge/github.com/cap-js/change-tracking)](https://api.reuse.software/info/github.com/cap-js/change-tracking)
 
+> [!IMPORTANT]
+> This release establishes compatibility with CDS 8.
+> 
+> Since the prior release was using **APIs deprecated in CDS8**, the code was modified significantly to enable compatibility. While we tested extensively, there may still be glitches or unexpected situations which we did not cover. So please **test this release extensively before applying it to productive** scenarios. Please also report any bugs or glitches, ideally by contributing a test-case for us to incorporate.
+> 
+> See the changelog for a full list of changes
 
 
 ### Table of Contents
 
-- [Change Tracking Plugin for SAP Cloud Application Programming Model (CAP)](#change-tracking-plugin-for-sap-cloud-application-programming-model-cap)
-    - [Table of Contents](#table-of-contents)
-  - [Preliminaries](#preliminaries)
-  - [Setup](#setup)
-  - [Annotations](#annotations)
-    - [Human-readable Types and Fields](#human-readable-types-and-fields)
-    - [Human-readable IDs](#human-readable-ids)
-    - [Human-readable Values](#human-readable-values)
-  - [Test-drive locally](#test-drive-locally)
-  - [Change History View](#change-history-view)
-  - [Customizations](#customizations)
-    - [Altered table view](#altered-table-view)
-    - [Disable lazy loading](#disable-lazy-loading)
-  - [Contributing](#contributing)
-  - [Code of Conduct](#code-of-conduct)
-  - [Licensing](#licensing)
-
-
-
-## Preliminaries
-
-In this guide, we use the [Incidents Management reference sample app](https://github.com/cap-js/incidents-app) as the base to add change tracking to. Clone the repository and apply the step-by-step instructions:
+- [Try it Locally](#try-it-locally)
+- [Detailed Explanation](#detailed-explanation)
+  - [Human-readable Types and Fields](#human-readable-types-and-fields)
+  - [Human-readable IDs](#human-readable-ids)
+  - [Human-readable Values](#human-readable-values)
+- [Advanced Options](#advanced-options)
+  - [Altered Table View](#altered-table-view)
+  - [Disable Lazy Loading](#disable-lazy-loading)
+  - [Disable UI Facet generation](#disable-ui-facet-generation)
+    - [Disable Association to Changes Generation](#disable-association-to-changes-generation)
+- [Examples](#examples)
+  - [Specify Object ID](#specify-object-id)
+  - [Tracing Changes](#tracing-changes)
+  - [Don&#39;ts](#donts)
+- [Contributing](#contributing)
+- [Code of Conduct](#code-of-conduct)
+- [Licensing](#licensing)
+
+## Try it Locally
+
+In this guide, we use the [Incidents Management reference sample app](https://github.com/cap-js/incidents-app) as the base to add change tracking to.
+
+1. [Prerequisites](#1-prerequisites)
+2. [Setup](#2-setup)
+3. [Annotations](#3-annotations)
+4. [Testing](#4-testing)
+
+### 1. Prerequisites
+
+Clone the repository and apply the step-by-step instructions:
 
 ```sh
 git clone https://github.com/cap-js/incidents-app
@@ -55,9 +63,7 @@ npm i
 cds w samples/change-tracking
 ```
 
-
-
-## Setup
+### 2. Setup
 
 To enable change tracking, simply add this self-configuring plugin package to your project:
 
@@ -65,12 +71,10 @@ To enable change tracking, simply add this self-configuring plugin package to yo
 npm add @cap-js/change-tracking
 ```
 
-
-
-## Annotations
+### 3. Annotations
 
 > [!WARNING]
-> Please be aware that [**sensitive** or **personal** data](https://cap.cloud.sap/docs/guides/data-privacy/annotations#annotating-personal-data) should not be change tracked, since viewing the log allows users to circumvent [audit-logging](https://cap.cloud.sap/docs/guides/data-privacy/audit-logging#setup).
+> Please be aware that [**sensitive** or **personal** data](https://cap.cloud.sap/docs/guides/data-privacy/annotations#annotating-personal-data) (annotated with `@PersonalData`) is not change tracked, since viewing the log allows users to circumvent [audit-logging](https://cap.cloud.sap/docs/guides/data-privacy/audit-logging#setup).
 
 All we need to do is to identify what should be change-tracked by annotating respective entities and elements in our model with the `@changelog` annotation. Following the [best practice of separation of concerns](https://cap.cloud.sap/docs/guides/domain-modeling#separation-of-concerns), we do so in a separate file _srv/change-tracking.cds_:
 
@@ -92,10 +96,33 @@ The minimal annotation we require for change tracking is `@changelog` on element
 
 Additional identifiers or labels can be added to obtain more *human-readable* change records as described below.
 
+### 4. Testing
+
+With the steps above, we have successfully set up change tracking for our reference application. Let's see that in action.
+
+1. **Start the server**:
+
+```sh
+cds watch
+```
+
+2. **Make a change** on your change-tracked elements. This change will automatically be persisted in the database table (`sap.changelog.ChangeLog`) and made available in a pre-defined view, namely the [Change History view](#change-history-view) for your convenience.
+
+#### Change History View
+
+> [!IMPORTANT]
+> To ensure proper lazy loading of the Change History table, please use **SAPUI5 version 1.120.0** or higher.`<br>`
+> If you wish to *disable* this feature, please see the customization section on how to [disable lazy loading](#disable-lazy-loading).
+
+<img width="1300" alt="change-history" src="_assets/changes.png">
+
+If you have a Fiori Element application, the CDS plugin automatically provides and generates a view `sap.changelog.ChangeView`, the facet of which is automatically added to the Fiori Object Page of your change-tracked entities/elements. In the UI, this corresponds to the *Change History* table which serves to help you to view and search the stored change records of your modeled entities.
+
+## Detailed Explanation
 
 ### Human-readable Types and Fields
 
-By default the implementation looks up *Object Type* names or *Field* namesfrom respective  `@title` or  `@Common.Label` annotations, and applies i18n lookups. If no such annotations are given, the technical names of the respective CDS definitions are displayed.
+By default the implementation looks up *Object Type* names or *Field* names from respective  `@title` or  `@Common.Label` annotations, and applies i18n lookups. If no such annotations are given, the technical names of the respective CDS definitions are displayed.
 
 For example, without the `@title` annotation, changes to conversation entries would show up with the technical entity name:
 
@@ -111,7 +138,6 @@ We get a human-readable display for *Object Type*:
 
 <img width="1300" alt="change-history-type-hr" src="_assets/changes-type-hr-wbox.png">
 
-
 ### Human-readable IDs
 
 The changelog annotations for *Object ID* are defined at entity level.
@@ -120,9 +146,6 @@ These are already human-readable by default, unless the `@changelog` definition
 
 For example, having a `@changelog` annotation without any additional identifiers, changes to conversation entries would show up as simple entity IDs:
 
-```cds
-annotate ProcessorService.Conversations {
-```
 <img width="1300" alt="change-history-id" src="_assets/changes-id-wbox.png">
 
 However, this is not advisable as we cannot easily distinguish between changes. It is more appropriate to annotate as follows:
@@ -130,11 +153,11 @@ However, this is not advisable as we cannot easily distinguish between changes.
 ```cds
 annotate ProcessorService.Conversations with @changelog: [author, timestamp] {
 ```
+
 <img width="1300" alt="change-history-id-hr" src="_assets/changes-id-hr-wbox.png">
 
 Expanding the changelog annotation by additional identifiers `[author, timestamp]`, we can now better identify the `message` change events by their respective author and timestamp.
 
-
 ### Human-readable Values
 
 The changelog annotations for *New Value* and *Old Value* are defined at element level.
@@ -144,7 +167,7 @@ They are already human-readable by default, unless the `@changelog` definition c
 For example, having a `@changelog` annotation without any additional identifiers, changes to incident customer would show up as UUIDs:
 
 ```cds
-  customer @changelog;
+customer @changelog;
 ```
 
 <img width="1300" alt="change-history-value" src="_assets/changes-value-wbox.png">
@@ -152,33 +175,12 @@ For example, having a `@changelog` annotation without any additional identifiers
 Hence, here it is essential to add a unique identifier to obtain human-readable value columns:
 
 ```cds
-  customer @changelog: [customer.name];
+customer @changelog: [customer.name];
 ```
 
 <img width="1300" alt="change-history-value-hr" src="_assets/changes-value-hr-wbox.png">
 
-
-## Test-drive locally
-
-With the steps above, we have successfully set up change tracking for our reference application. Let's see that in action.
-
-1. **Start the server**:
-  ```sh
-  cds watch
-  ```
-2. **Make a change** on your change-tracked elements. This change will automatically be persisted in the database table (`sap.changelog.ChangeLog`) and made available in a pre-defined view, namely the [Change History view](#change-history-view) for your convenience.
-
-## Change History View
-
-> [!IMPORTANT]
-> To ensure proper lazy loading of the Change History table, please use **SAPUI5 version 1.120.0** or higher.<br>
-> If you wish to *disable* this feature, please see the customization section on how to [disable lazy loading](#disable-lazy-loading).
-
-<img width="1300" alt="change-history" src="_assets/changes.png">
-
-If you have a Fiori Element application, the CDS plugin automatically provides and generates a view `sap.changelog.ChangeView`, the facet of which is automatically added to the Fiori Object Page of your change-tracked entities/elements. In the UI, this corresponds to the *Change History* table which serves to help you to view and search the stored change records of your modeled entities.
-
-## Customizations
+## Advanced Options
 
 ### Altered table view
 
@@ -218,21 +220,368 @@ annotate sap.changelog.aspect @(UI.Facets: [{
   Target: 'changes/@UI.PresentationVariant',
   ![@UI.PartOfPreview]
 }]);
-
 ```
 
 The system now uses the SAPUI5 default setting `![@UI.PartOfPreview]: true`, such that the table will always shown when navigating to that respective Object page.
 
+### Disable UI Facet generation
+
+If you do not want the UI facet added to a specific UI, you can annotate the service entity with `@changelog.disable_facet`. This will disable the automatic addition of the UI faced to this specific entity, but also all views or further projections up the chain.
+
+### Disable Association to Changes Generation
+
+For some scenarios, e.g. when doing `UNION` and the `@changelog` annotion is still propageted, the automatic addition of the association to `changes` does not make sense. You can use `@changelog.disable_assoc`for this to be disabled on entity level.
+
+> [!IMPORTANT]
+> This will also supress the addition of the UI facet, since the change-view is not available as target entity anymore.
+
+### Preserve change logs of deleted data
+
+By default, deleting a record will also automatically delete all associated change logs. This helps reduce the impact on the size of the database.
+You can turn this behavior off globally by adding the following switch to the `package.json` of your project
+
+```
+...
+"cds": {
+  "requires": {
+    ...
+    "change-tracking": {
+      "preserveDeletes": true
+    }
+   ...
+  }
+}
+...
+```
+> [!IMPORTANT]
+> Preserving the change logs of deleted data can have a significant impact on the size of the change logging table, since now such data also survives automated data retention runs. 
+> You must implement an own **data retention strategy** for the change logging table in order to manage the size and performance of your database.
+
+## Examples
+
+This section describes modelling cases for further reference, from simple to complex, including the following:
+
+- [Specify Object ID](#specify-object-id)
+  - [Use Case 1: Annotate single field/multiple fields of associated table(s) as the Object ID](#use-case-1-annotate-single-fieldmultiple-fields-of-associated-tables-as-the-object-id)
+  - [Use Case 2: Annotate single field/multiple fields of project customized types as the Object ID](#use-case-2-annotate-single-fieldmultiple-fields-of-project-customized-types-as-the-object-id)
+  - [Use Case 3: Annotate chained associated entities from the current entity as the Object ID](#use-case-3-annotate-chained-associated-entities-from-the-current-entity-as-the-object-id)
+- [Tracing Changes](#tracing-changes)
+  - [Use Case 1: Trace the changes of child nodes from the current entity and display the meaningful data from child nodes (composition relation)](#use-case-1-trace-the-changes-of-child-nodes-from-the-current-entity-and-display-the-meaningful-data-from-child-nodes-composition-relation)
+  - [Use Case 2: Trace the changes of associated entities from the current entity and display the meaningful data from associated entities (association relation)](#use-case-2-trace-the-changes-of-associated-entities-from-the-current-entity-and-display-the-meaningful-data-from-associated-entities-association-relation)
+  - [Use Case 3: Trace the changes of fields defined by project customized types and display the meaningful data](#use-case-3-trace-the-changes-of-fields-defined-by-project-customized-types-and-display-the-meaningful-data)
+  - [Use Case 4: Trace the changes of chained associated entities from the current entity and display the meaningful data from associated entities (association relation)](#use-case-4-trace-the-changes-of-chained-associated-entities-from-the-current-entity-and-display-the-meaningful-data-from-associated-entities-association-relation)
+  - [Use Case 5: Trace the changes of union entity and display the meaningful data](#use-case-5-trace-the-changes-of-union-entity-and-display-the-meaningful-data)
+- [Don&#39;ts](#donts)
+  - [Use Case 1: Don&#39;t trace changes for field(s) with `Association to many`](#use-case-1-dont-trace-changes-for-fields-with-association-to-many)
+  - [Use Case 2: Don&#39;t trace changes for field(s) with *Unmanaged Association*](#use-case-2-dont-trace-changes-for-fields-with-unmanaged-association)
+  - [Use Case 3: Don&#39;t trace changes for CUD on DB entity](#use-case-3-dont-trace-changes-for-cud-on-db-entity)
+
+### Specify Object ID
+
+Use cases for Object ID annotation
+
+#### Use Case 1: Annotate single field/multiple fields of associated table(s) as the Object ID
+
+Modelling in `db/schema.cds`
+
+```cds
+entity Incidents : cuid, managed {
+  ...
+  customer       : Association to Customers;
+  title          : String @title: 'Title';
+  urgency        : Association to Urgency default 'M';
+  status         : Association to Status default 'N';
+  ...
+}
+```
+
+Add the following `@changelog` annotations in `srv/change-tracking.cds`
+
+```cds
+annotate ProcessorService.Incidents with @changelog: [customer.name, urgency.code, status.criticality] {
+  title    @changelog;
+}
+```
+
+![AssociationID](_assets/AssociationID.png)
+
+#### Use Case 2: Annotate single field/multiple fields of project customized types as the Object ID
+
+Modelling in `db/schema.cds`
+
+```cds
+entity Incidents : cuid, managed {
+  ...
+  customer       : Association to Customers;
+  title          : String @title: 'Title';
+  ...
+}
+
+entity Customers : cuid, managed {
+  ...
+  email          : EMailAddress;  // customized type
+  phone          : PhoneNumber;   // customized type
+  ...
+}
+```
+
+Add the following `@changelog` annotations in `srv/change-tracking.cds`
+
+```cds
+annotate ProcessorService.Incidents with @changelog: [customer.email, customer.phone] {
+  title    @changelog;
+}
+```
+
+![CustomTypeID](_assets/CustomTypeID.png)
+
+#### Use Case 3: Annotate chained associated entities from the current entity as the Object ID
+
+Modelling in `db/schema.cds`
+
+```cds
+entity Incidents : cuid, managed {
+  ...
+  customer       : Association to Customers;
+  ...
+}
+
+entity Customers : cuid, managed {
+  ...
+  addresses : Association to Addresses;
+  ...
+}
+```
+
+Add the following `@changelog` annotations in `srv/change-tracking.cds`
+
+```cds
+annotate ProcessorService.Incidents with @changelog: [customer.addresses.city, customer.addresses.postCode] {
+  title    @changelog;
+}
+```
+
+![ChainedAssociationID](_assets/ChainedAssociationID.png)
+
+> Change-tracking supports annotating chained associated entities from the current entity as object ID of current entity in case the entity in consumer applications is a pure relation table. However, the usage of chained associated entities is not recommended due to performance cost.
+
+### Tracing Changes
+
+Use cases for tracing changes
+
+#### Use Case 1: Trace the changes of child nodes from the current entity and display the meaningful data from child nodes (composition relation)
+
+Modelling in `db/schema.cds`
+
+```cds
+entity Incidents : managed, cuid {
+  ...
+  title          : String @title: 'Title';
+  conversation   : Composition of many Conversation;
+  ...
+}
+
+aspect Conversation: managed, cuid {
+    ...
+    message   : String;
+}
+```
+
+Add the following `@changelog` annotations in `srv/change-tracking.cds`
+
+```cds
+annotate ProcessorService.Incidents with @changelog: [title] {
+  conversation @changelog: [conversation.message];
+}
+```
+
+![CompositionChange](_assets/CompositionChange.png)
+
+#### Use Case 2: Trace the changes of associated entities from the current entity and display the meaningful data from associated entities (association relation)
+
+Modelling in `db/schema.cds`
+
+```cds
+entity Incidents : cuid, managed {
+  ...
+  customer       : Association to Customers;
+  title          : String @title: 'Title';
+  ...
+}
+
+entity Customers : cuid, managed {
+  ...
+  email          : EMailAddress;
+  ...
+}
+```
+
+Add the following `@changelog` annotations in `srv/change-tracking.cds`
+
+```cds
+annotate ProcessorService.Incidents with @changelog: [title] {
+  customer @changelog: [customer.email];
+}
+```
+
+![AssociationChange](_assets/AssociationChange.png)
+
+#### Use Case 3: Trace the changes of fields defined by project customized types and display the meaningful data
+
+Modelling in `db/schema.cds`
+
+```cds
+type StatusType : Association to Status;
+
+entity Incidents : cuid, managed {
+  ...
+  title          : String @title: 'Title';
+  status         : StatusType default 'N';
+  ...
+}
+```
+
+Add the following `@changelog` annotations in `srv/change-tracking.cds`
+
+```cds
+annotate ProcessorService.Incidents with @changelog: [title] {
+  status   @changelog: [status.code];
+}
+```
+
+![CustomTypeChange](_assets/CustomTypeChange.png)
+
+#### Use Case 4: Trace the changes of chained associated entities from the current entity and display the meaningful data from associated entities (association relation)
+
+Modelling in `db/schema.cds`
+
+```cds
+entity Incidents : cuid, managed {
+  ...
+  title          : String @title: 'Title';
+  customer       : Association to Customers;
+  ...
+}
+
+entity Customers : cuid, managed {
+  ...
+  addresses : Association to Addresses;
+  ...
+}
+```
+
+Add the following `@changelog` annotations in `srv/change-tracking.cds`
+
+```cds
+annotate ProcessorService.Incidents with @changelog: [title] {
+  customer @changelog: [customer.addresses.city, customer.addresses.streetAddress];
+}
+```
+
+![ChainedAssociationChange](_assets/ChainedAssociationChange.png)
+
+> Change-tracking supports analyzing chained associated entities from the current entity in case the entity in consumer applications is a pure relation table. However, the usage of chained associated entities is not recommended due to performance cost.
+
+#### Use Case 5: Trace the changes of union entity and display the meaningful data
+
+`Payable.cds`:
+
+```cds
+entity Payables : cuid {
+    displayId    : String;
+    @changelog
+    name         : String;
+    cryptoAmount : Decimal;
+    fiatAmount   : Decimal;
+};
+```
+
+`Payment.cds`:
+
+```cds
+entity Payments : cuid {
+    displayId : String; //readable ID
+    @changelog
+    name      : String;
+};
+```
+
+Union entity in `BusinessTransaction.cds`:
+
+```cds
+entity BusinessTransactions          as(
+    select from payments.Payments{
+        key ID,
+            displayId,
+            name,
+            changes  : Association to many ChangeView
+                on changes.objectID = ID AND changes.entity = 'payments.Payments'
+    }
+)
+union all
+(
+    select from payables.Payables {
+        key ID,
+            displayId,
+            name,
+            changes  : Association to many ChangeView
+               on changes.objectID = ID AND changes.entity = 'payables.Payables'
+    }
+);
+```
+
+![UnionChange.png](_assets/UnionChange.png)
+
+### Don'ts
+
+Don'ts
+
+#### Use Case 1: Don't trace changes for field(s) with `Association to many`
+
+```cds
+entity Customers : cuid, managed {
+  ...
+  incidents : Association to many Incidents on incidents.customer = $self;
+}
+```
+
+The reason is that: the relationship: `Association to many` is only for modelling purpose and there is no concrete field in database table. In the above sample, there is no column for incidents in the table Customers, but there is a navigation property of incidents in Customers OData entity metadata.
+
+#### Use Case 2: Don't trace changes for field(s) with *Unmanaged Association*
+
+```cds
+entity AggregatedBusinessTransactionData @(cds.autoexpose) : cuid {
+    FootprintInventory: Association to one FootprintInventories
+                        on  FootprintInventory.month                      = month
+                        and FootprintInventory.year                       = year
+                        and FootprintInventory.FootprintInventoryScope.ID = FootprintInventoryScope.ID;
+    ...
+}
+```
+
+The reason is that: When deploying to relational databases, Associations are mapped to foreign keys. Yet, when mapped to non-relational databases they're just references. More details could be found in [Prefer Managed Associations](https://cap.cloud.sap/docs/guides/domain-models#managed-associations). In the above sample, there is no column for FootprintInventory in the table AggregatedBusinessTransactionData, but there is a navigation property FootprintInventoryof in OData entity metadata.
+
+#### Use Case 3: Don't trace changes for CUD on DB entity
+
+```cds
+this.on("UpdateActivationStatus", async (req) =>
+    // PaymentAgreementsOutgoingDb is the DB entity
+    await UPDATE.entity(PaymentAgreementsOutgoingDb)
+        .where({ ID: paymentAgreement.ID })
+        .set({ ActivationStatus_code: ActivationCodes.ACTIVE });
+);
+```
+
+The reason is that: Application level services are by design the only place where business logic is enforced. This by extension means, that it also is the only point where e.g. change-tracking would be enabled. The underlying method used to do change tracking is `req.diff` which is responsible to read the necessary before-image from the database, and this method is not available on DB level.
+
 ## Contributing
 
 This project is open to feature requests/suggestions, bug reports etc. via [GitHub issues](https://github.com/cap-js/change-tracking/issues). Contribution and feedback are encouraged and always welcome. For more information about how to contribute, the project structure, as well as additional contribution information, see our [Contribution Guidelines](CONTRIBUTING.md).
 
-
 ## Code of Conduct
 
 We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone. By participating in this project, you agree to abide by its [Code of Conduct](CODE_OF_CONDUCT.md) at all times.
 
-
 ## Licensing
 
 Copyright 2023 SAP SE or an SAP affiliate company and contributors. Please see our [LICENSE](LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/cap-js/change-tracking).

package/cds-plugin.js

@@ -1,5 +1,8 @@
 const cds = require('@sap/cds')
 
+const isRoot = 'change-tracking-isRootEntity'
+const hasParent = 'change-tracking-parentEntity'
+
 const isChangeTracked = (entity) => (
   (entity['@changelog']
   || entity.elements && Object.values(entity.elements).some(e => e['@changelog'])) && entity.query?.SET?.op !== 'union'
@@ -7,6 +10,10 @@ const isChangeTracked = (entity) => (
 
 // Add the appropriate Side Effects attribute to the custom action
 const addSideEffects = (actions, flag, element) => {
+  if (!flag && (element === undefined || element === null)) {
+    return
+  }
+
   for (const se of Object.values(actions)) {
     const target = flag ? 'TargetProperties' : 'TargetEntities'
     const sideEffectAttr = se[`@Common.SideEffects.${target}`]
@@ -23,6 +30,114 @@ const addSideEffects = (actions, flag, element) => {
   }
 }
 
+function setChangeTrackingIsRootEntity(entity, csn, val = true) {
+  if (csn.definitions?.[entity.name]) {
+    csn.definitions[entity.name][isRoot] = val;
+  }
+}
+
+function checkAndSetRootEntity(parentEntity, entity, csn) {
+  if (entity[isRoot] === false) {
+    return entity;
+  }
+  if (parentEntity) {
+    return compositionRoot(parentEntity, csn);
+  } else {
+    setChangeTrackingIsRootEntity(entity, csn);
+    return { ...csn.definitions?.[entity.name], name: entity.name };
+  }
+}
+
+function processEntities(m) {
+  for (let name in m.definitions) {
+    compositionRoot({...m.definitions[name], name}, m)
+  }
+}
+
+function compositionRoot(entity, csn) {
+  if (!entity || entity.kind !== 'entity') {
+    return;
+  }
+  const parentEntity = compositionParent(entity, csn);
+  return checkAndSetRootEntity(parentEntity, entity, csn);
+}
+
+function compositionParent(entity, csn) {
+  if (!entity || entity.kind !== 'entity') {
+    return;
+  }
+  const parentAssociation = compositionParentAssociation(entity, csn);
+  return parentAssociation ?? null;
+}
+
+function compositionParentAssociation(entity, csn) {
+  if (!entity || entity.kind !== 'entity') {
+    return;
+  }
+  const elements = entity.elements ?? {};
+
+  // Add the change-tracking-isRootEntity attribute of the child entity
+  processCompositionElements(entity, csn, elements);
+
+  const hasChildFlag = entity[isRoot] !== false;
+  const hasParentEntity = entity[hasParent];
+
+  if (hasChildFlag || !hasParentEntity) {
+    // Find parent association of the entity
+    const parentAssociation = findParentAssociation(entity, csn, elements);
+    if (parentAssociation) {
+      const parentAssociationTarget = elements[parentAssociation]?.target;
+      if (hasChildFlag) setChangeTrackingIsRootEntity(entity, csn, false);
+      return {
+        ...csn.definitions?.[parentAssociationTarget],
+        name: parentAssociationTarget
+      };
+    } else return;
+  }
+  return { ...csn.definitions?.[entity.name], name: entity.name };
+}
+
+function processCompositionElements(entity, csn, elements) {
+  for (const name in elements) {
+    const element = elements[name];
+    const target = element?.target;
+    const definition = csn.definitions?.[target];
+    if (
+      element.type !== 'cds.Composition' ||
+      target === entity.name ||
+      !definition ||
+      definition[isRoot] === false
+    ) {
+      continue;
+    }
+    setChangeTrackingIsRootEntity({ ...definition, name: target }, csn, false);
+  }
+}
+
+function findParentAssociation(entity, csn, elements) {
+  return Object.keys(elements).find((name) => {
+    const element = elements[name];
+    const target = element?.target;
+    if (element.type === 'cds.Association' && target !== entity.name) {
+      const parentDefinition = csn.definitions?.[target] ?? {};
+      const parentElements = parentDefinition?.elements ?? {};
+      return !!Object.keys(parentElements).find((parentEntityName) => {
+        const parentElement = parentElements?.[parentEntityName] ?? {};
+        if (parentElement.type === 'cds.Composition') {
+          const isCompositionEntity = parentElement.target === entity.name;
+          // add parent information in the current entity
+          if (isCompositionEntity) {
+            csn.definitions[entity.name][hasParent] = {
+              associationName: name,
+              entityName: target
+            };
+          }
+          return isCompositionEntity;
+        }
+      });
+    }
+  });
+}
 
 // Unfold @changelog annotations in loaded model
 cds.on('loaded', m => {
@@ -31,6 +146,9 @@ cds.on('loaded', m => {
   const { 'sap.changelog.aspect': aspect } = m.definitions; if (!aspect) return // some other model
   const { '@UI.Facets': [facet], elements: { changes } } = aspect
   changes.on.pop() // remove ID -> filled in below
+  
+  // Process entities to define the relation
+  processEntities(m)
 
   for (let name in m.definitions) {
     const entity = m.definitions[name]
@@ -40,12 +158,19 @@ cds.on('loaded', m => {
       const keys = [], { elements: elms } = entity
       for (let e in elms) if (elms[e].key) keys.push(e)
 
+      // If no key attribute is defined for the entity, the logic to add association to ChangeView should be skipped.
+      if(keys.length === 0) {
+        continue;
+      }
+
       // Add association to ChangeView...
       const on = [...changes.on]; keys.forEach((k, i) => { i && on.push('||'); on.push({
         ref: k === 'up_' ? [k,'ID'] : [k] // REVISIT: up_ handling is a dirty hack for now
       })})
       const assoc = { ...changes, on }
       const query = entity.projection || entity.query?.SELECT
+      if(!entity['@changelog.disable_assoc'])
+      {
       if (query) {
         (query.columns ??= ['*']).push({ as: 'changes', cast: assoc })
       } else {
@@ -53,30 +178,23 @@ cds.on('loaded', m => {
       }
 
       // Add UI.Facet for Change History List
-      entity['@UI.Facets']?.push(facet)
+      if(!entity['@changelog.disable_facet'])
+        entity['@UI.Facets']?.push(facet)
+      }
 
-      // The changehistory list should be refreshed after the custom action is triggered
       if (entity.actions) {
+        const hasParentInfo = entity[hasParent];
+        const entityName = hasParentInfo?.entityName;
+        const parentEntity = entityName ? m.definitions[entityName] : null;
 
-        // Update the changehistory list on the current entity when the custom action of the entity is triggered
-        if (entity['@UI.Facets']) {
-          addSideEffects(entity.actions, true)
-        }
+        const isParentRootAndHasFacets = parentEntity?.[isRoot] && parentEntity?.['@UI.Facets'];
 
-        // When the custom action of the child entity is performed, the change history list of the parent entity is updated
-        if (entity.elements) {
-          //ToDo: Revisit Breaklook with node.js Expert
-          breakLoop: for (const [ele, eleValue] of Object.entries(entity.elements)) {
-            const parentEntity = m.definitions[eleValue.target]
-            if (parentEntity && parentEntity['@UI.Facets'] && eleValue.type === 'cds.Association') {
-              for (const value of Object.values(parentEntity.elements)) {
-                if (value.target === name) {
-                  addSideEffects(entity.actions, false, ele)
-                  break breakLoop
-                }
-              }
-            }
-          }
+        if (entity[isRoot] && entity['@UI.Facets']) {
+          // Add side effects for root entity
+          addSideEffects(entity.actions, true);
+        } else if (isParentRootAndHasFacets) {
+          // Add side effects for child entity
+          addSideEffects(entity.actions, false, hasParentInfo?.associationName);
         }
       }
     }

package/index.cds

@@ -40,8 +40,8 @@ entity ChangeLog : managed, cuid {
   serviceEntity : String @title: '{i18n>ChangeLog.serviceEntity}'; // definition name of target entity (on service level) - e.g. ProcessorsService.Incidents
   entity        : String @title: '{i18n>ChangeLog.entity}'; // definition name of target entity (on db level) - e.g. sap.capire.incidents.Incidents
   entityKey     : UUID   @title: '{i18n>ChangeLog.entityKey}'; // primary key of target entity, e.g. Incidents.ID
-  createdAt     : managed:createdAt @title: 'On';
-  createdBy     : managed:createdBy @title: 'By';
+  createdAt     : managed:createdAt;
+  createdBy     : managed:createdBy;
   changes       : Composition of many Changes on changes.changeLog = $self;
 }
 

package/lib/change-log.js

@@ -15,6 +15,7 @@ const {
   getValueEntityType,
 } = require("./entity-helper")
 const { localizeLogFields } = require("./localization")
+const isRoot = "change-tracking-isRootEntity"
 
 
 const _getRootEntityPathVals = function (txContext, entity, entityKey) {
@@ -26,21 +27,22 @@ const _getRootEntityPathVals = function (txContext, entity, entityKey) {
   if (txContext.event === "CREATE") {
     const curEntityPathVal = `${entity.name}(${entityKey})`
     serviceEntityPathVals.push(curEntityPathVal)
+    txContext.hasComp && entityIDs.pop();
   } else {
     // When deleting Composition of one node via REST API in draft-disabled mode,
     // the child node ID would be missing in URI
     if (txContext.event === "DELETE" && !entityIDs.find((x) => x === entityKey)) {
       entityIDs.push(entityKey)
     }
-    const curEntity = getEntityByContextPath(path)
+    const curEntity = getEntityByContextPath(path, txContext.hasComp)
     const curEntityID = entityIDs.pop()
     const curEntityPathVal = `${curEntity.name}(${curEntityID})`
     serviceEntityPathVals.push(curEntityPathVal)
   }
 
 
-  while (_isCompositionContextPath(path)) {
-    const hostEntity = getEntityByContextPath(path = path.slice(0, -1))
+  while (_isCompositionContextPath(path, txContext.hasComp)) {
+    const hostEntity = getEntityByContextPath(path = path.slice(0, -1), txContext.hasComp)
     const hostEntityID = entityIDs.pop()
     const hostEntityPathVal = `${hostEntity.name}(${hostEntityID})`
     serviceEntityPathVals.unshift(hostEntityPathVal)
@@ -55,7 +57,7 @@ const _getAllPathVals = function (txContext) {
   const entityIDs = _getEntityIDs(txContext.params)
 
   for (let idx = 0; idx < paths.length; idx++) {
-    const entity = getEntityByContextPath(paths.slice(0, idx + 1))
+    const entity = getEntityByContextPath(paths.slice(0, idx + 1), txContext.hasComp)
     const entityID = entityIDs[idx]
     const entityPathVal = `${entity.name}(${entityID})`
     pathVals.push(entityPathVal)
@@ -64,6 +66,28 @@ const _getAllPathVals = function (txContext) {
   return pathVals
 }
 
+function convertSubjectToParams(subject) {
+  let params = [];
+  let subjectRef = [];
+  subject?.ref?.forEach((item)=>{
+    if (typeof item === 'string') {
+      subjectRef.push(item)
+      return
+    }
+
+    const keys = {}
+    let id = item.id
+    if (!id) return
+    for (let j = 0; j < item?.where?.length; j = j + 4) {
+      const key = item.where[j].ref[0]
+      const value = item.where[j + 2].val
+      if (key !== 'IsActiveEntity') keys[key] = value
+    }
+    params.push(keys);
+  })
+  return params.length > 0 ? params : subjectRef;
+}
+
 const _getEntityIDs = function (txParams) {
   const entityIDs = []
   for (const param of txParams) {
@@ -97,7 +121,7 @@ const _getEntityIDs = function (txParams) {
  * ...
  * }
  */
-const _formatAssociationContext = async function (changes) {
+const _formatAssociationContext = async function (changes, reqData) {
   for (const change of changes) {
     const a = cds.model.definitions[change.serviceEntity].elements[change.attribute]
     if (a?.type !== "cds.Association") continue
@@ -111,10 +135,10 @@ const _formatAssociationContext = async function (changes) {
       SELECT.one.from(a.target).where({ [ID]: change.valueChangedTo })
     ])
 
-    const fromObjId = await getObjectId(a.target, semkeys, { curObjFromDbQuery: from || undefined }) // Note: ... || undefined is important for subsequent object destructuring with defaults
+    const fromObjId = await getObjectId(reqData, a.target, semkeys, { curObjFromDbQuery: from || undefined }) // Note: ... || undefined is important for subsequent object destructuring with defaults
     if (fromObjId) change.valueChangedFrom = fromObjId
 
-    const toObjId = await getObjectId(a.target, semkeys, { curObjFromDbQuery: to || undefined }) // Note: ... || undefined is important for subsequent object destructuring with defaults
+    const toObjId = await getObjectId(reqData, a.target, semkeys, { curObjFromDbQuery: to || undefined }) // Note: ... || undefined is important for subsequent object destructuring with defaults
     if (toObjId) change.valueChangedTo = toObjId
 
     const isVLvA = a["@Common.ValueList.viaAssociation"]
@@ -219,7 +243,7 @@ const _getObjectIdByPath = async function (
   const entityUUID = getUUIDFromPathVal(nodePathVal)
   const obj = await getCurObjFromDbQuery(entityName, entityUUID)
   const curObj = { curObjFromReqData, curObjFromDbQuery: obj }
-  return getObjectId(entityName, objIdElementNames, curObj)
+  return getObjectId(reqData, entityName, objIdElementNames, curObj)
 }
 
 const _formatObjectID = async function (changes, reqData) {
@@ -255,19 +279,19 @@ const _formatObjectID = async function (changes, reqData) {
   }
 }
 
-const _isCompositionContextPath = function (aPath) {
+const _isCompositionContextPath = function (aPath, hasComp) {
   if (!aPath) return
   if (typeof aPath === 'string') aPath = aPath.split('/')
   if (aPath.length < 2) return false
-  const target = getEntityByContextPath(aPath)
-  const parent = getEntityByContextPath(aPath.slice(0, -1))
+  const target = getEntityByContextPath(aPath, hasComp)
+  const parent = getEntityByContextPath(aPath.slice(0, -1), hasComp)
   if (!parent.compositions) return false
   return Object.values(parent.compositions).some(c => c._target === target)
 }
 
 const _formatChangeLog = async function (changes, req) {
   await _formatObjectID(changes, req.data)
-  await _formatAssociationContext(changes)
+  await _formatAssociationContext(changes, req.data)
   await _formatCompositionContext(changes, req.data)
 }
 
@@ -289,10 +313,26 @@ function _trackedChanges4 (srv, target, diff) {
     template, row: diff, processFn: ({ row, key, element }) => {
       const from = row._old?.[key]
       const to = row[key]
+      const eleParentKeys = element.parent.keys
       if (from === to) return
 
-      const keys = Object.keys(element.parent.keys)
+      /**
+       * 
+       * For the Inline entity such as Items, 
+       * further filtering is required on the keys 
+       * within the 'association' and 'foreign key' to ultimately retain the keys of the entity itself.
+       * entity Order : cuid {
+       *   title      : String;
+       *   Items      : Composition of many {
+       *     key ID   : UUID;
+       *     quantity : Integer;
+       *   }
+       * }
+       */
+      const keys = Object.keys(eleParentKeys)
         .filter(k => k !== "IsActiveEntity")
+        .filter(k => eleParentKeys[k]?.type !== "cds.Association") // Skip association
+        .filter(k => !eleParentKeys[k]?.["@odata.foreignKey4"]) // Skip foreign key
         .map(k => `${k}=${row[k]}`)
         .join(', ')
 
@@ -339,20 +379,90 @@ const _prepareChangeLogForComposition = async function (entity, entityKey, chang
   return [ rootEntity, rootEntityID ]
 }
 
+async function generatePathAndParams (req, entityKey) {
+  const { target, data } = req;
+  const { ID, foreignKey, parentEntity } = getAssociationDetails(target);
+  const hasParentAndForeignKey = parentEntity && data[foreignKey];
+  const targetEntity = hasParentAndForeignKey ? parentEntity : target;
+  const targetKey = hasParentAndForeignKey ? data[foreignKey] : entityKey;
+
+  let compContext = {
+    path: hasParentAndForeignKey
+      ? `${parentEntity.name}/${target.name}`
+      : `${target.name}`,
+    params: hasParentAndForeignKey
+      ? [{ [ID]: data[foreignKey] }, { [ID]: entityKey }]
+      : [{ [ID]: entityKey }],
+    hasComp: true
+  };
+
+  if (hasParentAndForeignKey && parentEntity[isRoot]) {
+    return compContext;
+  }
+
+  let parentAssoc = await processEntity(targetEntity, targetKey, compContext);
+  while (parentAssoc && !parentAssoc.entity[isRoot]) {
+    parentAssoc = await processEntity(
+      parentAssoc.entity,
+      parentAssoc.ID,
+      compContext
+    );
+  }
+  return compContext;
+}
+
+async function processEntity (entity, entityKey, compContext) {
+  const { ID, foreignKey, parentEntity } = getAssociationDetails(entity);
+
+  if (foreignKey && parentEntity) {
+    const parentResult =
+      (await SELECT.one
+        .from(entity.name)
+        .where({ [ID]: entityKey })
+        .columns(foreignKey)) || {};
+    const hasForeignKey = parentResult[foreignKey];
+    if (!hasForeignKey) return;
+    compContext.path = `${parentEntity.name}/${compContext.path}`;
+    compContext.params.unshift({ [ID]: parentResult[foreignKey] });
+    return {
+      entity: parentEntity,
+      [ID]: hasForeignKey ? parentResult[foreignKey] : undefined
+    };
+  }
+}
+
+function getAssociationDetails (entity) {
+  if (!entity) return {};
+  const assocName = entity['change-tracking-parentEntity']?.associationName;
+  const assoc = entity.elements[assocName];
+  const parentEntity = assoc?._target;
+  const foreignKey = assoc?.keys?.[0]?.$generatedFieldName;
+  const ID = assoc?.keys?.[0]?.ref[0] || 'ID';
+  return { ID, foreignKey, parentEntity };
+}
+
 
 async function track_changes (req) {
   let diff = await req.diff()
   if (!diff) return
 
   let target = req.target
-  let isDraftEnabled = !!target.drafts
-  let isComposition = _isCompositionContextPath(req.context.path)
+  let compContext = null;
   let entityKey = diff.ID
-
-  if (req.event === "DELETE") {
-    if (isDraftEnabled || !isComposition) {
-      return await DELETE.from(`sap.changelog.ChangeLog`).where({ entityKey })
-    }
+  const params = convertSubjectToParams(req.subject);
+  if (req.subject.ref.length === 1 && params.length === 1 && !target[isRoot]) {
+    compContext = await generatePathAndParams(req, entityKey);
+  }
+  let isComposition = _isCompositionContextPath(
+    compContext?.path || req.path,
+    compContext?.hasComp
+  );
+  if (
+    req.event === "DELETE" &&
+    target[isRoot] &&
+    !cds.env.requires["change-tracking"]?.preserveDeletes
+  ) {
+    return await DELETE.from(`sap.changelog.ChangeLog`).where({ entityKey });
   }
 
   let changes = _trackedChanges4(this, target, diff)
@@ -360,13 +470,22 @@ async function track_changes (req) {
 
   await _formatChangeLog(changes, req)
   if (isComposition) {
-    [ target, entityKey ] = await _prepareChangeLogForComposition(target, entityKey, changes, this)
+    let reqInfo = {
+      data: req.data,
+      context: {
+        path: compContext?.path || req.path,
+        params: compContext?.params || params,
+        event: req.event,
+        hasComp: compContext?.hasComp
+      }
+    };
+    [ target, entityKey ] = await _prepareChangeLogForComposition(target, entityKey, changes, reqInfo)
   }
   const dbEntity = getDBEntity(target)
   await INSERT.into("sap.changelog.ChangeLog").entries({
     entity: dbEntity.name,
     entityKey: entityKey,
-    serviceEntity: target.name,
+    serviceEntity: target.name || target,
     changes: changes.filter(c => c.valueChangedFrom || c.valueChangedTo).map((c) => ({
       ...c,
       valueChangedFrom: `${c.valueChangedFrom ?? ''}`,

package/lib/entity-helper.js

@@ -11,7 +11,8 @@ const getUUIDFromPathVal = function (pathVal) {
   return regRes ? regRes[1] : ""
 }
 
-const getEntityByContextPath = function (aPath) {
+const getEntityByContextPath = function (aPath, hasComp = false) {
+  if (hasComp) return cds.model.definitions[aPath[aPath.length - 1]]
   let entity = cds.model.definitions[aPath[0]]
   for (let each of aPath.slice(1)) {
     entity = entity.elements[each]?._target
@@ -70,7 +71,7 @@ const getCurObjFromReqData = function (reqData, nodePathVal, pathVal) {
 }
 
 
-async function getObjectId (entityName, fields, curObj) {
+async function getObjectId (reqData, entityName, fields, curObj) {
   let all = [], { curObjFromReqData: req_data={}, curObjFromDbQuery: db_data={} } = curObj
   let entity = cds.model.definitions[entityName]
   if (!fields?.length) fields = entity["@changelog"]?.map?.(k => k['='] || k) || []
@@ -81,13 +82,28 @@ async function getObjectId (entityName, fields, curObj) {
       while (path.length > 1) {
         let assoc = current.elements[path[0]]; if (!assoc?.isAssociation) break
         let foreignKey = assoc.keys?.[0]?.$generatedFieldName
-        let IDval = req_data[foreignKey] || _db_data[foreignKey]
-        if (IDval) try {
+        let IDval =
+        req_data[foreignKey] && current.name === entityName
+          ? req_data[foreignKey]
+          : _db_data[foreignKey]
+        if (!IDval) {
+          _db_data = {};
+        } else try {
           // REVISIT: This always reads all elements -> should read required ones only!
           let ID = assoc.keys?.[0]?.ref[0] || 'ID'
-          // When parent/child nodes are created simultaneously, data is taken from draft table
-          _db_data = await SELECT.one.from(assoc._target).where({[ID]: IDval}) ||
-            await SELECT.one.from(`${assoc._target}.drafts`).where({[ID]: IDval}) || {}
+          const isComposition = hasComposition(assoc._target, current)
+          // Peer association and composition are distinguished by the value of isComposition.
+          if (isComposition) {
+            // This function can recursively retrieve the desired information from reqData without having to read it from db.
+            _db_data = _getCompositionObjFromReq(reqData, IDval)
+            // When multiple layers of child nodes are deleted at the same time, the deep layer of child nodes will lose the information of the upper nodes, so data needs to be extracted from the db.
+            const entityKeys = reqData ? Object.keys(reqData).filter(item => !Object.keys(assoc._target.keys).some(ele => item === ele)) : [];
+            if (!_db_data || JSON.stringify(_db_data) === '{}' || entityKeys.length === 0) {
+              _db_data = await getCurObjFromDbQuery(assoc._target, IDval, ID);
+            }
+          } else {
+            _db_data = await getCurObjFromDbQuery(assoc._target, IDval, ID);
+          }
         } catch (e) {
           LOG.error("Failed to generate object Id for an association entity.", e)
           throw new Error("Failed to generate object Id for an association entity.", e)
@@ -96,7 +112,7 @@ async function getObjectId (entityName, fields, curObj) {
         path.shift()
       }
       field = path.join('_')
-      let obj = _db_data[field] || req_data[field]
+      let obj = current.name === entityName && req_data[field] ? req_data[field] : _db_data[field]
       if (obj) all.push(obj)
     } else {
       let e = entity.elements[field]
@@ -134,6 +150,39 @@ const getValueEntityType = function (entityName, fields) {
   return types.join(', ')
 }
 
+const hasComposition = function (parentEntity, subEntity) {
+  if (!parentEntity.compositions) {
+    return false
+  }
+
+  const compositions = Object.values(parentEntity.compositions);
+
+  for (const composition of compositions) {
+    if (composition.target === subEntity.name) {
+      return true;
+    }
+  }
+
+  return false
+}
+
+const _getCompositionObjFromReq = function (obj, targetID) {
+    if (obj?.ID === targetID) {
+        return obj;
+    }
+
+    for (const key in obj) {
+        if (typeof obj[key] === "object" && obj[key] !== null) {
+            const result = _getCompositionObjFromReq(obj[key], targetID);
+            if (result) {
+                return result;
+            }
+        }
+    }
+
+    return null;
+};
+
 module.exports = {
   getCurObjFromReqData,
   getCurObjFromDbQuery,

package/lib/template-processor.js

@@ -12,7 +12,9 @@ const _processElement = (processFn, row, key, elements, isRoot, pathSegments, pi
     const element = elements[key];
     const { plain } = picked;
 
-    if (plain) {
+    // do not change-track personal data
+    const isPersonalData = element && Object.keys(element).some(key => key.startsWith('@PersonalData'));
+    if (plain && !isPersonalData) {
         /**
          * @type import('../../types/api').templateProcessorProcessFnArgs
          */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/change-tracking",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "CDS plugin providing out-of-the box support for automatic capturing, storing, and viewing of the change records of modeled entities.",
   "repository": "cap-js/change-tracking",
   "author": "SAP SE (https://www.sap.com)",
@@ -18,7 +18,7 @@
     "test": "npx jest --silent"
   },
   "peerDependencies": {
-    "@sap/cds": "^7"
+    "@sap/cds": ">=7"
   },
   "devDependencies": {
     "@cap-js/change-tracking": "file:.",