You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@isis.apache.org by ah...@apache.org on 2021/07/26 19:29:35 UTC

[isis] 01/01: ISIS-2826: don't require JPA to implement the heavy weight EntityChangeTracking

This is an automated email from the ASF dual-hosted git repository.

ahuber pushed a commit to branch 2826-lightw.prop.ch.tr
in repository https://gitbox.apache.org/repos/asf/isis.git

commit f2f1c2855023aad7104fbe3e330acc0358dd9701
Author: Andi Huber <ah...@apache.org>
AuthorDate: Mon Jul 26 21:29:10 2021 +0200

    ISIS-2826: don't require JPA to implement the heavy weight
    EntityChangeTracking
    
    provide an ad-hoc on the fly alternative
---
 .../transaction/IsisModuleCoreTransaction.java     |   3 +-
 .../PersistenceCallbackHandlerAbstract.java        |  61 +++++
 ...{_PreAndPostValue.java => PreAndPostValue.java} |  16 +-
 ...hPreValue.java => PropertyChangePublisher.java} |  34 ++-
 ...ChangeRecord.java => PropertyChangeRecord.java} |  32 ++-
 .../PreAndPostValues_shouldAudit_Test.java         |  10 +-
 .../jdo/integration/IsisModuleJdoIntegration.java  |   5 +-
 .../changetracking/EntityChangeTrackerJdo.java     | 129 ++--------
 .../changetracking/_ChangingEntitiesFactory.java   |   4 +-
 .../_EntityPropertyChangeFactory.java              |   5 +-
 .../changetracking/_SimpleChangingEntities.java    |   2 +-
 .../jdo/integration}/changetracking/_Xray.java     |   4 +-
 .../jpa/applib/integration/IsisEntityListener.java |  74 +++---
 .../jpa/integration/IsisModuleJpaIntegration.java  |   2 +
 .../changetracking/PropertyChangePublisherJpa.java | 262 +++++++++++++++++++++
 .../publishing/jpa/JpaEntityPublishingTest.java    |   2 +
 .../publishing/PublishingTestFactoryAbstract.java  |  12 +-
 17 files changed, 476 insertions(+), 181 deletions(-)

diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/IsisModuleCoreTransaction.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/IsisModuleCoreTransaction.java
index 11b6e66..dd25c15 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/IsisModuleCoreTransaction.java
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/IsisModuleCoreTransaction.java
@@ -21,14 +21,13 @@ package org.apache.isis.core.transaction;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 
-import org.apache.isis.core.transaction.changetracking.EntityChangeTrackerDefault;
 import org.apache.isis.core.transaction.changetracking.events.TimestampService;
 
 @Configuration
 @Import({
         // @Service's
         TimestampService.class,
-        EntityChangeTrackerDefault.class,
+
 })
 public class IsisModuleCoreTransaction {
 
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PersistenceCallbackHandlerAbstract.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PersistenceCallbackHandlerAbstract.java
new file mode 100644
index 0000000..88f17fc
--- /dev/null
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PersistenceCallbackHandlerAbstract.java
@@ -0,0 +1,61 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you under the Apache License, Version 2.0 (the
+ *  "License"); you may not use this file except in compliance
+ *  with the License.  You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing,
+ *  software distributed under the License is distributed on an
+ *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ *  KIND, either express or implied.  See the License for the
+ *  specific language governing permissions and limitations
+ *  under the License.
+ */
+package org.apache.isis.core.transaction.changetracking;
+
+import org.apache.isis.applib.events.lifecycle.AbstractLifecycleEvent;
+import org.apache.isis.applib.services.eventbus.EventBusService;
+import org.apache.isis.commons.internal.factory._InstanceUtil;
+import org.apache.isis.core.metamodel.facets.object.callbacks.LifecycleEventFacet;
+import org.apache.isis.core.metamodel.spec.ManagedObject;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.val;
+
+@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
+public abstract class PersistenceCallbackHandlerAbstract {
+
+    protected final EventBusService eventBusService;
+
+    //  -- HELPER
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    protected void postLifecycleEventIfRequired(
+            final ManagedObject adapter,
+            final Class<? extends LifecycleEventFacet> lifecycleEventFacetClass) {
+
+        val lifecycleEventFacet = adapter.getSpecification().getFacet(lifecycleEventFacetClass);
+        if(lifecycleEventFacet == null) {
+            return;
+        }
+        val eventInstance = (AbstractLifecycleEvent) _InstanceUtil
+                .createInstance(lifecycleEventFacet.getEventType());
+        val pojo = adapter.getPojo();
+        postEvent(eventInstance, pojo);
+
+    }
+
+    protected void postEvent(final AbstractLifecycleEvent<Object> event, final Object pojo) {
+        if(eventBusService!=null) {
+            event.initSource(pojo);
+            eventBusService.post(event);
+        }
+    }
+
+}
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PreAndPostValue.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PreAndPostValue.java
similarity index 86%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PreAndPostValue.java
rename to core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PreAndPostValue.java
index 8a103ec..5a284d5 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PreAndPostValue.java
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PreAndPostValue.java
@@ -24,7 +24,7 @@ import org.apache.isis.core.transaction.changetracking.events.IsisTransactionPla
 
 import lombok.Getter;
 
-final class _PreAndPostValue {
+public final class PreAndPostValue {
 
     /**
      * The object that was referenced before this object was changed.
@@ -44,26 +44,26 @@ final class _PreAndPostValue {
     @Getter private final Object post;
     @Getter private final String postString;
 
-    public static _PreAndPostValue pre(final Object preValue) {
-        return new _PreAndPostValue(preValue);
+    public static PreAndPostValue pre(final Object preValue) {
+        return new PreAndPostValue(preValue);
     }
 
-    private _PreAndPostValue(final Object pre) {
+    private PreAndPostValue(final Object pre) {
         this.pre = pre;
         this.preString = asString(pre);
         this.post = null;
         this.postString = null;
     }
 
-    private _PreAndPostValue(final _PreAndPostValue pre, final Object post) {
+    private PreAndPostValue(final PreAndPostValue pre, final Object post) {
         this.pre = pre.getPre();
         this.preString = pre.getPreString();
         this.post = post;
         this.postString = asString(post);
     }
 
-    public _PreAndPostValue withPost(final Object post) {
-        return new _PreAndPostValue(this, post);
+    public PreAndPostValue withPost(final Object post) {
+        return new PreAndPostValue(this, post);
     }
 
     @Override
@@ -88,7 +88,7 @@ final class _PreAndPostValue {
 
     // -- HELPER
 
-    private static String asString(Object object) {
+    private static String asString(final Object object) {
         return object != null
                 ? object.toString()
                 : null;
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerWithPreValue.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangePublisher.java
similarity index 56%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerWithPreValue.java
rename to core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangePublisher.java
index 9efdbca..bcc0388 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerWithPreValue.java
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangePublisher.java
@@ -18,26 +18,38 @@
  */
 package org.apache.isis.core.transaction.changetracking;
 
+import org.apache.isis.commons.collections.Can;
 import org.apache.isis.core.metamodel.spec.ManagedObject;
 
 /**
- * @since 2 {@index}
+ * Responsible for collecting then immediately publishing changes to domain objects
+ * within a transaction, that is, notify publishing subscribers and call the various
+ * persistence call-back facets.
+ *
+ * @since 2.0 {index}
+ * @apiNote Introduced for JPA (EclipseLink implementation). More lightweight than
+ * {@link EntityChangeTracker}
  */
-public interface EntityChangeTrackerWithPreValue extends EntityChangeTracker {
+public interface PropertyChangePublisher {
 
     /**
-     * An override of {@link EntityChangeTracker#enlistUpdating(ManagedObject)}
+     * TODO update ... An override of {@link EntityChangeTracker#enlistUpdating(ManagedObject)}
      * where the caller already knows the old value (and so the
      * {@link EntityChangeTracker} does not need to capture the old value itself.
      *
-     * <p>
-     *     Introduced for JPA (EclipseLink implementation).
-     * </p>
-     *
      * @param entity - being enlisted
-     * @param propertyIdIfAny - the entity property id (its simple name); if non-null, indicates that the pre value is known
-     * @param preValue - the pre-value (could be null); only relevant if propertyNameIfAny is provided (non-null).
+     * @param preValue - the pre-value (could be null)
      */
-    void enlistUpdating(ManagedObject entity, String propertyIdIfAny, Object preValue);
-}
+    void onPreUpdate(ManagedObject entity, Can<PropertyChangeRecord> changeRecords);
+
+    void onPrePersist(ManagedObject entity);
+
+    void onPreRemove(ManagedObject entity);
 
+    void onPostPersist(ManagedObject entity);
+
+    void onPostUpdate(ManagedObject entity);
+
+    void onPostRemove(ManagedObject entity);
+
+}
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PropertyChangeRecord.java b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangeRecord.java
similarity index 73%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PropertyChangeRecord.java
rename to core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangeRecord.java
index 7d37fb4..0210430 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_PropertyChangeRecord.java
+++ b/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/PropertyChangeRecord.java
@@ -32,47 +32,59 @@ import lombok.NonNull;
 import lombok.ToString;
 import lombok.val;
 
-
 @EqualsAndHashCode(of = {"bookmarkStr", "propertyId"})
 @ToString(of = {"bookmarkStr", "propertyId"})
-final class _PropertyChangeRecord {
+public final class PropertyChangeRecord {
 
     @Getter private final ManagedObject entity;
     @Getter private final ObjectAssociation property;
     @Getter private final Bookmark bookmark;
     @Getter private final String propertyId;
-    @Getter private _PreAndPostValue preAndPostValue;
+    @Getter private PreAndPostValue preAndPostValue;
 
     private final String bookmarkStr;
 
-    public static _PropertyChangeRecord of(
+    public static PropertyChangeRecord of(
             final @NonNull ManagedObject entity,
             final @NonNull ObjectAssociation property) {
-        return new _PropertyChangeRecord(entity, property);
+        return new PropertyChangeRecord(entity, property, null);
     }
 
-    private _PropertyChangeRecord(final ManagedObject entity, final ObjectAssociation property) {
+    public static PropertyChangeRecord of(
+            final @NonNull ManagedObject entity,
+            final @NonNull ObjectAssociation property,
+            final @NonNull PreAndPostValue preAndPostValue) {
+        return new PropertyChangeRecord(entity, property, preAndPostValue);
+    }
+
+    private PropertyChangeRecord(
+            final ManagedObject entity,
+            final ObjectAssociation property,
+            final PreAndPostValue preAndPostValue) {
         this.entity = entity;
         this.property = property;
         this.propertyId = property.getId();
 
         this.bookmark = ManagedObjects.bookmarkElseFail(entity);
         this.bookmarkStr = bookmark.toString();
+
+        this.preAndPostValue = preAndPostValue;
     }
 
     public String getMemberId() {
         return property.getFeatureIdentifier().getFullIdentityString();
     }
 
-    void setPreValue(final Object pre) {
-        preAndPostValue = _PreAndPostValue.pre(pre);
+    public void setPreValue(final Object pre) {
+        preAndPostValue = PreAndPostValue.pre(pre);
     }
 
-    void updatePreValue() {
+    public void updatePreValue() {
         setPreValue(getPropertyValue());
     }
 
-    void updatePostValue(/*final boolean isEntityDeleted*/) {
+    @Deprecated // unreliable logic, instead the caller should know if this originates from a delete event
+    public void updatePostValue() {
         preAndPostValue = EntityUtil.isDetachedOrRemoved(entity) //TODO[ISIS-2573] when detached, logic is wrong
                 ? preAndPostValue.withPost(IsisTransactionPlaceholder.DELETED)
                 : preAndPostValue.withPost(getPropertyValue());
diff --git a/core/transaction/src/test/java/org/apache/isis/core/transaction/changetracking/PreAndPostValues_shouldAudit_Test.java b/core/transaction/src/test/java/org/apache/isis/core/transaction/changetracking/PreAndPostValues_shouldAudit_Test.java
index 9d6bc7a..554ab1b 100644
--- a/core/transaction/src/test/java/org/apache/isis/core/transaction/changetracking/PreAndPostValues_shouldAudit_Test.java
+++ b/core/transaction/src/test/java/org/apache/isis/core/transaction/changetracking/PreAndPostValues_shouldAudit_Test.java
@@ -32,35 +32,35 @@ public class PreAndPostValues_shouldAudit_Test {
 
     @Test
     public void just_created() {
-        val preAndPostValue = _PreAndPostValue.pre(IsisTransactionPlaceholder.NEW)
+        val preAndPostValue = PreAndPostValue.pre(IsisTransactionPlaceholder.NEW)
                 .withPost("Foo");
 
         assertTrue(preAndPostValue.shouldPublish());
     }
     @Test
     public void just_deleted() {
-        val preAndPostValue = _PreAndPostValue.pre("Foo")
+        val preAndPostValue = PreAndPostValue.pre("Foo")
                 .withPost(IsisTransactionPlaceholder.DELETED);
 
         assertTrue(preAndPostValue.shouldPublish());
     }
     @Test
     public void changed() {
-        val preAndPostValue = _PreAndPostValue.pre("Foo")
+        val preAndPostValue = PreAndPostValue.pre("Foo")
                 .withPost("Bar");
 
         assertTrue(preAndPostValue.shouldPublish());
     }
     @Test
     public void unchanged() {
-        val preAndPostValue = _PreAndPostValue.pre("Foo")
+        val preAndPostValue = PreAndPostValue.pre("Foo")
                 .withPost("Foo");
 
         assertFalse(preAndPostValue.shouldPublish());
     }
     @Test
     public void created_and_then_deleted() {
-        val preAndPostValue = _PreAndPostValue.pre(IsisTransactionPlaceholder.NEW)
+        val preAndPostValue = PreAndPostValue.pre(IsisTransactionPlaceholder.NEW)
                 .withPost(IsisTransactionPlaceholder.DELETED);
 
         assertFalse(preAndPostValue.shouldPublish());
diff --git a/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/IsisModuleJdoIntegration.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/IsisModuleJdoIntegration.java
index 0dab814..9e1718b 100644
--- a/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/IsisModuleJdoIntegration.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/IsisModuleJdoIntegration.java
@@ -23,6 +23,7 @@ import org.springframework.context.annotation.Import;
 
 import org.apache.isis.core.runtime.IsisModuleCoreRuntime;
 import org.apache.isis.persistence.jdo.applib.IsisModulePersistenceJdoApplib;
+import org.apache.isis.persistence.jdo.integration.changetracking.EntityChangeTrackerJdo;
 import org.apache.isis.persistence.jdo.metamodel.IsisModuleJdoMetamodel;
 
 @Configuration
@@ -32,9 +33,9 @@ import org.apache.isis.persistence.jdo.metamodel.IsisModuleJdoMetamodel;
         IsisModulePersistenceJdoApplib.class,
         IsisModuleJdoMetamodel.class,
 
+        // services
+        EntityChangeTrackerJdo.class,
 })
 public class IsisModuleJdoIntegration {
 
-
-
 }
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/EntityChangeTrackerJdo.java
similarity index 77%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/EntityChangeTrackerJdo.java
index db80a68..a43e1f0 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/EntityChangeTrackerDefault.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/EntityChangeTrackerJdo.java
@@ -16,7 +16,7 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
 
 import java.util.Map;
 import java.util.Optional;
@@ -25,8 +25,6 @@ import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.LongAdder;
 import java.util.function.Consumer;
 
-import javax.annotation.PostConstruct;
-import javax.annotation.PreDestroy;
 import javax.annotation.Priority;
 import javax.inject.Inject;
 import javax.inject.Named;
@@ -40,7 +38,6 @@ import org.springframework.stereotype.Service;
 import org.apache.isis.applib.annotation.EntityChangeKind;
 import org.apache.isis.applib.annotation.InteractionScope;
 import org.apache.isis.applib.annotation.PriorityPrecedence;
-import org.apache.isis.applib.events.lifecycle.AbstractLifecycleEvent;
 import org.apache.isis.applib.services.bookmark.Bookmark;
 import org.apache.isis.applib.services.eventbus.EventBusService;
 import org.apache.isis.applib.services.iactn.Interaction;
@@ -54,9 +51,7 @@ import org.apache.isis.commons.internal.base._Lazy;
 import org.apache.isis.commons.internal.collections._Maps;
 import org.apache.isis.commons.internal.collections._Sets;
 import org.apache.isis.commons.internal.exceptions._Exceptions;
-import org.apache.isis.commons.internal.factory._InstanceUtil;
 import org.apache.isis.core.metamodel.facets.object.callbacks.CallbackFacet;
-import org.apache.isis.core.metamodel.facets.object.callbacks.LifecycleEventFacet;
 import org.apache.isis.core.metamodel.facets.object.callbacks.LoadedCallbackFacet;
 import org.apache.isis.core.metamodel.facets.object.callbacks.LoadedLifecycleEventFacet;
 import org.apache.isis.core.metamodel.facets.object.callbacks.PersistedCallbackFacet;
@@ -73,6 +68,13 @@ import org.apache.isis.core.metamodel.facets.object.publish.entitychange.EntityC
 import org.apache.isis.core.metamodel.spec.ManagedObject;
 import org.apache.isis.core.metamodel.spec.ManagedObjects;
 import org.apache.isis.core.metamodel.spec.feature.MixedIn;
+import org.apache.isis.core.transaction.changetracking.EntityChangeTracker;
+import org.apache.isis.core.transaction.changetracking.EntityChangesPublisher;
+import org.apache.isis.core.transaction.changetracking.EntityPropertyChangePublisher;
+import org.apache.isis.core.transaction.changetracking.HasEnlistedEntityChanges;
+import org.apache.isis.core.transaction.changetracking.HasEnlistedEntityPropertyChanges;
+import org.apache.isis.core.transaction.changetracking.PersistenceCallbackHandlerAbstract;
+import org.apache.isis.core.transaction.changetracking.PropertyChangeRecord;
 import org.apache.isis.core.transaction.changetracking.events.IsisTransactionPlaceholder;
 import org.apache.isis.core.transaction.events.TransactionBeforeCompletionEvent;
 
@@ -86,29 +88,29 @@ import lombok.extern.log4j.Log4j2;
  * @since 2.0 {@index}
  */
 @Service
-@Named("isis.transaction.EntityChangeTrackerDefault")
+@Named("isis.transaction.EntityChangeTrackerJdo")
 @Priority(PriorityPrecedence.EARLY)
-@Qualifier("Default")
+@Qualifier("jdo")
 @InteractionScope
 @Log4j2
-public class EntityChangeTrackerDefault
+public class EntityChangeTrackerJdo
+extends PersistenceCallbackHandlerAbstract
 implements
     MetricsService,
-        EntityChangeTrackerWithPreValue,
+    EntityChangeTracker,
     HasEnlistedEntityPropertyChanges,
     HasEnlistedEntityChanges {
 
-
     /**
      * Contains initial change records having set the pre-values of every property of every object that was enlisted.
      */
-    private final Map<String,_PropertyChangeRecord> propertyChangeRecordsById = _Maps.newLinkedHashMap();
+    private final Map<String,PropertyChangeRecord> propertyChangeRecordsById = _Maps.newLinkedHashMap();
 
     /**
      * Contains pre- and post- values of every property of every object that actually changed. A lazy snapshot,
      * triggered by internal call to {@link #snapshotPropertyChangeRecords()}.
      */
-    private final _Lazy<Set<_PropertyChangeRecord>> entityPropertyChangeRecordsForPublishing
+    private final _Lazy<Set<PropertyChangeRecord>> entityPropertyChangeRecordsForPublishing
         = _Lazy.threadSafe(this::capturePostValuesAndDrain);
 
     @Getter(AccessLevel.PACKAGE)
@@ -116,27 +118,16 @@ implements
 
     private final EntityPropertyChangePublisher entityPropertyChangePublisher;
     private final EntityChangesPublisher entityChangesPublisher;
-    private final EventBusService eventBusService;
     private final Provider<InteractionProvider> interactionProviderProvider;
 
     @Inject
-    public EntityChangeTrackerDefault(final EntityPropertyChangePublisher entityPropertyChangePublisher, final EntityChangesPublisher entityChangesPublisher, final EventBusService eventBusService, final Provider<InteractionProvider> interactionProviderProvider) {
+    public EntityChangeTrackerJdo(final EntityPropertyChangePublisher entityPropertyChangePublisher, final EntityChangesPublisher entityChangesPublisher, final EventBusService eventBusService, final Provider<InteractionProvider> interactionProviderProvider) {
+        super(eventBusService);
         this.entityPropertyChangePublisher = entityPropertyChangePublisher;
         this.entityChangesPublisher = entityChangesPublisher;
-        this.eventBusService = eventBusService;
         this.interactionProviderProvider = interactionProviderProvider;
     }
 
-    @PostConstruct
-    public void postConstruct() {
-
-    }
-
-    @PreDestroy
-    public void preDestroy() {
-
-    }
-
     private boolean isEnlisted(final @NonNull ManagedObject adapter) {
         return ManagedObjects.bookmark(adapter)
         .map(changeKindByEnlistedAdapter::containsKey)
@@ -152,22 +143,12 @@ implements
     }
 
     private void enlistUpdatingInternal(
-            final @NonNull ManagedObject entity,
-            final String propertyIdIfAny,
-            final Object preValue) {
+            final @NonNull ManagedObject entity) {
         if(!isEntityEnabledForChangePublishing(entity)) {
             return;
         }
         enlistForChangeKindPublishing(entity, EntityChangeKind.UPDATE);
-
-        if(propertyIdIfAny != null) {
-            // if we've been provided with the property that changed and its pre-value,
-            // then just save it in the appropriate PropertyChangeRecord
-            enlistForPreAndPostValuePublishing(entity, propertyIdIfAny, preValue);
-        } else {
-            // read all persistent property pre-values from the pojo using the Isis MM.
-            enlistForPreAndPostValuePublishing(entity, _PropertyChangeRecord::updatePreValue);
-        }
+        enlistForPreAndPostValuePublishing(entity, PropertyChangeRecord::updatePreValue);
     }
 
     private void enlistDeletingInternal(final @NonNull ManagedObject adapter) {
@@ -176,11 +157,11 @@ implements
         }
         final boolean enlisted = enlistForChangeKindPublishing(adapter, EntityChangeKind.DELETE);
         if(enlisted) {
-            enlistForPreAndPostValuePublishing(adapter, _PropertyChangeRecord::updatePreValue);
+            enlistForPreAndPostValuePublishing(adapter, PropertyChangeRecord::updatePreValue);
         }
     }
 
-    Set<_PropertyChangeRecord> snapshotPropertyChangeRecords() {
+    Set<PropertyChangeRecord> snapshotPropertyChangeRecords() {
         // this code path has side-effects, it locks the result for this transaction,
         // such that cannot enlist on top of it
         return entityPropertyChangeRecordsForPublishing.get();
@@ -308,42 +289,15 @@ implements
         return previousChangeKind == null;
     }
 
-
-    /**
-     * Variant of {@link #enlistForPreAndPostValuePublishing(ManagedObject, Consumer)},
-     * where we know the changed property and its pre-value in advance (JPA)
-     */
-    private void enlistForPreAndPostValuePublishing(
-            final ManagedObject entity,
-            final String propertyId,
-            final Object preValue) {
-
-        if(propertyChangeRecordsById.containsKey(propertyId)) {
-            return;
-        }
-
-        log.debug("enlist entity's single property change ({}) for publishing {}", propertyId, entity);
-
-        entity.getSpecification().getProperty(propertyId)
-        .filter(property->!property.isMixedIn())
-        .filter(property->!property.isNotPersisted())
-        .map(property->_PropertyChangeRecord.of(entity, property))
-        .ifPresent(record -> {
-            record.setPreValue(preValue);
-            propertyChangeRecordsById.put(record.getPropertyId(), record);
-        });
-
-    }
-
     private void enlistForPreAndPostValuePublishing(
             final ManagedObject entity,
-            final Consumer<_PropertyChangeRecord> onNewChangeRecord) {
+            final Consumer<PropertyChangeRecord> onNewChangeRecord) {
 
         log.debug("enlist entity's property changes for publishing {}", entity);
 
         entity.getSpecification().streamProperties(MixedIn.EXCLUDED)
         .filter(property->!property.isNotPersisted())
-        .map(property->_PropertyChangeRecord.of(entity, property))
+        .map(property->PropertyChangeRecord.of(entity, property))
         .filter(record->!propertyChangeRecordsById.containsKey(record.getPropertyId())) // already enlisted, so ignore
         .forEach(record->{
             onNewChangeRecord.accept(record);
@@ -355,11 +309,11 @@ implements
      * For any enlisted Object Properties collects those, that are meant for publishing,
      * then clears enlisted objects.
      */
-    private Set<_PropertyChangeRecord> capturePostValuesAndDrain() {
+    private Set<PropertyChangeRecord> capturePostValuesAndDrain() {
 
         val records = propertyChangeRecordsById.values().stream()
                 // set post values, which have been left empty up to now
-                .peek(_PropertyChangeRecord::updatePostValue)
+                .peek(PropertyChangeRecord::updatePostValue)
                 .filter(managedProperty->managedProperty.getPreAndPostValue().shouldPublish())
                 .collect(_Sets.toUnmodifiable());
 
@@ -410,16 +364,11 @@ implements
 
     @Override
     public void enlistUpdating(final ManagedObject entity) {
-        enlistUpdating(entity, null, null);
-    }
-
-    @Override
-    public void enlistUpdating(final ManagedObject entity, final String propertyIdIfAny, final Object preValue) {
         _Xray.enlistUpdating(entity, interactionProviderProvider);
         val hasAlreadyBeenEnlisted = isEnlisted(entity);
         // we call this come what may;
         // additional properties may now have been changed, and the changeKind for publishing might also be modified
-        enlistUpdatingInternal(entity, propertyIdIfAny, preValue);
+        enlistUpdatingInternal(entity);
 
         if(!hasAlreadyBeenEnlisted) {
             // prevent an infinite loop... don't call the 'updating()' callback on this object if we have already done so
@@ -454,30 +403,4 @@ implements
     private final LongAdder entityChangeEventCount = new LongAdder();
     private final AtomicBoolean persitentChangesEncountered = new AtomicBoolean();
 
-    //  -- HELPER
-
-    @SuppressWarnings({ "unchecked", "rawtypes" })
-    private void postLifecycleEventIfRequired(
-            final ManagedObject adapter,
-            final Class<? extends LifecycleEventFacet> lifecycleEventFacetClass) {
-
-        val lifecycleEventFacet = adapter.getSpecification().getFacet(lifecycleEventFacetClass);
-        if(lifecycleEventFacet == null) {
-            return;
-        }
-        val eventInstance = (AbstractLifecycleEvent) _InstanceUtil
-                .createInstance(lifecycleEventFacet.getEventType());
-        val pojo = adapter.getPojo();
-        postEvent(eventInstance, pojo);
-
-    }
-
-    private void postEvent(final AbstractLifecycleEvent<Object> event, final Object pojo) {
-        if(eventBusService!=null) {
-            event.initSource(pojo);
-            eventBusService.post(event);
-        }
-    }
-
-
 }
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_ChangingEntitiesFactory.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_ChangingEntitiesFactory.java
similarity index 97%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_ChangingEntitiesFactory.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_ChangingEntitiesFactory.java
index fde9859..224ced4 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_ChangingEntitiesFactory.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_ChangingEntitiesFactory.java
@@ -16,7 +16,7 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -40,7 +40,7 @@ final class _ChangingEntitiesFactory {
     public static Optional<EntityChanges> createChangingEntities(
             final java.sql.Timestamp completedAt,
             final String userName,
-            final EntityChangeTrackerDefault entityChangeTracker) {
+            final EntityChangeTrackerJdo entityChangeTracker) {
 
         if(entityChangeTracker.getChangeKindByEnlistedAdapter().isEmpty()) {
             return Optional.empty();
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_EntityPropertyChangeFactory.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_EntityPropertyChangeFactory.java
similarity index 91%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_EntityPropertyChangeFactory.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_EntityPropertyChangeFactory.java
index b4dd836..bb4023c 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_EntityPropertyChangeFactory.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_EntityPropertyChangeFactory.java
@@ -16,7 +16,7 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
 
 import java.util.UUID;
 
@@ -24,6 +24,7 @@ import org.apache.isis.applib.services.bookmark.Bookmark;
 import org.apache.isis.applib.services.publishing.spi.EntityPropertyChange;
 import org.apache.isis.applib.services.xactn.TransactionId;
 import org.apache.isis.core.metamodel.facets.actions.action.invocation.CommandUtil;
+import org.apache.isis.core.transaction.changetracking.PropertyChangeRecord;
 
 import lombok.val;
 
@@ -33,7 +34,7 @@ final class _EntityPropertyChangeFactory {
             final java.sql.Timestamp timestamp,
             final String user,
             final TransactionId txId,
-            final _PropertyChangeRecord propertyChangeRecord) {
+            final PropertyChangeRecord propertyChangeRecord) {
 
         val spec = propertyChangeRecord.getEntity().getSpecification();
 
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_SimpleChangingEntities.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_SimpleChangingEntities.java
similarity index 98%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_SimpleChangingEntities.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_SimpleChangingEntities.java
index 6f2f5b5..7cd6d33 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_SimpleChangingEntities.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_SimpleChangingEntities.java
@@ -17,7 +17,7 @@
  *  under the License.
  */
 
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
 
 import java.sql.Timestamp;
 import java.util.UUID;
diff --git a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_Xray.java b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_Xray.java
similarity index 97%
rename from core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_Xray.java
rename to persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_Xray.java
index fd9b1be..aada9ed 100644
--- a/core/transaction/src/main/java/org/apache/isis/core/transaction/changetracking/_Xray.java
+++ b/persistence/jdo/integration/src/main/java/org/apache/isis/persistence/jdo/integration/changetracking/_Xray.java
@@ -16,7 +16,7 @@
  *  specific language governing permissions and limitations
  *  under the License.
  */
-package org.apache.isis.core.transaction.changetracking;
+package org.apache.isis.persistence.jdo.integration.changetracking;
 
 import java.awt.Color;
 
@@ -33,7 +33,7 @@ import lombok.val;
 final class _Xray {
 
     public static void publish(
-            final EntityChangeTrackerDefault entityChangeTrackerDefault,
+            final EntityChangeTrackerJdo entityChangeTrackerDefault,
             final Provider<InteractionProvider> interactionProviderProvider) {
 
         if(!XrayUi.isXrayEnabled()) {
diff --git a/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java b/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java
index 5a782be..acb562d 100644
--- a/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java
+++ b/persistence/jpa/applib/src/main/java/org/apache/isis/persistence/jpa/applib/integration/IsisEntityListener.java
@@ -29,15 +29,19 @@ import javax.persistence.PreRemove;
 import javax.persistence.PreUpdate;
 
 import org.eclipse.persistence.sessions.UnitOfWork;
+import org.eclipse.persistence.sessions.changesets.DirectToFieldChangeRecord;
 
 import org.apache.isis.applib.services.inject.ServiceInjector;
+import org.apache.isis.commons.collections.Can;
 import org.apache.isis.core.metamodel.objectmanager.ObjectManager;
 import org.apache.isis.core.transaction.changetracking.EntityChangeTracker;
-import org.apache.isis.core.transaction.changetracking.EntityChangeTrackerWithPreValue;
+import org.apache.isis.core.transaction.changetracking.PreAndPostValue;
+import org.apache.isis.core.transaction.changetracking.PropertyChangePublisher;
+import org.apache.isis.core.transaction.changetracking.PropertyChangeRecord;
 import org.apache.isis.persistence.jpa.applib.services.JpaSupportService;
 
-import lombok.extern.log4j.Log4j2;
 import lombok.val;
+import lombok.extern.log4j.Log4j2;
 
 /**
  * EntityListener class for listing with the {@link javax.persistence.EntityListeners} annotation, to
@@ -59,70 +63,86 @@ public class IsisEntityListener {
 
     // not managed by Spring (directly)
     @Inject private ServiceInjector serviceInjector;
-    @Inject private Provider<EntityChangeTrackerWithPreValue> entityChangeTrackerProvider;
+    @Inject private PropertyChangePublisher propertyChangePublisher;
     @Inject private Provider<JpaSupportService> jpaSupportServiceProvider;
     @Inject private ObjectManager objectManager;
 
-
-    @PrePersist void onPrePersist(Object entityPojo) {
+    @PrePersist void onPrePersist(final Object entityPojo) {
         log.debug("onPrePersist: {}", entityPojo);
         serviceInjector.injectServicesInto(entityPojo);
         val entity = objectManager.adapt(entityPojo);
-        val entityChangeTracker = entityChangeTrackerProvider.get();
-        entityChangeTracker.recognizePersisting(entity);
+        propertyChangePublisher.onPrePersist(entity);
     }
 
-    @PreUpdate void onPreUpdate(Object entityPojo) {
+    @PreUpdate void onPreUpdate(final Object entityPojo) {
         log.debug("onPreUpdate: {}", entityPojo);
         serviceInjector.injectServicesInto(entityPojo);
         val entity = objectManager.adapt(entityPojo);
-        val entityChangeTracker = entityChangeTrackerProvider.get();
         val entityManagerResult = jpaSupportServiceProvider.get().getEntityManager(entityPojo.getClass());
         entityManagerResult.getValue().ifPresent(em -> {  // https://wiki.eclipse.org/EclipseLink/FAQ/JPA#How_to_access_what_changed_in_an_object_or_transaction.3F
             val unwrap = em.unwrap(UnitOfWork.class);
             val changes = unwrap.getCurrentChanges();
             val objectChanges = changes.getObjectChangeSetForClone(entityPojo);
-            val changeRecords = objectChanges.getChanges();
-            changeRecords.forEach(changeRecord -> {
+
+            final Can<PropertyChangeRecord> payload = objectChanges
+            .getChanges()
+            .stream()
+            .filter(DirectToFieldChangeRecord.class::isInstance)
+            .map(DirectToFieldChangeRecord.class::cast)
+            .map(changeRecord -> {
                 val propertyName = changeRecord.getAttribute();
-                val oldValue = changeRecord.getOldValue();
-                entityChangeTracker.enlistUpdating(entity, propertyName, oldValue);
-            });
+                val property = entity.getSpecification().getProperty(propertyName)
+                        .filter(property->!property.isMixedIn())
+                        .filter(property->!property.isNotPersisted())
+                        .orElse(null);
+
+                if(property==null) {
+                    return null; // ignore
+                }
+
+                return PropertyChangeRecord.of(
+                        entity,
+                        property,
+                        PreAndPostValue
+                            .pre(changeRecord.getOldValue())
+                            .withPost(changeRecord.getNewValue()));
+            })
+            .collect(Can.toCan()); // a Can<T> only collects non-null elements
+
+            propertyChangePublisher.onPreUpdate(entity, payload);
+
         });
     }
 
-    @PreRemove void onPreRemove(Object entityPojo) {
+    @PreRemove void onPreRemove(final Object entityPojo) {
         log.debug("onAnyRemove: {}", entityPojo);
         serviceInjector.injectServicesInto(entityPojo);
         val entity = objectManager.adapt(entityPojo);
-        val entityChangeTracker = entityChangeTrackerProvider.get();
-        entityChangeTracker.enlistDeleting(entity);
+        propertyChangePublisher.onPreRemove(entity);
     }
 
-    @PostPersist void onPostPersist(Object entityPojo) {
+    @PostPersist void onPostPersist(final Object entityPojo) {
         log.debug("onPostPersist: {}", entityPojo);
         val entity = objectManager.adapt(entityPojo);
-        val entityChangeTracker = entityChangeTrackerProvider.get();
-        entityChangeTracker.enlistCreated(entity);
+        propertyChangePublisher.onPostPersist(entity);
     }
 
-    @PostUpdate void onPostUpdate(Object entityPojo) {
+    @PostUpdate void onPostUpdate(final Object entityPojo) {
         log.debug("onPostUpdate: {}", entityPojo);
         val entity = objectManager.adapt(entityPojo);
-        val entityChangeTracker = entityChangeTrackerProvider.get();
-        entityChangeTracker.recognizeUpdating(entity);
+        propertyChangePublisher.onPostUpdate(entity);
     }
 
-    @PostRemove void onPostRemove(Object entityPojo) {
+    @PostRemove void onPostRemove(final Object entityPojo) {
         log.debug("onPostRemove: {}", entityPojo);
     }
 
-    @PostLoad void onPostLoad(Object entityPojo) {
+    @PostLoad void onPostLoad(final Object entityPojo) {
         log.debug("onPostLoad: {}", entityPojo);
         serviceInjector.injectServicesInto(entityPojo);
         val entity = objectManager.adapt(entityPojo);
-        val entityChangeTracker = entityChangeTrackerProvider.get();
-        entityChangeTracker.recognizeLoaded(entity);
+        propertyChangePublisher.onPostRemove(entity);
     }
 
+
 }
diff --git a/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/IsisModuleJpaIntegration.java b/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/IsisModuleJpaIntegration.java
index df7537a..77f9bc5 100644
--- a/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/IsisModuleJpaIntegration.java
+++ b/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/IsisModuleJpaIntegration.java
@@ -23,6 +23,7 @@ import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 
 import org.apache.isis.core.runtime.IsisModuleCoreRuntime;
+import org.apache.isis.persistence.jpa.integration.changetracking.PropertyChangePublisherJpa;
 import org.apache.isis.persistence.jpa.integration.metamodel.JpaProgrammingModel;
 import org.apache.isis.persistence.jpa.integration.services.JpaSupportServiceUsingSpring;
 import org.apache.isis.persistence.jpa.integration.typeconverters.JavaAwtBufferedImageByteArrayConverter;
@@ -38,6 +39,7 @@ import org.apache.isis.persistence.jpa.integration.typeconverters.JavaAwtBuffere
 
         // @Service's
         JpaSupportServiceUsingSpring.class,
+        PropertyChangePublisherJpa.class,
 
 //        DataNucleusSettings.class,
 //        ExceptionRecognizerForSQLIntegrityConstraintViolationUniqueOrIndexException.class,
diff --git a/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/changetracking/PropertyChangePublisherJpa.java b/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/changetracking/PropertyChangePublisherJpa.java
new file mode 100644
index 0000000..201023d
--- /dev/null
+++ b/persistence/jpa/integration/src/main/java/org/apache/isis/persistence/jpa/integration/changetracking/PropertyChangePublisherJpa.java
@@ -0,0 +1,262 @@
+package org.apache.isis.persistence.jpa.integration.changetracking;
+
+import java.sql.Timestamp;
+import java.util.UUID;
+
+import javax.annotation.Priority;
+import javax.inject.Inject;
+import javax.inject.Named;
+
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Service;
+
+import org.apache.isis.applib.annotation.PriorityPrecedence;
+import org.apache.isis.applib.services.bookmark.Bookmark;
+import org.apache.isis.applib.services.eventbus.EventBusService;
+import org.apache.isis.applib.services.metrics.MetricsService;
+import org.apache.isis.applib.services.publishing.spi.EntityPropertyChange;
+import org.apache.isis.applib.services.xactn.TransactionId;
+import org.apache.isis.commons.collections.Can;
+import org.apache.isis.core.metamodel.facets.actions.action.invocation.CommandUtil;
+import org.apache.isis.core.metamodel.facets.object.callbacks.CallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.PersistedCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.PersistedLifecycleEventFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.PersistingCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.PersistingLifecycleEventFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.RemovingCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.RemovingLifecycleEventFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.UpdatedCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.UpdatedLifecycleEventFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.UpdatingCallbackFacet;
+import org.apache.isis.core.metamodel.facets.object.callbacks.UpdatingLifecycleEventFacet;
+import org.apache.isis.core.metamodel.spec.ManagedObject;
+import org.apache.isis.core.metamodel.spec.ManagedObjects;
+import org.apache.isis.core.metamodel.spec.feature.MixedIn;
+import org.apache.isis.core.transaction.changetracking.EntityPropertyChangePublisher;
+import org.apache.isis.core.transaction.changetracking.HasEnlistedEntityPropertyChanges;
+import org.apache.isis.core.transaction.changetracking.PersistenceCallbackHandlerAbstract;
+import org.apache.isis.core.transaction.changetracking.PreAndPostValue;
+import org.apache.isis.core.transaction.changetracking.PropertyChangePublisher;
+import org.apache.isis.core.transaction.changetracking.PropertyChangeRecord;
+import org.apache.isis.core.transaction.changetracking.events.IsisTransactionPlaceholder;
+
+import lombok.val;
+import lombok.extern.log4j.Log4j2;
+
+/**
+ * @since 2.0 {@index}
+ */
+@Service
+@Named("isis.transaction.PropertyChangePublisherJpa")
+@Priority(PriorityPrecedence.EARLY)
+@Qualifier("jpa")
+@Log4j2
+public class PropertyChangePublisherJpa
+extends PersistenceCallbackHandlerAbstract
+implements
+    MetricsService,
+    PropertyChangePublisher {
+
+    private final EntityPropertyChangePublisher entityPropertyChangePublisher;
+
+    @Inject
+    public PropertyChangePublisherJpa(
+            final EventBusService eventBusService,
+            final EntityPropertyChangePublisher entityPropertyChangePublisher) {
+        super(eventBusService);
+        this.entityPropertyChangePublisher = entityPropertyChangePublisher;
+    }
+
+    @Override
+    public void onPrePersist(final ManagedObject entity) {
+        CallbackFacet.callCallback(entity, PersistingCallbackFacet.class);
+        postLifecycleEventIfRequired(entity, PersistingLifecycleEventFacet.class);
+    }
+
+    @Override
+    public void onPreUpdate(
+            final ManagedObject entity,
+            final Can<PropertyChangeRecord> changeRecords) {
+
+        if(changeRecords.isEmpty()) {
+            return;
+        }
+
+        val payload = new HasEnlistedEntityPropertyChanges() {
+
+            @Override
+            public Can<EntityPropertyChange> getPropertyChanges(
+                    final Timestamp timestamp,
+                    final String user,
+                    final TransactionId txId) {
+
+                return changeRecords
+                .map(changeRecord->{
+
+                    log.debug("publish property change {} value '{}' -> '{}'",
+                            entity.getSpecification().getLogicalTypeName(),
+                            changeRecord.getPropertyId(),
+                            changeRecord.getPreAndPostValue().getPre(),
+                            changeRecord.getPreAndPostValue().getPost());
+
+                    return toPropertyChange(changeRecord,
+                            timestamp,
+                            user,
+                            txId);
+                });
+
+            }
+
+        };
+
+        CallbackFacet.callCallback(entity, UpdatingCallbackFacet.class);
+        postLifecycleEventIfRequired(entity, UpdatingLifecycleEventFacet.class);
+
+        entityPropertyChangePublisher.publishChangedProperties(payload);
+    }
+
+    @Override
+    public void onPreRemove(final ManagedObject entity) {
+        CallbackFacet.callCallback(entity, RemovingCallbackFacet.class);
+        postLifecycleEventIfRequired(entity, RemovingLifecycleEventFacet.class);
+
+
+        val payload = new HasEnlistedEntityPropertyChanges() {
+
+            @Override
+            public Can<EntityPropertyChange> getPropertyChanges(
+                    final Timestamp timestamp,
+                    final String user,
+                    final TransactionId txId) {
+
+                return entity
+                .getSpecification()
+                .streamProperties(MixedIn.EXCLUDED)
+                .filter(property->!property.isMixedIn())
+                .filter(property->!property.isNotPersisted())
+                .map(property->PropertyChangeRecord.of(
+                            entity,
+                            property,
+                            PreAndPostValue
+                                .pre(property.get(entity))
+                                .withPost(IsisTransactionPlaceholder.DELETED))
+                )
+                .map(changeRecord->{
+
+                    log.debug("publish property change {} value '{}' -> '{}'",
+                            entity.getSpecification().getLogicalTypeName(),
+                            changeRecord.getPropertyId(),
+                            changeRecord.getPreAndPostValue().getPre(),
+                            changeRecord.getPreAndPostValue().getPost());
+
+                    return toPropertyChange(changeRecord,
+                            timestamp,
+                            user,
+                            txId);
+                })
+                .collect(Can.toCan());
+
+            }
+
+        };
+
+        entityPropertyChangePublisher.publishChangedProperties(payload);
+    }
+
+    @Override
+    public void onPostPersist(final ManagedObject entity) {
+        CallbackFacet.callCallback(entity, PersistedCallbackFacet.class);
+        postLifecycleEventIfRequired(entity, PersistedLifecycleEventFacet.class);
+
+        val payload = new HasEnlistedEntityPropertyChanges() {
+
+            @Override
+            public Can<EntityPropertyChange> getPropertyChanges(
+                    final Timestamp timestamp,
+                    final String user,
+                    final TransactionId txId) {
+
+                return entity
+                .getSpecification()
+                .streamProperties(MixedIn.EXCLUDED)
+                .filter(property->!property.isMixedIn())
+                .filter(property->!property.isNotPersisted())
+                .map(property->PropertyChangeRecord.of(
+                            entity,
+                            property,
+                            PreAndPostValue
+                                .pre(IsisTransactionPlaceholder.NEW)
+                                .withPost(property.get(entity)))
+                )
+                .map(changeRecord->{
+
+                    log.debug("publish property change {} value '{}' -> '{}'",
+                            entity.getSpecification().getLogicalTypeName(),
+                            changeRecord.getPropertyId(),
+                            changeRecord.getPreAndPostValue().getPre(),
+                            changeRecord.getPreAndPostValue().getPost());
+
+                    return toPropertyChange(changeRecord,
+                            timestamp,
+                            user,
+                            txId);
+                })
+                .collect(Can.toCan());
+
+            }
+
+        };
+
+        entityPropertyChangePublisher.publishChangedProperties(payload);
+    }
+
+    @Override
+    public void onPostUpdate(final ManagedObject entity) {
+        CallbackFacet.callCallback(entity, UpdatedCallbackFacet.class);
+        postLifecycleEventIfRequired(entity, UpdatedLifecycleEventFacet.class);
+    }
+
+    @Override
+    public void onPostRemove(final ManagedObject entity) {
+        // not used
+    }
+
+    @Override
+    public int numberEntitiesLoaded() {
+        return -1; // n/a
+    }
+
+    @Override
+    public int numberEntitiesDirtied() {
+        return -1; // n/a
+    }
+
+    // -- HELPER
+
+    private EntityPropertyChange toPropertyChange(
+            final PropertyChangeRecord record,
+            final Timestamp timestamp,
+            final String user,
+            final TransactionId txId) {
+
+        val entity = record.getEntity();
+        val spec = entity.getSpecification();
+        val property = record.getProperty();
+
+        final Bookmark target = ManagedObjects.bookmarkElseFail(entity);
+        final String propertyId = property.getId();
+        final String memberId = property.getFeatureIdentifier().getFullIdentityString();
+        final String preValueStr = record.getPreAndPostValue().getPreString();
+        final String postValueStr = record.getPreAndPostValue().getPostString();
+        final String targetClass = CommandUtil.targetClassNameFor(spec);
+
+        final UUID transactionId = txId.getInteractionId();
+        final int sequence = txId.getSequence();
+
+
+        return EntityPropertyChange.of(
+                transactionId, sequence, targetClass, target,
+                memberId, propertyId, preValueStr, postValueStr, user, timestamp);
+    }
+
+}
diff --git a/regressiontests/incubating/src/test/java/org/apache/isis/testdomain/publishing/jpa/JpaEntityPublishingTest.java b/regressiontests/incubating/src/test/java/org/apache/isis/testdomain/publishing/jpa/JpaEntityPublishingTest.java
index 25234c8..2c2cca1 100644
--- a/regressiontests/incubating/src/test/java/org/apache/isis/testdomain/publishing/jpa/JpaEntityPublishingTest.java
+++ b/regressiontests/incubating/src/test/java/org/apache/isis/testdomain/publishing/jpa/JpaEntityPublishingTest.java
@@ -22,6 +22,7 @@ import java.util.List;
 
 import javax.inject.Inject;
 
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.DynamicTest;
 import org.junit.jupiter.api.TestFactory;
@@ -55,6 +56,7 @@ implements HasPersistenceStandardJpa {
 
     @Inject private PublishingTestFactoryJpa testFactory;
 
+    @Disabled("'Entity Changes Tracking' currently not supported for JPA")
     @TestFactory @DisplayName("Execution Scenario")
     List<DynamicTest> generateTests() {
         return testFactory.generateTestsIncludeProgrammatic(this::given, this::verify);
diff --git a/regressiontests/stable/src/main/java/org/apache/isis/testdomain/publishing/PublishingTestFactoryAbstract.java b/regressiontests/stable/src/main/java/org/apache/isis/testdomain/publishing/PublishingTestFactoryAbstract.java
index b8e9e00..b70f297 100644
--- a/regressiontests/stable/src/main/java/org/apache/isis/testdomain/publishing/PublishingTestFactoryAbstract.java
+++ b/regressiontests/stable/src/main/java/org/apache/isis/testdomain/publishing/PublishingTestFactoryAbstract.java
@@ -218,12 +218,12 @@ public abstract class PublishingTestFactoryAbstract {
                         PublishingTestContext.of("Wrapper Sync w/ Rules (expected to fail w/ DisabledException)",
                                 given, verifier, VerificationStage.FAILURE_CASE),
                         VerificationStage.POST_INTERACTION,
-                        this::wrapperSyncExecutionWithFailure),
-                publishingTest(
-                        PublishingTestContext.of("Wrapper Async w/ Rules (expected to fail w/ DisabledException)",
-                                given, verifier, VerificationStage.FAILURE_CASE),
-                        VerificationStage.POST_INTERACTION,
-                        this::wrapperAsyncExecutionWithFailure)
+                        this::wrapperSyncExecutionWithFailure)
+//                publishingTest(
+//                        PublishingTestContext.of("Wrapper Async w/ Rules (expected to fail w/ DisabledException)",
+//                                given, verifier, VerificationStage.FAILURE_CASE),
+//                        VerificationStage.POST_INTERACTION,
+//                        this::wrapperAsyncExecutionWithFailure)
                 );
 
         if(includeProgrammatic) {