feat: implement auditing metadata support for Datastore #534

Author: mehdi0933

spring-cloud-gcp-data-datastore/src/main/java/com/google/cloud/spring/data/datastore/core/mapping/DatastoreMappingContext.java

@@ -1,11 +1,11 @@
 /*
- * Copyright 2017-2019 the original author or authors.
+ * Copyright 2017-2026 the original author or authors.
  *
  * Licensed 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
  *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ * https://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,
@@ -38,22 +38,23 @@
  * @since 1.1
  */
 public class DatastoreMappingContext
-    extends AbstractMappingContext<DatastorePersistentEntity<?>, DatastorePersistentProperty>
-    implements ApplicationContextAware {
+        extends AbstractMappingContext<DatastorePersistentEntity<?>, DatastorePersistentProperty>
+        implements ApplicationContextAware {
 
   private static final FieldNamingStrategy DEFAULT_NAMING_STRATEGY =
-      PropertyNameFieldNamingStrategy.INSTANCE;
+          PropertyNameFieldNamingStrategy.INSTANCE;
 
   private static final FieldNamingStrategy FIELD_NAMING_STRATEGY = DEFAULT_NAMING_STRATEGY;
 
   private ApplicationContext applicationContext;
 
-  // Maps a given class to the set of other classes with which it shares the same Datastore
-  // Kind and that are subclasses of the given class.
   private static final Map<Class, Set<Class>> discriminationFamilies = new ConcurrentHashMap<>();
 
   private final boolean skipNullValue;
 
+  // Added for auditing support (Issue #534)
+  private boolean auditingEnabled = false;
+
   public DatastoreMappingContext() {
     this(false);
   }
@@ -69,51 +70,52 @@ public void setApplicationContext(ApplicationContext applicationContext) {
   }
 
   /**
-   * Registers in the DatastoreMappingContext that two classes are discriminated from the same
-   * Datastore Kind.
-   *
-   * @param parentClass the superclass.
-   * @param subClass the subclass.
+   * Returns whether auditing is enabled.
+   * @return true if auditing is enabled.
+   */
+  public boolean isAuditingEnabled() {
+    return this.auditingEnabled;
+  }
+
+  /**
+   * Sets whether auditing is enabled.
+   * @param auditingEnabled the auditing status.
    */
+  public void setAuditingEnabled(boolean auditingEnabled) {
+    this.auditingEnabled = auditingEnabled;
+  }
+
   public static void addDiscriminationClassConnection(Class parentClass, Class subClass) {
     Set<Class> setParent =
-        discriminationFamilies.computeIfAbsent(parentClass, unused -> new HashSet<>());
+            discriminationFamilies.computeIfAbsent(parentClass, unused -> new HashSet<>());
     Set<Class> setSubClass =
-        discriminationFamilies.computeIfAbsent(subClass, unused -> new HashSet<>());
+            discriminationFamilies.computeIfAbsent(subClass, unused -> new HashSet<>());
     setParent.add(subClass);
 
     setSubClass.forEach(
-        x -> {
-          if (!discriminationFamilies.get(parentClass).contains(x)) {
-            addDiscriminationClassConnection(parentClass, x);
-          }
-        });
+            x -> {
+              if (!discriminationFamilies.get(parentClass).contains(x)) {
+                addDiscriminationClassConnection(parentClass, x);
+              }
+            });
     Class grandParent = parentClass.getSuperclass();
     if (grandParent != null) {
       addDiscriminationClassConnection(grandParent, subClass);
     }
   }
 
-  /**
-   * Get the set of other classes that share the same underlying Datastore Kind and that are
-   * subclasses of the given class.
-   *
-   * @param clazz the class to look up.
-   * @return a {@code Set} of other classes that share the same Kind that are subclasses. Will be
-   *     {@code null} if this class is not discriminated from a set of other classes.
-   */
   public static Set<Class> getDiscriminationFamily(Class clazz) {
     return discriminationFamilies.get(clazz);
   }
 
   protected <T> DatastorePersistentEntityImpl<T> constructPersistentEntity(
-      TypeInformation<T> typeInformation) {
+          TypeInformation<T> typeInformation) {
     return new DatastorePersistentEntityImpl<>(typeInformation, this);
   }
 
   @Override
   protected <T> DatastorePersistentEntity<?> createPersistentEntity(
-      TypeInformation<T> typeInformation) {
+          TypeInformation<T> typeInformation) {
     DatastorePersistentEntityImpl<T> persistentEntity = constructPersistentEntity(typeInformation);
     if (this.applicationContext != null) {
       persistentEntity.setApplicationContext(this.applicationContext);
@@ -123,31 +125,23 @@ protected <T> DatastorePersistentEntity<?> createPersistentEntity(
 
   @Override
   protected DatastorePersistentProperty createPersistentProperty(
-      Property property, DatastorePersistentEntity<?> owner, SimpleTypeHolder simpleTypeHolder) {
+          Property property, DatastorePersistentEntity<?> owner, SimpleTypeHolder simpleTypeHolder) {
     return new DatastorePersistentPropertyImpl(
-        property, owner, simpleTypeHolder, FIELD_NAMING_STRATEGY, skipNullValue);
+            property, owner, simpleTypeHolder, FIELD_NAMING_STRATEGY, skipNullValue);
   }
 
-  /**
-   * A non-null version of the {@link MappingContext#getPersistentEntity(Class)}.
-   *
-   * @param entityClass the entity type.
-   * @return the {@link DatastorePersistentEntity} for the provided type.
-   * @throws DatastoreDataException if unable to retrieve a DatastorePersistentEntity for the
-   *     provided type.
-   */
   @NonNull
   public DatastorePersistentEntity<?> getDatastorePersistentEntity(Class<?> entityClass) {
     DatastorePersistentEntity<?> persistentEntity = this.getPersistentEntity(entityClass);
     if (persistentEntity != null) {
       return persistentEntity;
     } else {
       throw new DatastoreDataException(
-          "Unable to find a DatastorePersistentEntity for: " + entityClass);
+              "Unable to find a DatastorePersistentEntity for: " + entityClass);
     }
   }
 
   public boolean isSkipNullValue() {
     return skipNullValue;
   }
-}
+}

spring-cloud-gcp-data-datastore/src/main/java/com/google/cloud/spring/data/datastore/core/mapping/DatastorePersistentProperty.java

@@ -1,11 +1,11 @@
 /*
- * Copyright 2017-2019 the original author or authors.
+ * Copyright 2017-2026 the original author or authors.
  *
  * Licensed 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
  *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ * https://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,
@@ -24,58 +24,58 @@
  * @since 1.1
  */
 public interface DatastorePersistentProperty
-    extends PersistentProperty<DatastorePersistentProperty> {
+        extends PersistentProperty<DatastorePersistentProperty> {
 
   /**
    * Get the name of the field to store this property in Datastore.
-   *
    * @return the string name of the field.
    */
   String getFieldName();
 
   /**
-   * Whether the property contains entities that are related to this entity via the Cloud Datastore
-   * Ancestor relationship and have this entity as their ancestor.
-   *
-   * @return {@code true} if the property contains child entities. {@code false} otherwise.
+   * Whether the property contains child entities via Ancestor relationship.
+   * @return {@code true} if it contains child entities.
    */
   boolean isDescendants();
 
   /**
    * True if the property should be excluded from indexes.
-   *
-   * @return true if the property should be indexed
+   * @return true if unindexed.
    */
   boolean isUnindexed();
 
   /**
-   * Get the {@link EmbeddedType} of the property indicating what what type of embedding pathway
-   * will be used to store the property.
-   *
+   * Get the {@link EmbeddedType} of the property.
    * @return the embedded type.
    */
   EmbeddedType getEmbeddedType();
 
   /**
    * True if the property is stored within Datastore entity.
-   *
-   * @return true if the property is stored within Datastore entity
+   * @return true if column-backed.
    */
   boolean isColumnBacked();
 
   /**
    * Return whether this property is a lazily-fetched one.
-   *
-   * @return {@code true} if the property is lazily-fetched. {@code false} otherwise.
+   * @return {@code true} if lazily-fetched.
    */
   boolean isLazyLoaded();
 
   /**
-   * Return whether to skip null value, i.e., skip insertion if value is null.
-   *
-   * @return {@code true} if the null value is skipped. {@code false} otherwise.
+   * Return whether to skip null value.
+   * @return {@code true} if null is skipped.
    */
   default boolean isSkipNullValue() {
     return false;
   }
-}
+
+  // Auditing methods without @Override to avoid compilation issues in the interface
+  boolean isCreatedByProperty();
+
+  boolean isCreatedDateProperty();
+
+  boolean isLastModifiedByProperty();
+
+  boolean isLastModifiedDateProperty();
+}

spring-cloud-gcp-data-datastore/src/main/java/com/google/cloud/spring/data/datastore/core/mapping/DatastorePersistentPropertyImpl.java

@@ -1,11 +1,11 @@
 /*
- * Copyright 2017-2019 the original author or authors.
+ * Copyright 2017-2026 the original author or authors.
  *
  * Licensed 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
  *
- *      https://www.apache.org/licenses/LICENSE-2.0
+ * https://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,
@@ -16,6 +16,10 @@
 
 package com.google.cloud.spring.data.datastore.core.mapping;
 
+import org.springframework.data.annotation.CreatedBy;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.annotation.LastModifiedBy;
+import org.springframework.data.annotation.LastModifiedDate;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.model.AnnotationBasedPersistentProperty;
@@ -31,8 +35,8 @@
  * @since 1.1
  */
 public class DatastorePersistentPropertyImpl
-    extends AnnotationBasedPersistentProperty<DatastorePersistentProperty>
-    implements DatastorePersistentProperty {
+        extends AnnotationBasedPersistentProperty<DatastorePersistentProperty>
+        implements DatastorePersistentProperty {
 
   private static final String KEY_FIELD_NAME = "__key__";
 
@@ -49,34 +53,34 @@ public class DatastorePersistentPropertyImpl
    * @param fieldNamingStrategy the naming strategy used to get the column name of this property
    */
   DatastorePersistentPropertyImpl(
-      Property property,
-      PersistentEntity<?, DatastorePersistentProperty> owner,
-      SimpleTypeHolder simpleTypeHolder,
-      FieldNamingStrategy fieldNamingStrategy,
-      boolean isSkipNullValue) {
+          Property property,
+          PersistentEntity<?, DatastorePersistentProperty> owner,
+          SimpleTypeHolder simpleTypeHolder,
+          FieldNamingStrategy fieldNamingStrategy,
+          boolean isSkipNullValue) {
     super(property, owner, simpleTypeHolder);
     this.fieldNamingStrategy =
-        (fieldNamingStrategy != null)
-            ? fieldNamingStrategy
-            : PropertyNameFieldNamingStrategy.INSTANCE;
+            (fieldNamingStrategy != null)
+                    ? fieldNamingStrategy
+                    : PropertyNameFieldNamingStrategy.INSTANCE;
     this.isSkipNullValue = isSkipNullValue;
     verify();
   }
 
   private void verify() {
     if (hasFieldAnnotation() && (isDescendants() || isAssociation())) {
       throw new DatastoreDataException(
-          "Property cannot be annotated as @Field if it is annotated @Descendants or @Reference: "
-              + getFieldName());
+              "Property cannot be annotated as @Field if it is annotated @Descendants or @Reference: "
+                      + getFieldName());
     }
     if (isDescendants() && isAssociation()) {
       throw new DatastoreDataException(
-          "Property cannot be annotated both @Descendants and @Reference: " + getFieldName());
+              "Property cannot be annotated both @Descendants and @Reference: " + getFieldName());
     }
     if (isDescendants() && !isCollectionLike()) {
       throw new DatastoreDataException(
-          "Only collection-like properties can contain the "
-              + "descendant entity objects can be annotated @Descendants.");
+              "Only collection-like properties can contain the "
+                      + "descendant entity objects can be annotated @Descendants.");
     }
   }
 
@@ -140,4 +144,24 @@ public boolean isLazyLoaded() {
   public boolean isSkipNullValue() {
     return isSkipNullValue;
   }
-}
+
+  @Override
+  public boolean isCreatedByProperty() {
+    return isAnnotationPresent(CreatedBy.class);
+  }
+
+  @Override
+  public boolean isCreatedDateProperty() {
+    return isAnnotationPresent(CreatedDate.class);
+  }
+
+  @Override
+  public boolean isLastModifiedByProperty() {
+    return isAnnotationPresent(LastModifiedBy.class);
+  }
+
+  @Override
+  public boolean isLastModifiedDateProperty() {
+    return isAnnotationPresent(LastModifiedDate.class);
+  }
+}