upgrade testing-hibernate-native-alternatives to hibernate 7.0+

Author: fprochazka

.claude/settings.local.json

@@ -0,0 +1,21 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(./gradlew:*)",
+      "Bash(GRADLE_OPTS=\"-Dorg.gradle.console=plain -Dorg.gradle.stacktrace=always\" ./gradlew:*)",
+      "Bash(find:*)",
+      "Bash(grep:*)",
+      "Bash(cat:*)",
+      "Bash(mv:*)",
+      "Bash(git --no-pager log -n 1 --stat -p)",
+      "WebFetch(domain:hibernate.org)",
+      "WebFetch(domain:docs.hibernate.org)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:docs.jboss.org)",
+      "Bash(../../gradlew build)",
+      "WebFetch(domain:docs.hypersistence.io)"
+    ],
+    "deny": []
+  },
+  "enableAllProjectMcpServers": false
+}

gradle/libs.versions.toml

@@ -33,9 +33,12 @@ hibernate-orm-v63 = { group = "org.hibernate.orm", name = "hibernate-core", vers
 hibernate-orm-v64 = { group = "org.hibernate.orm", name = "hibernate-core", version = "6.4.10.Final" }
 hibernate-orm-v65 = { group = "org.hibernate.orm", name = "hibernate-core", version = "6.5.3.Final" }
 hibernate-orm-v66 = { group = "org.hibernate.orm", name = "hibernate-core", version = "6.6.26.Final" }
+hibernate-orm-v70 = { group = "org.hibernate.orm", name = "hibernate-core", version = "7.0.10.Final" }
+hibernate-orm-v71 = { group = "org.hibernate.orm", name = "hibernate-core", version = "7.1.0.Final" }
 hypersistence-utils-hibernate61 = { group = "io.hypersistence", name = "hypersistence-utils-hibernate-60", version = "3.9.4" }
 hypersistence-utils-hibernate62 = { group = "io.hypersistence", name = "hypersistence-utils-hibernate-62", version = "3.9.4" }
 hypersistence-utils-hibernate63 = { group = "io.hypersistence", name = "hypersistence-utils-hibernate-63", version = "3.10.3" }
+hypersistence-utils-hibernate70 = { group = "io.hypersistence", name = "hypersistence-utils-hibernate-70", version = "3.10.3" }
 hypersistence-tsid = { module = "io.hypersistence:hypersistence-tsid", version = "2.1.4" }
 kotlinx-serialization = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version = "1.7.0" }
 swagger-v3-core-jakarta = { module = "io.swagger.core.v3:swagger-core-jakarta", version = "2.2.35" }

modules/typed-ids-hibernate-70-testing/build.gradle.kts

@@ -0,0 +1,10 @@
+plugins {
+    id("framefork.java")
+}
+
+dependencies {
+    api(project(":typed-ids-testing"))
+
+    api(libs.hibernate.orm.v70)
+    api(libs.hypersistence.utils.hibernate70)
+}

modules/typed-ids-hibernate-70-testing/src/main/java/org/framefork/typedIds/hibernate/tests/AbstractContainerDataSourceProvider.java

@@ -0,0 +1,64 @@
+package org.framefork.typedIds.hibernate.tests;
+
+import io.hypersistence.utils.test.providers.DataSourceProvider;
+import org.testcontainers.containers.JdbcDatabaseContainer;
+
+import javax.sql.DataSource;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicReference;
+
+public abstract class AbstractContainerDataSourceProvider implements DataSourceProvider
+{
+
+    private final AtomicReference<JdbcDatabaseContainer<?>> container = new AtomicReference<>();
+
+    public JdbcDatabaseContainer<?> getContainer()
+    {
+        if (container.get() == null) {
+            synchronized (container) {
+                if (container.get() == null) {
+                    container.set(initContainer());
+                }
+            }
+        }
+
+        return Objects.requireNonNull(container.get(), "database container must not be null");
+    }
+
+    private JdbcDatabaseContainer<?> initContainer()
+    {
+        var newContainer = (JdbcDatabaseContainer<?>) newJdbcDatabaseContainer();
+
+        if (supportsDatabaseName()) {
+            newContainer.withDatabaseName(databaseName());
+        }
+        if (supportsCredentials()) {
+            newContainer.withUsername(username()).withPassword(password());
+        }
+
+        newContainer.withReuse(true).start();
+
+        return newContainer;
+    }
+
+    @Override
+    public final DataSource dataSource()
+    {
+        getContainer(); // force init
+        return newDataSource();
+    }
+
+    @Override
+    public final String url()
+    {
+        return getContainer().getJdbcUrl();
+    }
+
+    public String databaseName()
+    {
+        return "framefork";
+    }
+
+    protected abstract DataSource newDataSource();
+
+}

modules/typed-ids-hibernate-70-testing/src/main/java/org/framefork/typedIds/hibernate/tests/AbstractMySQLIntegrationTest.java

@@ -0,0 +1,31 @@
+package org.framefork.typedIds.hibernate.tests;
+
+import io.hypersistence.utils.test.AbstractHibernateTest;
+import io.hypersistence.utils.test.providers.DataSourceProvider;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+
+public abstract class AbstractMySQLIntegrationTest extends AbstractHibernateTest
+{
+
+    @BeforeEach
+    @Override
+    public void init()
+    {
+        super.init();
+    }
+
+    @AfterEach
+    @Override
+    public void destroy()
+    {
+        super.destroy();
+    }
+
+    @Override
+    protected DataSourceProvider dataSourceProvider()
+    {
+        return MySQLDataSourceProvider.V8;
+    }
+
+}

modules/typed-ids-hibernate-70-testing/src/main/java/org/framefork/typedIds/hibernate/tests/AbstractPostgreSQLIntegrationTest.java

@@ -0,0 +1,31 @@
+package org.framefork.typedIds.hibernate.tests;
+
+import io.hypersistence.utils.test.AbstractHibernateTest;
+import io.hypersistence.utils.test.providers.DataSourceProvider;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+
+public abstract class AbstractPostgreSQLIntegrationTest extends AbstractHibernateTest
+{
+
+    @BeforeEach
+    @Override
+    public void init()
+    {
+        super.init();
+    }
+
+    @AfterEach
+    @Override
+    public void destroy()
+    {
+        super.destroy();
+    }
+
+    @Override
+    protected DataSourceProvider dataSourceProvider()
+    {
+        return PostgreSQLDataSourceProvider.V16;
+    }
+
+}

modules/typed-ids-hibernate-70-testing/src/main/java/org/framefork/typedIds/hibernate/tests/MySQLDataSourceProvider.java

@@ -0,0 +1,67 @@
+package org.framefork.typedIds.hibernate.tests;
+
+import com.mysql.cj.jdbc.MysqlDataSource;
+import org.hibernate.dialect.Database;
+import org.hibernate.dialect.MySQLDialect;
+import org.testcontainers.containers.JdbcDatabaseContainer;
+import org.testcontainers.containers.MySQLContainer;
+
+import javax.sql.DataSource;
+import java.util.Map;
+
+public final class MySQLDataSourceProvider extends AbstractContainerDataSourceProvider
+{
+
+    public static final MySQLDataSourceProvider V8 = new MySQLDataSourceProvider("8.4");
+
+    private final String version;
+
+    private MySQLDataSourceProvider(final String version)
+    {
+        this.version = version;
+    }
+
+    @Override
+    public Database database()
+    {
+        return Database.MYSQL;
+    }
+
+    @Override
+    public String hibernateDialect()
+    {
+        return MySQLDialect.class.getName();
+    }
+
+    @Override
+    protected DataSource newDataSource()
+    {
+        var dataSource = new MysqlDataSource();
+        dataSource.setURL(url());
+        dataSource.setUser(username());
+        dataSource.setPassword(password());
+        return dataSource;
+    }
+
+    @Override
+    public String username()
+    {
+        return "mysql";
+    }
+
+    @Override
+    public String password()
+    {
+        return "admin";
+    }
+
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    @Override
+    public JdbcDatabaseContainer newJdbcDatabaseContainer()
+    {
+        var container = new MySQLContainer("mysql:" + version);
+        container.withTmpFs(Map.of("/var/lib/mysql", "rw"));
+        return container;
+    }
+
+}

modules/typed-ids-hibernate-70-testing/src/main/java/org/framefork/typedIds/hibernate/tests/PostgreSQLDataSourceProvider.java

@@ -0,0 +1,70 @@
+package org.framefork.typedIds.hibernate.tests;
+
+import org.hibernate.dialect.Database;
+import org.hibernate.dialect.PostgreSQLDialect;
+import org.postgresql.ds.PGSimpleDataSource;
+import org.testcontainers.containers.JdbcDatabaseContainer;
+import org.testcontainers.containers.PostgreSQLContainer;
+
+import javax.sql.DataSource;
+import java.util.Map;
+
+public final class PostgreSQLDataSourceProvider extends AbstractContainerDataSourceProvider
+{
+
+    public static final PostgreSQLDataSourceProvider V16 = new PostgreSQLDataSourceProvider("16.4");
+
+    private final String version;
+
+    private PostgreSQLDataSourceProvider(final String version)
+    {
+        this.version = version;
+    }
+
+    @Override
+    public Database database()
+    {
+        return Database.POSTGRESQL;
+    }
+
+    @Override
+    public String hibernateDialect()
+    {
+        return PostgreSQLDialect.class.getName();
+    }
+
+    @Override
+    protected DataSource newDataSource()
+    {
+        var dataSource = new PGSimpleDataSource();
+        dataSource.setURL(url());
+        dataSource.setUser(username());
+        dataSource.setPassword(password());
+
+        return dataSource;
+    }
+
+    @Override
+    public String username()
+    {
+        return "postgres";
+    }
+
+    @Override
+    public String password()
+    {
+        return "admin";
+    }
+
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    @Override
+    public JdbcDatabaseContainer newJdbcDatabaseContainer()
+    {
+        var container = new PostgreSQLContainer("postgres:" + version);
+        container.withCommand("postgres", "-c", "fsync=off", "-c", "random_page_cost=1.0", "-c", "synchronous_commit=off", "-c", "full_page_writes=off");
+        container.withEnv(Map.of("PGDATA", "/var/lib/postgresql/data"));
+        container.withTmpFs(Map.of("/var/lib/postgresql/data", "rw"));
+        return container;
+    }
+
+}

testing/testing-hibernate-native-alternatives/README.md

@@ -29,7 +29,7 @@ The `framefork/typed-ids` library provides a comprehensive solution for strongly
 
 ## Alternative Approaches Analysis
 
-### 1. @EmbeddedId with Java Records
+### 1. @EmbeddedId with Java Records (Not viable with Hibernate 7.0+)
 
 **What it solves:**
 - ✅ Compile-time Type Safety
@@ -52,7 +52,7 @@ The `framefork/typed-ids` library provides a comprehensive solution for strongly
 - ✅ JPQL Querying: Both `WHERE e.id = :embeddableObject` and `WHERE e.id.value = :primitiveValue` work
 - ✅ SELECT NEW Constructor: Supports both direct embedded object mapping and inline constructor calls
 
-### 2. @IdClass with Java Records
+### 2. @IdClass with Java Records (Not viable with Hibernate 7.0+)
 
 **What it solves:**
 - ✅ Compile-time Type Safety
@@ -110,6 +110,11 @@ Hibernate treats both approaches as **composite identifiers** even when using si
 
 The error message is identical: `"Identity generation isn't supported for composite ids"`
 
+### Hibernate Version Regression
+**Note:** These native approaches that previously worked with Hibernate 6.6.x now fail consistently with Hibernate 7.0+ due to stricter composite identifier validation.
+This represents a regression in functionality where previously working code now fails at runtime,
+further emphasizing the value of the `framefork/typed-ids` library which maintains consistent behavior across Hibernate versions.
+
 ## Conclusion
 
 This empirical analysis demonstrates that **native JPA/Hibernate approaches fail** when combining strongly-typed identifiers with database-generated keys.

testing/testing-hibernate-native-alternatives/build.gradle.kts

@@ -4,10 +4,10 @@ plugins {
 
 dependencies {
     // Need Hibernate for JPA annotations, but not the typed-ids implementations
-    implementation(libs.hibernate.orm.v66)
+    implementation(libs.hibernate.orm.v71)
     compileOnly(libs.jetbrains.annotations)
 
     // Only the testing infrastructure, not the actual typed-ids implementations
-    testImplementation(project(":typed-ids-hibernate-63-testing"))
+    testImplementation(project(":typed-ids-hibernate-70-testing"))
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }