v2.5.1

CHANGELOG.md

@@ -1,3 +1,9 @@
+# 2.5.1
+
+* Simplified configuration injection in ``EclipseStoreRepositoryFactoryBean``.
+* Updated EclipseStore to v2.1.1
+* Updated org.springframework.boot.version to v3.4.2
+
 # 2.5.0
 
 * Updated org.springframework.boot.version to v3.4.1

README.md

@@ -59,7 +59,8 @@ instructions** are in the documentation](https://xdev-software.github.io/spring-
 | ``2.2.0-2.3.1``           | ``17`` | ``3.3.4``   | ``1.4.0``    |
 | ``2.4.0``                 | ``17`` | ``3.4.0``   | ``2.0.0``    |
 | ``2.4.1``                 | ``17`` | ``3.4.0``   | ``2.1.0``    |
-| ``>= 2.5.0``              | ``17`` | ``3.4.1``   | ``2.1.0``    |
+| ``2.5.0``                 | ``17`` | ``3.4.1``   | ``2.1.0``    |
+| ``>= 2.5.1``              | ``17`` | ``3.4.2``   | ``2.1.1``    |
 
 ## Demo
 
@@ -86,6 +87,12 @@ the [demos](./spring-data-eclipse-store-demo):
 If you need support as soon as possible, and you can't wait for any pull request, feel free to
 use [our support](https://xdev.software/en/services/support).
 
+## Additional Information
+
+* [Recording of an introduction talk at JUG Bangalore](https://www.youtube.com/watch?v=OlGZ2Hr0FdA)
+* [Recording of an introduction talk at JCON 2024](https://youtu.be/-WBbKUGeYBw?si=utZRlY9b2twQLxW8)
+* Blog-Article: [Minimize Costs by Utilizing Cloud Storage with Spring-Data-Eclipse-Store](https://foojay.io/today/minimize-costs-by-utilizing-cloud-storage-with-spring-data-eclipse-store/)
+
 ## Contributing
 See the [contributing guide](./CONTRIBUTING.md) for detailed instructions on how to get started with our project.
 

docs/modules/ROOT/nav.adoc

@@ -12,4 +12,5 @@
 ** xref:features/rest-api.adoc[REST Interface]
 ** xref:features/validation-constraints.adoc[Validation Constraints]
 * xref:migration-from-jpa.adoc[Migration from JPA]
+* xref:migration-from-eclipse-store.adoc[Migration from EclipseStore]
 * xref:known-issues.adoc[Known issues]

docs/modules/ROOT/pages/known-issues.adoc

@@ -13,10 +13,7 @@ That consists of https://docs.eclipsestore.io/manual/storage/legacy-type-mapping
 
 === Values
 
-There is a library to version your data in the store called https://github.com/xdev-software/micro-migration[XDEV MicroMigration].
-This helps you keep your data up to date regardless of the current version.
-
-We created https://github.com/xdev-software/spring-data-eclipse-store/issues/33[an issue] for that but right now we *do not support XDEVs MicroMigration*.
+Keeping data up-to-date is made easy through https://github.com/xdev-software/micro-migration[XDEV's MicroMigration] explained in detail in xref:features/versioned-migration.adoc[Versioned Migration].
 
 == Spring Developer Tools [[spring-dev-tools]]
 
@@ -41,12 +38,12 @@ Consequently, finding such a relationship requires searching the entire object g
 
 image::DependingClasses.svg[Example structure with orders and articles]
 
-Example Scenario:
+=== Example Scenario
 Consider an *order object* that contains references to several *article objects*.
 In this case, determining which order contains a specific article is nearly impossible without traversing the entire object graph to locate it.
 This lack of direct reference contrasts sharply with the behavior of SQL databases.
 
-What Happens When an Article is Deleted?
+=== What Happens When an Article is Deleted?
 
 1. In an *SQL Database*: +
 Attempting to delete an article that is still referenced (e.g., by an order) would typically result in an exception. +

docs/modules/ROOT/pages/migration-from-eclipse-store.adoc

@@ -0,0 +1,132 @@
+= Migration from EclipseStore
+
+Given the flexibility of EclipseStore and its diverse use cases, there is **no universal, one-size-fits-all solution for migrating data** between the two systems.
+
+The first step is to define the appropriate entities and repositories tailored to your requirements, ensuring they align with the existing data structure in EclipseStore.
+
+Next, the data must be transferred to the Spring-Data-Eclipse-Store storage.
+To facilitate this, both EclipseStore and {product-name} must run within the same JVM (Java Virtual Machine).
+This configuration enables the developer to operate both systems simultaneously and transfer data by making simple ``save`` calls to the respective repositories.
+
+== Example
+
+=== 0. Status Quo
+
+Let's say that this is the current state of the code:
+
+[source,java,title="``package software.xdev.example.eclipse.store``"]
+----
+public record Root(List<Owner> owners, List<Vet> vets){}
+public record Owner(String name, List<Pet> pets, List<Visit> visits){}
+public record Pet(String name){}
+public record Vet(String name, List<Owner> clients){}
+public record Visit(LocalDate date, Owner owner, Pet pet){}
+----
+
+In this case ``Root`` is the root-object of EclipseStore.
+
+=== 1. Building Repositories
+
+Now entities with its corresponding repositories must be created in the same project:
+
+[source,java,title="``package software.xdev.example.sdes.enitities``"]
+----
+	public class Owner{
+		@Id
+		@GeneratedValue(strategy = GenerationType.AUTO)
+		private long id;
+		private final String name;
+		private final List<Pet> pets;
+		private final List<Visit> visits;
+		//...
+	}
+	public class Vet{
+		@Id
+		@GeneratedValue(strategy = GenerationType.AUTO)
+		private long id;
+		private final String name;
+		private final List<Owner> clients;
+		//...
+	}
+	public class Visit{
+		@Id
+		@GeneratedValue(strategy = GenerationType.AUTO)
+		private long id;
+		private final LocalDate date;
+		private final Owner owner;
+		private final Pet pet;
+		//...
+	}
+	public class Pet{
+		@Id
+		@GeneratedValue(strategy = GenerationType.AUTO)
+		private long id;
+		private final String name;
+		//...
+	}
+----
+
+[source,java,title="``package software.xdev.example.sdes.repositories``"]
+----
+	public interface OwnerRepository extends CrudRepository<Owner, Long>{}
+	public interface VetRepository extends CrudRepository<Vet, Long>{}
+	public interface VisitRepository extends CrudRepository<Visit, Long>{}
+	public interface PetRepository extends CrudRepository<Pet, Long>{}
+----
+
+Note that the ``root`` object is not needed in the new structure.
+Since we want to transfer the data in the next step, it is good practice to keep these classes in the same project but in separate packages.
+It is recommended that **ids** fields are defined to improve performance.
+
+=== 3. Copy Data
+
+Now it's time to copy the actual data.
+For that we need to start up the old EclipseStore storage additionally to the {product-name} storage.
+Then we simply iterate over the existing data, repackage it in our new objects and store them through the repositories.
+
+[source,java,title="``package software.xdev.example.sdes.repositories``"]
+----
+package software.xdev.example;
+
+import org.eclipse.store.storage.embedded.types.EmbeddedStorage;
+import org.eclipse.store.storage.embedded.types.EmbeddedStorageManager;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.event.ContextRefreshedEvent;
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Service;
+import software.xdev.example.sdes.repositories.*;
+
+@Service
+public class EclipseStoreDataMigrater
+{
+	OwnerRepository ownerRepository;
+	VetRepository vetRepository;
+	VisitRepository visitRepository;
+	PetRepository petRepository;
+
+	@Autowired
+	public EclipseStoreDataMigrater(OwnerRepository ownerRepository, VetRepository vetRepository, VisitRepository visitRepository, PetRepository petRepository
+	)
+	{
+		this.ownerRepository = ownerRepository;
+		this.vetRepository = vetRepository;
+		this.visitRepository = visitRepository;
+		this.petRepository = petRepository;
+	}
+
+	@EventListener
+	public void migrateData(final ContextRefreshedEvent event)
+	{
+		final software.xdev.example.eclipse.store.Root root = new software.xdev.example.eclipse.store.Root(null, null);
+		try(final EmbeddedStorageManager storageManager = EmbeddedStorage.start(root))
+		{
+			root.owners.forEach(owner -> {
+				owner.pets.forEach(pet -> this.petRepository.save(new software.xdev.example.sdes.entities.Pet(pet.name)));
+				//...
+			});
+		}
+	}
+}
+----
+
+This is very simplified but shows the general strategy to migrate data from EclipseStore to {product-name}.

pom.xml

@@ -22,10 +22,10 @@
 		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 
 		<!-- Should be in sync with org.eclipse.store:integrations-spring-boot3 -->
-		<org.springframework.boot.version>3.4.1</org.springframework.boot.version>
-		<org.eclipse.store.version>2.1.0</org.eclipse.store.version>
-		<org.eclipse.serializer.version>2.1.0</org.eclipse.serializer.version>
-		<org.eclipse.storage-restservice-springboot.version>2.1.0</org.eclipse.storage-restservice-springboot.version>
+		<org.springframework.boot.version>3.4.2</org.springframework.boot.version>
+		<org.eclipse.store.version>2.1.1</org.eclipse.store.version>
+		<org.eclipse.serializer.version>2.1.1</org.eclipse.serializer.version>
+		<org.eclipse.storage-restservice-springboot.version>2.1.1</org.eclipse.storage-restservice-springboot.version>
 	</properties>
 
 	<modules>

renovate.json5

@@ -19,6 +19,17 @@
         "maven"
       ],
       "groupName": "net.sourceforge.pmd"
+    },
+    {
+      "description": "Group org.eclipse.store/serializer",
+      "matchPackagePatterns": [
+        "^org.eclipse.store",
+        "^org.eclipse.serializer"
+      ],
+      "datasources": [
+        "maven"
+      ],
+      "groupName": "org.eclipse.store-serializer"
     }
   ]
 }

spring-data-eclipse-store-demo/src/main/java/software/xdev/spring/data/eclipse/store/demo/dual/storage/invoice/PersistenceInvoiceConfiguration.java

@@ -11,13 +11,14 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Configuration;
 
+import software.xdev.spring.data.eclipse.store.demo.dual.storage.person.PersistencePersonConfiguration;
 import software.xdev.spring.data.eclipse.store.repository.config.EclipseStoreClientConfiguration;
 import software.xdev.spring.data.eclipse.store.repository.config.EnableEclipseStoreRepositories;
 
 
 /**
- * To set this configuration for the package we use the {@link EnableEclipseStoreRepositories#clientConfiguration()}
- * ()}. Another example:
+ * To set this configuration for the package we use the {@link EnableEclipseStoreRepositories#clientConfiguration()}.
+ * Another example:
  * {@link software.xdev.spring.data.eclipse.store.demo.dual.storage.person.PersistencePersonConfiguration}
  */
 @Configuration
@@ -49,7 +50,7 @@ public EmbeddedStorageFoundation<?> createEmbeddedStorageFoundation()
 		final EmbeddedStorageFoundation<?> storageFoundation =
 			EmbeddedStorage.Foundation(Storage.Configuration(Storage.FileProvider(Path.of(STORAGE_PATH))));
 		// This is only needed, if a different ClassLoader is used (e.g. when using spring-dev-tools)
-		storageFoundation.getConnectionFoundation().setClassLoaderProvider(getClassLoaderProvider());
+		storageFoundation.getConnectionFoundation().setClassLoaderProvider(this.getClassLoaderProvider());
 		return storageFoundation;
 	}
 }

spring-data-eclipse-store/pom.xml

@@ -51,13 +51,13 @@
 		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 
 		<!-- Should be in sync with org.eclipse.store:integrations-spring-boot3 -->
-		<org.springframework.boot.version>3.4.1</org.springframework.boot.version>
-		<org.eclipse.store.version>2.1.0</org.eclipse.store.version>
-		<org.eclipse.serializer.version>2.1.0</org.eclipse.serializer.version>
+		<org.springframework.boot.version>3.4.2</org.springframework.boot.version>
+		<org.eclipse.store.version>2.1.1</org.eclipse.store.version>
+		<org.eclipse.serializer.version>2.1.1</org.eclipse.serializer.version>
 		<hibernate-validator.version>8.0.2.Final</hibernate-validator.version>
 		<jakarta.el-api.version>6.0.1</jakarta.el-api.version>
 		<expressly.version>6.0.0-M1</expressly.version>
-		<hibernate-core.version>6.6.4.Final</hibernate-core.version>
+		<hibernate-core.version>6.6.5.Final</hibernate-core.version>
 		<micro-migration.version>3.0.1</micro-migration.version>
 	</properties>
 

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/config/EclipseStoreClientConfiguration.java

@@ -185,7 +185,7 @@ protected boolean shouldShutdownStorageOnContextClosed()
 			LOG.warn("Will shut down storage because Spring Boot DevTools Restarting is active. "
 				+ "This may cause some unexpected behavior. "
 				+ "For more information have a look at "
-				+ "https://spring-eclipsestore.xdev.software/known-issues.html#_spring_developer_tools");
+				+ "https://spring-eclipsestore.xdev.software/known-issues.html#spring-dev-tools");
 		}
 		return enabled;
 	}

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/config/EclipseStoreRepositoryConfigurationExtension.java

@@ -81,6 +81,7 @@ public String getRepositoryFactoryBeanClassName()
 	 * This is surely not the perfect way to get the correct configuration of that context, but it works with multiple
 	 * configurations, with no configuration and with a single configuration.
 	 */
+	@SuppressWarnings("NullableProblems")
 	@Override
 	public void postProcess(final BeanDefinitionBuilder builder, final AnnotationRepositoryConfigurationSource config)
 	{