@cap-js/change-tracking 1.0.7 → 1.1.0

package/CHANGELOG.md

@@ -4,6 +4,50 @@ 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.1.0 - TBD
+
+### Added
+
+- License entry
+- Added translations for the UI labels for more languages
+
+### Fixed
+
+- Handling of multiple records in one request
+- Handle cases where the key contains '/'
+- Instantiate the changes association correctly so it does not impact other `@cap-js` plugins
+
+### Changed
+
+- Prepare for CDS9 in tests
+
+## Version 1.0.8 - 28.03.25
+
+### Added
+
+- Added @UI.MultiLineText to value fields
+- Added support for Multi-Tenancy
+- Added configuration options to disable tracking of CREATE/UPDATE/DELETE operations on a project level
+
+### Fixed
+
+- Handling of numeric and boolean fields was faulty, when an initial value of `0` for numeric or `false` for boolean was supplied
+- Decimal values were handled differently for HANA and SQlite
+- Missing UI Label for one attribute (`ChangeLog.ID`) of the Changes UI facet
+- Support for @UI.HeaderInfo.TypeName as fallback for the UI Label of the key
+- Compilation error when an association is used as a key
+- Fixed handling of unmanaged composition of many
+- Proper casing of the operation enum type
+
+
+### Changed
+
+- Added warning and mitigation for multi-tenant deployments with MTX
+- Added a disclaimer of upcoming new version having a minimum requirement of CDS 8.6 for multitenancy fix
+- Changed the default limit on non-HANA databases from 255 to 5000 characters for all String values
+- Updated peer dependency from CDS7 to CDS8
+
+
 ## Version 1.0.7 - 20.08.24
 
 ### Added

package/README.md

@@ -5,12 +5,24 @@ a [CDS plugin](https://cap.cloud.sap/docs/node.js/cds-plugins#cds-plugin-package
 [![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.
+> Following the CAP best practices, the new release now requires CDS8 or CDS9 as minimum versions. If you want to use the plugin with an older version of CAP (CDS7), you will need to manually update the peer dependency in `package.json`. Please be aware that there will be no support for this version of the plugin with a CDS version below 8!
+
+> [!IMPORTANT]
+> This release establishes support for multi-tenant deployments using MTX and extensibility.
 > 
-> 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.
+> To achieve this, the code was modified significantly. While we tested extensively, there still may 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
 
+> [!Warning]
+>
+> Please note that if your project is multi-tenant, then the CDS version must be higher than 8.6 and the mtx version higher than 2.5 for change-tracking to work.
+
+> [!Warning]
+>
+> When using multi-tenancy with MTX, the generated facets and associations have to be created by the model provider of the MTX component. Therefore, the plugin also must be added to the `package.json` of the MTX sidecar. 
+>Although we tested this scenario extensively, there still might be cases where the automatic generation will not work as expected. If this happends in your scenario, we suggest using the `@changelog.disable_assoc` ([see here](#disable-association-to-changes-generation)) for all tracked entities and to add the association and facet manually to the service entity.
+
 
 ### Table of Contents
 
@@ -70,6 +82,7 @@ To enable change tracking, simply add this self-configuring plugin package to yo
 ```sh
 npm add @cap-js/change-tracking
 ```
+If you use multi-tenancy, please add the plugin also to the MTX poroject(The mtx version must be higher than 2.5).
 
 ### 3. Annotations
 
@@ -235,6 +248,24 @@ For some scenarios, e.g. when doing `UNION` and the `@changelog` annotion is sti
 > [!IMPORTANT]
 > This will also supress the addition of the UI facet, since the change-view is not available as target entity anymore.
 
+### Select types of changes to track
+
+If you do not want to track some types of changes, you can disable them using `disableCreateTracking`, `disableUpdateTracking`
+and `disableDeleteTracking` configs in your project settings:
+```json
+{
+  "cds": {
+    "requires": {
+      "change-tracking": {
+        "disableCreateTracking": true,
+        "disableUpdateTracking": false,
+        "disableDeleteTracking": true
+      }
+    }
+  }
+}
+```
+
 ### 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.
@@ -574,6 +605,7 @@ this.on("UpdateActivationStatus", async (req) =>
 
 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).

package/_i18n/i18n.properties

@@ -45,6 +45,10 @@ ChangeLog.modification.create=Create
 ChangeLog.modification.update=Update
 #XFLD: Field label
 ChangeLog.modification.delete=Delete
+#XFLD: Field label
+ChangeLog.createdAt=Changed at
+#XFLD: Field label
+ChangeLog.createdBy=Changed by
 
 ## Change History Table##
 ########################################

package/_i18n/i18n_de.properties

@@ -45,7 +45,11 @@ ChangeLog.modification.create=Anlegen
 ChangeLog.modification.update=Aktualisieren
 #XFLD: Field label
 ChangeLog.modification.delete=L\u00F6schen
+#XFLD: Field label
+ChangeLog.createdAt=\u00C4nderung am
+#XFLD: Field label
+ChangeLog.createdBy=\u00C4nderung von
 
 ## Change History Table##
 ########################################
-ChangeHistory=Änderungshistorie
+ChangeHistory=\u00C4nderungshistorie

package/_i18n/i18n_en.properties

@@ -45,6 +45,10 @@ ChangeLog.modification.create=Create
 ChangeLog.modification.update=Update
 #XFLD: Field label
 ChangeLog.modification.delete=Delete
+#XFLD: Field label
+ChangeLog.createdAt=Changed at
+#XFLD: Field label
+ChangeLog.createdBy=Changed by
 
 ## Change History Table##
 ########################################

package/cds-plugin.js

@@ -1,12 +1,14 @@
 const cds = require('@sap/cds')
+const DEBUG = cds.debug('changelog')
 
 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'
-)
+const isChangeTracked = (entity) => {
+  if (entity.query?.SET?.op === 'union') return false // REVISIT: should that be an error or warning?
+  if (entity['@changelog']) return true
+  if (Object.values(entity.elements).some(e => e['@changelog'])) return true
+}
 
 // Add the appropriate Side Effects attribute to the custom action
 const addSideEffects = (actions, flag, element) => {
@@ -30,179 +32,207 @@ const addSideEffects = (actions, flag, element) => {
   }
 }
 
-function setChangeTrackingIsRootEntity(entity, csn, val = true) {
+function setChangeTrackingIsRootEntity (entity, csn, val = true) {
   if (csn.definitions?.[entity.name]) {
-    csn.definitions[entity.name][isRoot] = val;
+    csn.definitions[entity.name][isRoot] = val
   }
 }
 
-function checkAndSetRootEntity(parentEntity, entity, csn) {
+function checkAndSetRootEntity (parentEntity, entity, csn) {
   if (entity[isRoot] === false) {
-    return entity;
+    return entity
   }
   if (parentEntity) {
-    return compositionRoot(parentEntity, csn);
+    return compositionRoot(parentEntity, csn)
   } else {
-    setChangeTrackingIsRootEntity(entity, csn);
-    return { ...csn.definitions?.[entity.name], name: entity.name };
+    setChangeTrackingIsRootEntity(entity, csn)
+    return { ...csn.definitions?.[entity.name], name: entity.name }
   }
 }
 
-function processEntities(m) {
+function processEntities (m) {
   for (let name in m.definitions) {
-    compositionRoot({...m.definitions[name], name}, m)
+    compositionRoot({ ...m.definitions[name], name }, m)
   }
 }
 
-function compositionRoot(entity, csn) {
+function compositionRoot (entity, csn) {
   if (!entity || entity.kind !== 'entity') {
-    return;
+    return
   }
-  const parentEntity = compositionParent(entity, csn);
-  return checkAndSetRootEntity(parentEntity, entity, csn);
+  const parentEntity = compositionParent(entity, csn)
+  return checkAndSetRootEntity(parentEntity, entity, csn)
 }
 
-function compositionParent(entity, csn) {
+function compositionParent (entity, csn) {
   if (!entity || entity.kind !== 'entity') {
-    return;
+    return
   }
-  const parentAssociation = compositionParentAssociation(entity, csn);
-  return parentAssociation ?? null;
+  const parentAssociation = compositionParentAssociation(entity, csn)
+  return parentAssociation ?? null
 }
 
-function compositionParentAssociation(entity, csn) {
+function compositionParentAssociation (entity, csn) {
   if (!entity || entity.kind !== 'entity') {
-    return;
+    return
   }
-  const elements = entity.elements ?? {};
+  const elements = entity.elements ?? {}
 
   // Add the change-tracking-isRootEntity attribute of the child entity
-  processCompositionElements(entity, csn, elements);
+  processCompositionElements(entity, csn, elements)
 
-  const hasChildFlag = entity[isRoot] !== false;
-  const hasParentEntity = entity[hasParent];
+  const hasChildFlag = entity[isRoot] !== false
+  const hasParentEntity = entity[hasParent]
 
   if (hasChildFlag || !hasParentEntity) {
     // Find parent association of the entity
-    const parentAssociation = findParentAssociation(entity, csn, elements);
+    const parentAssociation = findParentAssociation(entity, csn, elements)
     if (parentAssociation) {
-      const parentAssociationTarget = elements[parentAssociation]?.target;
-      if (hasChildFlag) setChangeTrackingIsRootEntity(entity, csn, false);
+      const parentAssociationTarget = elements[parentAssociation]?.target
+      if (hasChildFlag) setChangeTrackingIsRootEntity(entity, csn, false)
       return {
         ...csn.definitions?.[parentAssociationTarget],
         name: parentAssociationTarget
-      };
-    } else return;
+      }
+    } else return
   }
-  return { ...csn.definitions?.[entity.name], name: entity.name };
+  return { ...csn.definitions?.[entity.name], name: entity.name }
 }
 
-function processCompositionElements(entity, csn, elements) {
+function processCompositionElements (entity, csn, elements) {
   for (const name in elements) {
-    const element = elements[name];
-    const target = element?.target;
-    const definition = csn.definitions?.[target];
+    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;
+      continue
     }
-    setChangeTrackingIsRootEntity({ ...definition, name: target }, csn, false);
+    setChangeTrackingIsRootEntity({ ...definition, name: target }, csn, false)
   }
 }
 
-function findParentAssociation(entity, csn, elements) {
+function findParentAssociation (entity, csn, elements) {
   return Object.keys(elements).find((name) => {
-    const element = elements[name];
-    const target = element?.target;
+    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 ?? {};
+      const parentDefinition = csn.definitions?.[target] ?? {}
+      const parentElements = parentDefinition?.elements ?? {}
       return !!Object.keys(parentElements).find((parentEntityName) => {
-        const parentElement = parentElements?.[parentEntityName] ?? {};
+        const parentElement = parentElements?.[parentEntityName] ?? {}
         if (parentElement.type === 'cds.Composition') {
-          const isCompositionEntity = parentElement.target === entity.name;
+          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;
+          return isCompositionEntity
         }
-      });
+      })
     }
-  });
+  })
+}
+
+
+
+/**
+ * Returns an expression for the key of the given entity, which we can use as the right-hand-side of an ON condition.
+ */
+function entityKey4 (entity) {
+  const xpr = []
+  for (let k in entity.elements) {
+    const e = entity.elements[k]; if (!e.key) continue
+    if (xpr.length) xpr.push('||')
+    if (e.type === 'cds.Association') xpr.push({ ref: [k, e.keys?.[0]?.ref?.[0]] })
+    else xpr.push({ ref:[k] })
+  }
+  return xpr
 }
 
+
 // Unfold @changelog annotations in loaded model
-cds.on('loaded', m => {
+function enhanceModel (m) {
+
+  const _enhanced = 'sap.changelog.enhanced'
+  if (m.meta?.[_enhanced]) return // already enhanced
 
   // Get definitions from Dummy entity in our models
   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)
+  if (changes.on.length > 2) changes.on.pop() // remove ID -> filled in below
+
+  processEntities(m) // REVISIT: why is that required ?!?
 
   for (let name in m.definitions) {
+
     const entity = m.definitions[name]
-    if (isChangeTracked(entity)) {
+    if (entity.kind === 'entity' && !entity['@cds.autoexposed'] && isChangeTracked(entity)) {
 
-      // Determine entity keys
-      const keys = [], { elements: elms } = entity
-      for (let e in elms) if (elms[e].key) keys.push(e)
+      if (!entity['@changelog.disable_assoc']) {
 
-      // 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 keys = entityKey4(entity); if (!keys.length) continue // If no key attribute is defined for the entity, the logic to add association to ChangeView should be skipped.
+        const assoc = new cds.builtin.classes.Association({ ...changes, on: [ ...changes.on, ...keys ] })
 
-      // 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 {
-        entity.elements.changes = assoc
-      }
+        // --------------------------------------------------------------------
+        // PARKED: Add auto-exposed projection on ChangeView to service if applicable
+        // const namespace = name.match(/^(.*)\.[^.]+$/)[1]
+        // const service = m.definitions[namespace]
+        // if (service) {
+        //   const projection = {from:{ref:[assoc.target]}}
+        //   m.definitions[assoc.target = namespace + '.' + Changes] = {
+        //     '@cds.autoexposed':true, kind:'entity', projection
+        //   }
+        //   DEBUG?.(`\n
+        //     extend service ${namespace} with {
+        //       entity ${Changes} as projection on ${projection.from.ref[0]};
+        //     }
+        //   `.replace(/ {10}/g,''))
+        // }
+        // --------------------------------------------------------------------
+
+        DEBUG?.(`\n
+          extend ${name} with {
+            changes : Association to many ${assoc.target} on ${ assoc.on.map(x => x.ref?.join('.') || x).join(' ') };
+          }
+        `.replace(/ {8}/g,''))
+        const query = entity.projection || entity.query?.SELECT
+        if (query) (query.columns ??= ['*']).push({ as: 'changes', cast: assoc })
+        else if (entity.elements) entity.elements.changes = assoc
 
-      // Add UI.Facet for Change History List
-      if(!entity['@changelog.disable_facet'])
-        entity['@UI.Facets']?.push(facet)
+        // Add UI.Facet for Change History List
+        if (!entity['@changelog.disable_facet'])
+          entity['@UI.Facets']?.push(facet)
       }
 
       if (entity.actions) {
-        const hasParentInfo = entity[hasParent];
-        const entityName = hasParentInfo?.entityName;
-        const parentEntity = entityName ? m.definitions[entityName] : null;
-
-        const isParentRootAndHasFacets = parentEntity?.[isRoot] && parentEntity?.['@UI.Facets'];
-
+        const hasParentInfo = entity[hasParent]
+        const entityName = hasParentInfo?.entityName
+        const parentEntity = entityName ? m.definitions[entityName] : null
+        const isParentRootAndHasFacets = parentEntity?.[isRoot] && parentEntity?.['@UI.Facets']
         if (entity[isRoot] && entity['@UI.Facets']) {
           // Add side effects for root entity
-          addSideEffects(entity.actions, true);
+          addSideEffects(entity.actions, true)
         } else if (isParentRootAndHasFacets) {
           // Add side effects for child entity
-          addSideEffects(entity.actions, false, hasParentInfo?.associationName);
+          addSideEffects(entity.actions, false, hasParentInfo?.associationName)
         }
       }
     }
   }
-})
+  (m.meta ??= {})[_enhanced] = true
+}
 
 // Add generic change tracking handlers
-cds.on('served', () => {
+function addGenericHandlers() {
   const { track_changes, _afterReadChangeView } = require("./lib/change-log")
   for (const srv of cds.services) {
     if (srv instanceof cds.ApplicationService) {
@@ -220,4 +250,11 @@ cds.on('served', () => {
       }
     }
   }
-})
+}
+
+
+// Register plugin hooks
+cds.on('compile.for.runtime', csn => { DEBUG?.('on','compile.for.runtime'); enhanceModel(csn) })
+cds.on('compile.to.edmx', csn => { DEBUG?.('on','compile.to.edmx'); enhanceModel(csn) })
+cds.on('compile.to.dbx', csn => { DEBUG?.('on','compile.to.dbx'); enhanceModel(csn) })
+cds.on('served', addGenericHandlers)

package/index.cds

@@ -4,7 +4,7 @@ namespace sap.changelog;
 /**
  * Used in cds-plugin.js as template for tracked entities
  */
-aspect aspect @(UI.Facets: [{
+@cds.persistence.skip entity aspect @(UI.Facets: [{
   $Type : 'UI.ReferenceFacet',
   ID    : 'ChangeHistoryFacet',
   Label : '{i18n>ChangeHistory}',
@@ -37,15 +37,14 @@ view ChangeView as
  * Top-level changes entity, e.g. UPDATE Incident by, at, ...
  */
 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
+  serviceEntity : String(5000) @title: '{i18n>ChangeLog.serviceEntity}'; // definition name of target entity (on service level) - e.g. ProcessorsService.Incidents
+  entity        : String(5000) @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;
-  createdBy     : managed:createdBy;
+  createdAt     : managed:createdAt @title : '{i18n>ChangeLog.createdAt}';
+  createdBy     : managed:createdBy @title : '{i18n>ChangeLog.createdBy}';
   changes       : Composition of many Changes on changes.changeLog = $self;
 }
 
-
 /**
  * Attribute-level Changes with simple capturing of one-level
  * composition trees in parent... elements.
@@ -53,30 +52,30 @@ entity ChangeLog : managed, cuid {
 entity Changes {
 
   key ID                : UUID                     @UI.Hidden;
-      keys              : String                   @title: '{i18n>Changes.keys}';
-      attribute         : String                   @title: '{i18n>Changes.attribute}';
-      valueChangedFrom  : String                   @title: '{i18n>Changes.valueChangedFrom}';
-      valueChangedTo    : String                   @title: '{i18n>Changes.valueChangedTo}';
+      keys              : String(5000)             @title: '{i18n>Changes.keys}';
+      attribute         : String(5000)             @title: '{i18n>Changes.attribute}';
+      valueChangedFrom  : String(5000)             @title: '{i18n>Changes.valueChangedFrom}' @UI.MultiLineText;
+      valueChangedTo    : String(5000)             @title: '{i18n>Changes.valueChangedTo}' @UI.MultiLineText;
 
       // Business meaningful object id
-      entityID          : String                   @title: '{i18n>Changes.entityID}';
-      entity            : String                   @title: '{i18n>Changes.entity}'; // similar to ChangeLog.entity, but could be nested entity in a composition tree
-      serviceEntity     : String                   @title: '{i18n>Changes.serviceEntity}'; // similar to ChangeLog.serviceEntity, but could be nested entity in a composition tree
+      entityID          : String(5000)             @title: '{i18n>Changes.entityID}';
+      entity            : String(5000)             @title: '{i18n>Changes.entity}'; // similar to ChangeLog.entity, but could be nested entity in a composition tree
+      serviceEntity     : String(5000)             @title: '{i18n>Changes.serviceEntity}'; // similar to ChangeLog.serviceEntity, but could be nested entity in a composition tree
 
       // Business meaningful parent object id
-      parentEntityID    : String                   @title: '{i18n>Changes.parentEntityID}';
+      parentEntityID    : String(5000)             @title: '{i18n>Changes.parentEntityID}';
       parentKey         : UUID                     @title: '{i18n>Changes.parentKey}';
-      serviceEntityPath : String                   @title: '{i18n>Changes.serviceEntityPath}';
+      serviceEntityPath : String(5000)             @title: '{i18n>Changes.serviceEntityPath}';
 
       @title: '{i18n>Changes.modification}'
       modification      : String enum {
-        create = 'Create';
-        update = 'Edit';
-        delete = 'Delete';
+        Create = 'create';
+        Update = 'update';
+        Delete = 'delete';
       };
 
-      valueDataType     : String                   @title: '{i18n>Changes.valueDataType}';
-      changeLog         : Association to ChangeLog @title: '{i18n>ChangeLog.ID}';
+      valueDataType     : String(5000)             @title: '{i18n>Changes.valueDataType}';
+      changeLog         : Association to ChangeLog @title: '{i18n>ChangeLog.ID}' @UI.Hidden;
 }
 
 annotate ChangeView with @(UI: {

package/lib/change-log.js

@@ -13,11 +13,31 @@ const {
   getEntityByContextPath,
   getObjIdElementNamesInArray,
   getValueEntityType,
+  splitPath,
 } = require("./entity-helper")
 const { localizeLogFields } = require("./localization")
 const isRoot = "change-tracking-isRootEntity"
 
 
+function formatDecimal(str, scale) {
+  if (typeof str === "number" && !isNaN(str)) {
+    str = String(str);
+  } else return str;
+
+  if (scale > 0) {
+    let parts = str.split(".");
+    let decimalPart = parts[1] || "";
+
+    while (decimalPart.length < scale) {
+      decimalPart += "0";
+    }
+
+    return `${parts[0]}.${decimalPart}`;
+  }
+
+  return str;
+}
+
 const _getRootEntityPathVals = function (txContext, entity, entityKey) {
   const serviceEntityPathVals = []
   const entityIDs = _getEntityIDs(txContext.params)
@@ -168,13 +188,13 @@ const _formatCompositionContext = async function (changes, reqData) {
   const childNodeChanges = []
 
   for (const change of changes) {
-    if (typeof change.valueChangedTo === "object") {
+    if (typeof change.valueChangedTo === "object" && change.valueChangedTo instanceof Date !== true) {
       if (!Array.isArray(change.valueChangedTo)) {
         change.valueChangedTo = [change.valueChangedTo]
       }
       for (const childNodeChange of change.valueChangedTo) {
         const curChange = Object.assign({}, change)
-        const path = childNodeChange._path.split('/')
+        const path = splitPath(childNodeChange._path)
         const curNodePathVal = path.pop()
         curChange.modification = childNodeChange._op
         const objId = await _getChildChangeObjId(
@@ -197,7 +217,9 @@ const _formatCompositionValue = function (
   childNodeChange,
   childNodeChanges
 ) {
-  if (curChange.modification === "delete") {
+  if (curChange.modification === undefined) {
+    return
+  } else if (curChange.modification === "delete") {
     curChange.valueChangedFrom = objId
     curChange.valueChangedTo = ""
   } else if (curChange.modification === "update") {
@@ -249,7 +271,7 @@ const _getObjectIdByPath = async function (
 const _formatObjectID = async function (changes, reqData) {
   const objectIdCache = new Map()
   for (const change of changes) {
-    const path = change.serviceEntityPath.split('/')
+    const path = splitPath(change.serviceEntityPath)
     const curNodePathVal = path.pop()
     const parentNodePathVal = path.pop()
 
@@ -316,6 +338,28 @@ function _trackedChanges4 (srv, target, diff) {
       const eleParentKeys = element.parent.keys
       if (from === to) return
 
+      /**
+       * 
+       * HANA driver always filling up the defined decimal places with zeros,
+       * need to skip the change log if the value is not changed.
+       * Example:
+       * entity Books : cuid {
+       *   price     : Decimal(11, 4);
+       * }
+       * When price is updated from 3000.0000 to 3000, 
+       * the change log should not be created.
+       */
+      if (
+        row._op === "update" &&
+        element.type === "cds.Decimal" &&
+        cds.db.kind === "hana" &&
+        typeof to === "number"
+      ) {
+        const scaleNum = element.scale || 0;
+        if (from === formatDecimal(to, scaleNum))
+          return;
+      }
+
       /**
        * 
        * For the Inline entity such as Items, 
@@ -441,11 +485,36 @@ function getAssociationDetails (entity) {
   return { ID, foreignKey, parentEntity };
 }
 
+function isEmpty(value) {
+  return value === null || value === undefined || value === "";
+}
 
 async function track_changes (req) {
+  const config = cds.env.requires["change-tracking"];
+
+  if (
+    (req.event === 'UPDATE' && config?.disableUpdateTracking) ||
+    (req.event === 'CREATE' && config?.disableCreateTracking) ||
+    (req.event === 'DELETE' && config?.disableDeleteTracking)
+  ) {
+    return;
+  }
+
   let diff = await req.diff()
   if (!diff) return
 
+  const diffs = Array.isArray(diff) ? diff : [diff];
+  const changes = (
+    await Promise.all(diffs.map(item => trackChangesForDiff(item, req, this)))
+  ).filter(Boolean);
+
+  if (changes.length > 0) {
+    await INSERT.into("sap.changelog.ChangeLog").entries(changes);
+  }
+
+}
+
+async function trackChangesForDiff(diff, req, that){
   let target = req.target
   let compContext = null;
   let entityKey = diff.ID
@@ -462,10 +531,11 @@ async function track_changes (req) {
     target[isRoot] &&
     !cds.env.requires["change-tracking"]?.preserveDeletes
   ) {
-    return await DELETE.from(`sap.changelog.ChangeLog`).where({ entityKey });
+    await DELETE.from(`sap.changelog.ChangeLog`).where({ entityKey });
+    return;
   }
 
-  let changes = _trackedChanges4(this, target, diff)
+  let changes = _trackedChanges4(that, target, diff)
   if (!changes) return
 
   await _formatChangeLog(changes, req)
@@ -482,16 +552,16 @@ async function track_changes (req) {
     [ target, entityKey ] = await _prepareChangeLogForComposition(target, entityKey, changes, reqInfo)
   }
   const dbEntity = getDBEntity(target)
-  await INSERT.into("sap.changelog.ChangeLog").entries({
+  return {
     entity: dbEntity.name,
     entityKey: entityKey,
     serviceEntity: target.name || target,
-    changes: changes.filter(c => c.valueChangedFrom || c.valueChangedTo).map((c) => ({
+    changes: changes.filter(c => !isEmpty(c.valueChangedFrom) || !isEmpty(c.valueChangedTo)).map((c) => ({
       ...c,
       valueChangedFrom: `${c.valueChangedFrom ?? ''}`,
       valueChangedTo: `${c.valueChangedTo ?? ''}`,
     })),
-  })
+  };
 }
 
 module.exports = { track_changes, _afterReadChangeView }

package/lib/entity-helper.js

@@ -37,7 +37,7 @@ const getCurObjFromDbQuery = async function (entityName, queryVal, /**optional*/
 }
 
 const getCurObjFromReqData = function (reqData, nodePathVal, pathVal) {
-  const pathVals = pathVal.split('/')
+  const pathVals = splitPath(pathVal);
   const rootNodePathVal = pathVals[0]
   let curReqObj = reqData || {}
 
@@ -183,6 +183,25 @@ const _getCompositionObjFromReq = function (obj, targetID) {
     return null;
 };
 
+function splitPath (path) {
+  let result = [];
+  let buf = "";
+  let paren = 0;
+  for (let i = 0; i < path.length; i++) {
+    const c = path[i];
+    if (c === "(") paren++;
+    if (c === ")") paren--;
+    if (c === "/" && paren === 0) {
+      result.push(buf);
+      buf = "";
+    } else {
+      buf += c;
+    }
+  }
+  if (buf) result.push(buf);
+  return result;
+}
+
 module.exports = {
   getCurObjFromReqData,
   getCurObjFromDbQuery,
@@ -193,4 +212,5 @@ module.exports = {
   getEntityByContextPath,
   getObjIdElementNamesInArray,
   getValueEntityType,
+  splitPath,
 }

package/lib/localization.js

@@ -1,6 +1,6 @@
 const cds = require("@sap/cds/lib");
 const LOG = cds.log("change-log");
-const { getNameFromPathVal, getDBEntity } = require("./entity-helper");
+const { getNameFromPathVal, getDBEntity, splitPath } = require("./entity-helper");
 
 const MODIF_I18N_MAP = {
     create: "{i18n>ChangeLog.modification.create}",
@@ -36,7 +36,7 @@ const _localizeDefaultObjectID = function (change, locale) {
         change.objectID = change.entity ? change.entity : "";
     }
     if (change.objectID && change.serviceEntityPath && !change.parentObjectID && change.parentKey) {
-        const path = change.serviceEntityPath.split('/');
+        const path = splitPath(change.serviceEntityPath);
         const parentNodePathVal = path[path.length - 2];
         const parentEntityName = getNameFromPathVal(parentNodePathVal);
         const dbEntity = getDBEntity(parentEntityName);
@@ -98,7 +98,7 @@ const _getLabelI18nKeyOnEntity = function (entityName, /** optinal */ attribute)
     let def = cds.model.definitions[entityName];
     if (attribute) def = def?.elements[attribute]
     if (!def) return "";
-    return def['@Common.Label'] || def['@title'];
+    return def['@Common.Label'] || def['@title'] || def['@UI.HeaderInfo.TypeName'];
 };
 
 const localizeLogFields = function (data, locale) {

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@cap-js/change-tracking",
-  "version": "1.0.7",
+  "version": "1.1.0",
   "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)",
-  "license": "SEE LICENSE IN LICENSE",
+  "license": "Apache-2.0",
   "main": "cds-plugin.js",
   "files": [
     "lib",
@@ -18,18 +18,17 @@
     "test": "npx jest --silent"
   },
   "peerDependencies": {
-    "@sap/cds": ">=7"
+    "@sap/cds": ">=8"
+  },
+  "engines": {
+    "node": ">=20.0.0"
   },
   "devDependencies": {
     "@cap-js/change-tracking": "file:.",
-    "@cap-js/sqlite": "^1",
-    "axios": "^1",
-    "chai": "^4.3.10",
-    "chai-as-promised": "^7.1.1",
-    "chai-subset": "^1.6.0",
-    "eslint": "^8",
-    "express": "^4",
-    "jest": "^29"
+    "@cap-js/attachments": "^2",
+    "@cap-js/sqlite": "^1 || ^2",
+    "@cap-js/cds-test": "*",
+    "express": "^4"
   },
   "cds": {
     "requires": {