From b0c22bc5ce293aadc788780eeb359405df02b722 Mon Sep 17 00:00:00 2001 From: Huang Xiao Date: Tue, 17 Nov 2026 10:20:14 +0800 Subject: [PATCH 1/4] feat: add JPA administration store Replace the JDBC administration bean in the JPA module with a store that pages, inserts, and locks the host character-UUID tables. --- vadmin-spring/vadmin-spring-jpa/pom.xml | 1 + .../JpaAccessControlConfiguration.java | 9 +- .../JpaAdministrationStore.java | 284 ++++++++++++++++++ .../JpaAdministrationStoreTest.java | 77 +++++ .../src/test/resources/mysql-iam/schema.sql | 37 +++ 5 files changed, 402 insertions(+), 6 deletions(-) create mode 100644 vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStore.java create mode 100644 vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java create mode 100644 vadmin-spring/vadmin-spring-jpa/src/test/resources/mysql-iam/schema.sql diff --git a/vadmin-spring/vadmin-spring-jpa/pom.xml b/vadmin-spring/vadmin-spring-jpa/pom.xml index 7d40c05..9be8c27 100644 --- a/vadmin-spring/vadmin-spring-jpa/pom.xml +++ b/vadmin-spring/vadmin-spring-jpa/pom.xml @@ -41,5 +41,6 @@ org.assertjassertj-coretest org.testcontainerstestcontainers-junit-jupitertest org.testcontainerstestcontainers-postgresqltest + com.h2databaseh2test diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/JpaAccessControlConfiguration.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/JpaAccessControlConfiguration.java index b6b1a48..7d9d464 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/JpaAccessControlConfiguration.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/JpaAccessControlConfiguration.java @@ -6,20 +6,17 @@ import io.github.huahill.vadmin.contracts.auth.LocalUserSessionLookup; import io.github.huahill.vadmin.platform.access.AccessControlRepository; import io.github.huahill.vadmin.platform.administration.AdministrationStore; -import io.github.huahill.vadmin.springjdbc.JdbcAdministrationStore; -import io.github.huahill.vadmin.springjdbc.UuidStorage; import io.github.huahill.vadmin.springjpa.access.JpaAccessControlRepository; import io.github.huahill.vadmin.springjpa.access.JpaLocalUserAccountLookup; import io.github.huahill.vadmin.springjpa.access.JpaLocalUserSessionLookup; import io.github.huahill.vadmin.springjpa.access.PermissionCatalogSynchronizer; +import io.github.huahill.vadmin.springjpa.administration.JpaAdministrationStore; import io.github.huahill.vadmin.springjpa.audit.JpaAuditSink; import jakarta.persistence.EntityManager; import org.springframework.boot.autoconfigure.AutoConfiguration; import org.springframework.boot.autoconfigure.AutoConfigureBefore; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; -import org.springframework.jdbc.core.JdbcTemplate; - @AutoConfiguration @AutoConfigureBefore({ org.springframework.boot.flyway.autoconfigure.FlywayAutoConfiguration.class, @@ -28,8 +25,8 @@ @EnableConfigurationProperties(LocalIamProperties.class) public class JpaAccessControlConfiguration { @Bean - AdministrationStore administrationStore(JdbcTemplate jdbcTemplate, LocalIamProperties properties) { - return new JdbcAdministrationStore(jdbcTemplate, properties.getTablePrefix(), UuidStorage.NATIVE); + AdministrationStore administrationStore(EntityManager entityManager, LocalIamProperties properties) { + return new JpaAdministrationStore(entityManager, properties.tables()); } @Bean diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStore.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStore.java new file mode 100644 index 0000000..7e2f48d --- /dev/null +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStore.java @@ -0,0 +1,284 @@ +package io.github.huahill.vadmin.springjpa.administration; + +import io.github.huahill.vadmin.contracts.navigation.PagedQuery; +import io.github.huahill.vadmin.contracts.navigation.PagedResult; +import io.github.huahill.vadmin.platform.administration.AdministrationStore; +import io.github.huahill.vadmin.springjpa.AccessControlTables; +import io.github.huahill.vadmin.springjpa.access.JpaPermissionEntity; +import io.github.huahill.vadmin.springjpa.access.JpaRoleEntity; +import io.github.huahill.vadmin.springjpa.access.JpaUserAccountEntity; +import jakarta.persistence.EntityManager; +import jakarta.persistence.LockModeType; +import jakarta.persistence.PersistenceException; +import jakarta.persistence.criteria.CriteriaBuilder; +import jakarta.persistence.criteria.Order; +import jakarta.persistence.criteria.Predicate; +import jakarta.persistence.criteria.Root; +import java.sql.Timestamp; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Objects; +import java.util.Set; +import java.util.UUID; + +/// System-administration storage for the host's existing character UUID tables. +public final class JpaAdministrationStore implements AdministrationStore { + private final EntityManager entityManager; + private final AccessControlTables tables; + + public JpaAdministrationStore(EntityManager entityManager) { + this(entityManager, AccessControlTables.of(null)); + } + + public JpaAdministrationStore(EntityManager entityManager, AccessControlTables tables) { + this.entityManager = Objects.requireNonNull(entityManager, "EntityManager must not be null."); + this.tables = Objects.requireNonNull(tables, "Access tables must not be null."); + } + + @Override + public PagedResult users(PagedQuery query) { + String filter = "%" + query.filters().getOrDefault("q", "").strip().toLowerCase(Locale.ROOT) + "%"; + CriteriaBuilder criteria = entityManager.getCriteriaBuilder(); + var count = criteria.createQuery(Long.class); + Root counted = count.from(JpaUserAccountEntity.class); + count.select(criteria.count(counted)).where(usernameMatches(criteria, counted, filter)); + long total = entityManager.createQuery(count).getSingleResult(); + + var selection = criteria.createQuery(JpaUserAccountEntity.class); + Root root = selection.from(JpaUserAccountEntity.class); + selection.select(root).where(usernameMatches(criteria, root, filter)) + .orderBy(userOrder(criteria, root, query)); + List items = entityManager.createQuery(selection) + .setFirstResult(offset(query)) + .setMaxResults(query.pageSize()) + .getResultList() + .stream() + .map(user -> new UserRow(user.id(), user.username(), user.enabled(), user.authVersion())) + .toList(); + return new PagedResult<>(items, total); + } + + @Override + public List roles() { + List rows = entityManager.createQuery( + "select role from JpaRoleEntity role order by role.code, role.id", JpaRoleEntity.class) + .getResultList(); + return withPermissions(rows.stream().map(role -> new RoleRow(role.id(), role.code(), 0, List.of())).toList()); + } + + @Override + public PagedResult roles(PagedQuery query) { + long total = count(JpaRoleEntity.class); + List rows = entityManager.createQuery( + "select role from JpaRoleEntity role order by role.code " + direction(query) + ", role.id", + JpaRoleEntity.class) + .setFirstResult(offset(query)) + .setMaxResults(query.pageSize()) + .getResultList(); + return new PagedResult<>(withPermissions(rows.stream() + .map(role -> new RoleRow(role.id(), role.code(), 0, List.of())).toList()), total); + } + + @Override + public PagedResult permissions(PagedQuery query) { + List rows = entityManager.createQuery( + "select permission from JpaPermissionEntity permission order by permission.code " + direction(query), + JpaPermissionEntity.class) + .setFirstResult(offset(query)) + .setMaxResults(query.pageSize()) + .getResultList() + .stream() + .map(permission -> new PermissionRow(permission.code(), permission.systemManaged())) + .toList(); + return new PagedResult<>(rows, count(JpaPermissionEntity.class)); + } + + @Override + public PagedResult audit(PagedQuery query) { + @SuppressWarnings("unchecked") + List rows = entityManager.createNativeQuery(""" + select occurred_at, action_code, target_type, target_id, outcome, correlation_id + from %s order by occurred_at desc, id + """.formatted(tables.auditEntries())) + .setFirstResult(offset(query)) + .setMaxResults(query.pageSize()) + .getResultList(); + List items = rows.stream().map(JpaAdministrationStore::auditRow).toList(); + Number total = (Number) entityManager.createNativeQuery("select count(*) from " + tables.auditEntries()) + .getSingleResult(); + return new PagedResult<>(items, total.longValue()); + } + + @Override + public Set userRoleIds(UUID userId) { + @SuppressWarnings("unchecked") + List rows = entityManager.createNativeQuery( + "select role_id from " + tables.userRoles() + " where user_id = :userId") + .setParameter("userId", userId.toString()) + .getResultList(); + return rows.stream().map(JpaAdministrationStore::uuid).collect(java.util.stream.Collectors.toUnmodifiableSet()); + } + + @Override + public boolean userExists(UUID userId) { + Number count = (Number) entityManager.createNativeQuery( + "select count(*) from " + tables.users() + " where id = :id") + .setParameter("id", userId.toString()) + .getSingleResult(); + return count.longValue() > 0; + } + + @Override + public boolean insertUser(UUID id, String username, String passwordHash) { + return insert(""" + insert into %s (id, username, password_hash, enabled, auth_version) + values (:id, :username, :passwordHash, true, 0) + """.formatted(tables.users()), Map.of( + "id", id.toString(), "username", username, "passwordHash", passwordHash)); + } + + @Override + public boolean insertRole(UUID id, String code) { + return insert("insert into " + tables.roles() + " (id, code) values (:id, :code)", + Map.of("id", id.toString(), "code", code)); + } + + @Override + public void setEnabled(UUID userId, boolean enabled) { + entityManager.createNativeQuery(""" + update %s set enabled = :enabled, auth_version = auth_version + 1 where id = :id + """.formatted(tables.users())) + .setParameter("enabled", enabled) + .setParameter("id", userId.toString()) + .executeUpdate(); + } + + @Override + public void replaceUserRoles(UUID userId, Set roleIds) { + entityManager.createNativeQuery("delete from " + tables.userRoles() + " where user_id = :userId") + .setParameter("userId", userId.toString()) + .executeUpdate(); + for (UUID roleId : roleIds) { + entityManager.createNativeQuery( + "insert into " + tables.userRoles() + " (user_id, role_id) values (:userId, :roleId)") + .setParameter("userId", userId.toString()) + .setParameter("roleId", roleId.toString()) + .executeUpdate(); + } + entityManager.createNativeQuery( + "update " + tables.users() + " set auth_version = auth_version + 1 where id = :id") + .setParameter("id", userId.toString()) + .executeUpdate(); + } + + @Override + public void lockAdministratorRole() { + entityManager.createQuery("select role from JpaRoleEntity role where role.code = 'administrator'", + JpaRoleEntity.class) + .setLockMode(LockModeType.PESSIMISTIC_WRITE) + .getResultList(); + } + + @Override + public boolean isLastEnabledAdministrator(UUID userId) { + @SuppressWarnings("unchecked") + List rows = entityManager.createNativeQuery(""" + select u.id from %s u + join %s membership on membership.user_id = u.id + join %s role on role.id = membership.role_id + where role.code = 'administrator' and u.enabled = true + """.formatted(tables.users(), tables.userRoles(), tables.roles())) + .getResultList(); + return rows.size() == 1 && userId.equals(uuid(rows.getFirst())); + } + + private List withPermissions(List rows) { + if (rows.isEmpty()) { + return List.of(); + } + Map> codes = new HashMap<>(); + @SuppressWarnings("unchecked") + List grants = entityManager.createNativeQuery(""" + select membership.role_id, permission.code + from %s membership + join %s permission on permission.id = membership.permission_id + where membership.role_id in (:roleIds) + order by permission.code + """.formatted(tables.rolePermissions(), tables.permissions())) + .setParameter("roleIds", rows.stream().map(row -> row.id().toString()).toList()) + .getResultList(); + for (Object[] grant : grants) { + codes.computeIfAbsent(uuid(grant[0]), ignored -> new ArrayList<>()).add(String.valueOf(grant[1])); + } + return rows.stream().map(row -> { + List permissions = codes.getOrDefault(row.id(), List.of()); + return new RoleRow(row.id(), row.code(), permissions.size(), permissions); + }).toList(); + } + + private boolean insert(String sql, Map parameters) { + try { + var statement = entityManager.createNativeQuery(sql); + parameters.forEach(statement::setParameter); + statement.executeUpdate(); + return true; + } catch (PersistenceException duplicate) { + return false; + } + } + + private long count(Class type) { + CriteriaBuilder criteria = entityManager.getCriteriaBuilder(); + var query = criteria.createQuery(Long.class); + query.select(criteria.count(query.from(type))); + return entityManager.createQuery(query).getSingleResult(); + } + + private static Predicate usernameMatches(CriteriaBuilder criteria, Root root, String filter) { + return criteria.like(criteria.lower(root.get("username")), filter); + } + + private static List userOrder(CriteriaBuilder criteria, Root root, PagedQuery query) { + String field = switch (query.sortField()) { + case "enabled" -> "enabled"; + case "authVersion" -> "authVersion"; + default -> "username"; + }; + Order primary = query.ascending() ? criteria.asc(root.get(field)) : criteria.desc(root.get(field)); + return List.of(primary, criteria.asc(root.get("id"))); + } + + private static AuditRow auditRow(Object[] row) { + return new AuditRow(instant(row[0]), String.valueOf(row[1]), String.valueOf(row[2]), String.valueOf(row[3]), + String.valueOf(row[4]), row[5] == null ? null : String.valueOf(row[5])); + } + + private static Instant instant(Object value) { + return switch (value) { + case Instant instant -> instant; + case Timestamp timestamp -> timestamp.toInstant(); + case OffsetDateTime offset -> offset.toInstant(); + case LocalDateTime local -> local.toInstant(ZoneOffset.UTC); + default -> throw new IllegalStateException("Unsupported audit timestamp: " + value.getClass().getName()); + }; + } + + private static UUID uuid(Object value) { + return value instanceof UUID id ? id : UUID.fromString(String.valueOf(value)); + } + + private static int offset(PagedQuery query) { + return Math.toIntExact(Math.multiplyExact((long) query.page(), query.pageSize())); + } + + private static String direction(PagedQuery query) { + return query.ascending() ? "asc" : "desc"; + } +} diff --git a/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java new file mode 100644 index 0000000..c6ee272 --- /dev/null +++ b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java @@ -0,0 +1,77 @@ +package io.github.huahill.vadmin.springjpa.administration; + +import static org.assertj.core.api.Assertions.assertThat; + +import io.github.huahill.vadmin.contracts.navigation.PagedQuery; +import io.github.huahill.vadmin.springjpa.access.JpaRoleEntity; +import jakarta.persistence.EntityManager; +import jakarta.persistence.LockModeType; +import java.util.Map; +import java.util.UUID; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.SpringBootConfiguration; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.flyway.autoconfigure.FlywayAutoConfiguration; +import org.springframework.boot.persistence.autoconfigure.EntityScan; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.DynamicPropertyRegistry; +import org.springframework.test.context.DynamicPropertySource; +import org.springframework.transaction.annotation.Transactional; + +@SpringBootTest(classes = JpaAdministrationStoreTest.TestApplication.class) +class JpaAdministrationStoreTest { + private static final UUID ADMIN_ID = UUID.fromString("11111111-1111-1111-1111-111111111111"); + private static final UUID ADMINISTRATOR_ROLE_ID = UUID.fromString("22222222-2222-2222-2222-222222222222"); + + @Autowired + private EntityManager entityManager; + + @DynamicPropertySource + static void database(DynamicPropertyRegistry registry) { + registry.add("spring.datasource.url", () -> + "jdbc:h2:mem:vadmin-admin;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE"); + registry.add("spring.datasource.username", () -> "sa"); + registry.add("spring.datasource.password", () -> ""); + registry.add("spring.jpa.hibernate.ddl-auto", () -> "none"); + registry.add("spring.flyway.enabled", () -> "false"); + registry.add("spring.sql.init.mode", () -> "always"); + registry.add("spring.sql.init.schema-locations", () -> "classpath:mysql-iam/schema.sql"); + registry.add("spring.jpa.properties.hibernate.type.preferred_uuid_jdbc_type", () -> "CHAR"); + } + + @Test + @Transactional + void should_page_users_and_lock_administrator_role_on_char36_ids() { + entityManager.createNativeQuery(""" + insert into vadmin_users (id, username, password_hash, enabled, auth_version) + values (:id, 'admin', 'hash', true, 1) + """).setParameter("id", ADMIN_ID.toString()).executeUpdate(); + entityManager.createNativeQuery(""" + insert into vadmin_roles (id, code) values (:id, 'administrator') + """).setParameter("id", ADMINISTRATOR_ROLE_ID.toString()).executeUpdate(); + + var store = new JpaAdministrationStore(entityManager); + var page = store.users(new PagedQuery(0, 10, "username", true, Map.of("q", "admin"))); + + assertThat(page.total()).isEqualTo(1); + assertThat(page.items()).singleElement().satisfies(user -> { + assertThat(user.id()).isEqualTo(ADMIN_ID); + assertThat(user.username()).isEqualTo("admin"); + }); + + store.lockAdministratorRole(); + JpaRoleEntity locked = entityManager.createQuery( + "select role from JpaRoleEntity role where role.code = 'administrator'", JpaRoleEntity.class) + .getSingleResult(); + assertThat(entityManager.getLockMode(locked)).isEqualTo(LockModeType.PESSIMISTIC_WRITE); + } + + @SpringBootConfiguration + @EnableAutoConfiguration(exclude = { + FlywayAutoConfiguration.class, + io.github.huahill.vadmin.springjpa.JpaAccessControlConfiguration.class + }) + @EntityScan(basePackages = "io.github.huahill.vadmin.springjpa") + static class TestApplication { } +} diff --git a/vadmin-spring/vadmin-spring-jpa/src/test/resources/mysql-iam/schema.sql b/vadmin-spring/vadmin-spring-jpa/src/test/resources/mysql-iam/schema.sql new file mode 100644 index 0000000..e8d4acc --- /dev/null +++ b/vadmin-spring/vadmin-spring-jpa/src/test/resources/mysql-iam/schema.sql @@ -0,0 +1,37 @@ +CREATE TABLE vadmin_users ( + id CHAR(36) NOT NULL PRIMARY KEY, + username VARCHAR(120) NOT NULL UNIQUE, + password_hash VARCHAR(255) NOT NULL, + enabled BOOLEAN NOT NULL, + auth_version BIGINT NOT NULL +); +CREATE TABLE vadmin_roles ( + id CHAR(36) NOT NULL PRIMARY KEY, + code VARCHAR(120) NOT NULL UNIQUE +); +CREATE TABLE vadmin_permissions ( + id CHAR(36) NOT NULL PRIMARY KEY, + code VARCHAR(120) NOT NULL UNIQUE, + system_managed BOOLEAN NOT NULL +); +CREATE TABLE vadmin_user_roles ( + user_id CHAR(36) NOT NULL, + role_id CHAR(36) NOT NULL, + PRIMARY KEY (user_id, role_id) +); +CREATE TABLE vadmin_role_permissions ( + role_id CHAR(36) NOT NULL, + permission_id CHAR(36) NOT NULL, + PRIMARY KEY (role_id, permission_id) +); +CREATE TABLE vadmin_audit_entries ( + id CHAR(36) NOT NULL PRIMARY KEY, + actor_user_id CHAR(36) NOT NULL, + action_code VARCHAR(120) NOT NULL, + target_type VARCHAR(120) NOT NULL, + target_id VARCHAR(255) NOT NULL, + outcome VARCHAR(16) NOT NULL, + occurred_at TIMESTAMP NOT NULL, + correlation_id VARCHAR(64), + metadata VARCHAR(4000) +); From 40074c1f1d1f3baad7bf7e6f4f6d551e55513c81 Mon Sep 17 00:00:00 2001 From: Huang Xiao Date: Tue, 17 Nov 2026 10:23:37 +0800 Subject: [PATCH 2/4] fix: map VAdmin identity UUIDs as CHAR(36) MySQLDialect otherwise stores UUIDs as binary and cannot read the host CHAR(36) identity rows. Account, session, and audit lookups round-trip the same string id. --- .../springjpa/access/JpaPermissionEntity.java | 4 + .../springjpa/access/JpaRoleEntity.java | 4 + .../access/JpaUserAccountEntity.java | 4 + .../springjpa/audit/JpaAuditEntryEntity.java | 5 +- .../springjpa/MySqlChar36IdentityTest.java | 86 +++++++++++++++++++ .../JpaAdministrationStoreTest.java | 1 + 6 files changed, 103 insertions(+), 1 deletion(-) create mode 100644 vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlChar36IdentityTest.java diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaPermissionEntity.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaPermissionEntity.java index 3e09f36..4ab3c6b 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaPermissionEntity.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaPermissionEntity.java @@ -5,11 +5,15 @@ import jakarta.persistence.Id; import jakarta.persistence.Table; import java.util.UUID; +import org.hibernate.annotations.JdbcTypeCode; +import org.hibernate.type.SqlTypes; @Entity @Table(name = "vadmin_permissions") public class JpaPermissionEntity { @Id + @JdbcTypeCode(SqlTypes.CHAR) + @Column(length = 36) private UUID id; @Column(nullable = false, unique = true) diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaRoleEntity.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaRoleEntity.java index d40423c..d5de103 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaRoleEntity.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaRoleEntity.java @@ -5,11 +5,15 @@ import jakarta.persistence.Id; import jakarta.persistence.Table; import java.util.UUID; +import org.hibernate.annotations.JdbcTypeCode; +import org.hibernate.type.SqlTypes; @Entity @Table(name = "vadmin_roles") public class JpaRoleEntity { @Id + @JdbcTypeCode(SqlTypes.CHAR) + @Column(length = 36) private UUID id; @Column(nullable = false, unique = true) diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaUserAccountEntity.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaUserAccountEntity.java index d4dc7eb..6b574ff 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaUserAccountEntity.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaUserAccountEntity.java @@ -5,11 +5,15 @@ import jakarta.persistence.Id; import jakarta.persistence.Table; import java.util.UUID; +import org.hibernate.annotations.JdbcTypeCode; +import org.hibernate.type.SqlTypes; @Entity @Table(name = "vadmin_users") public class JpaUserAccountEntity { @Id + @JdbcTypeCode(SqlTypes.CHAR) + @Column(length = 36) private UUID id; @Column(nullable = false, unique = true) diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/audit/JpaAuditEntryEntity.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/audit/JpaAuditEntryEntity.java index a3f4598..13d1691 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/audit/JpaAuditEntryEntity.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/audit/JpaAuditEntryEntity.java @@ -17,9 +17,12 @@ @Table(name = "vadmin_audit_entries") public class JpaAuditEntryEntity { @Id + @JdbcTypeCode(SqlTypes.CHAR) + @Column(length = 36) private UUID id; - @Column(name = "actor_user_id", nullable = false) + @JdbcTypeCode(SqlTypes.CHAR) + @Column(name = "actor_user_id", nullable = false, length = 36) private UUID actorUserId; @Column(name = "action_code", nullable = false) diff --git a/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlChar36IdentityTest.java b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlChar36IdentityTest.java new file mode 100644 index 0000000..d4d1aec --- /dev/null +++ b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlChar36IdentityTest.java @@ -0,0 +1,86 @@ +package io.github.huahill.vadmin.springjpa; + +import static org.assertj.core.api.Assertions.assertThat; + +import io.github.huahill.vadmin.contracts.audit.AuditEvent; +import io.github.huahill.vadmin.contracts.audit.AuditMetadataRedactor; +import io.github.huahill.vadmin.contracts.audit.AuditOutcome; +import io.github.huahill.vadmin.contracts.auth.LocalUserAccountLookup; +import io.github.huahill.vadmin.contracts.auth.LocalUserSessionLookup; +import io.github.huahill.vadmin.springjpa.access.JpaLocalUserAccountLookup; +import io.github.huahill.vadmin.springjpa.access.JpaLocalUserSessionLookup; +import io.github.huahill.vadmin.springjpa.audit.JpaAuditSink; +import jakarta.persistence.EntityManager; +import java.time.Instant; +import java.util.Map; +import java.util.UUID; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.SpringBootConfiguration; +import org.springframework.boot.autoconfigure.EnableAutoConfiguration; +import org.springframework.boot.flyway.autoconfigure.FlywayAutoConfiguration; +import org.springframework.boot.persistence.autoconfigure.EntityScan; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.DynamicPropertyRegistry; +import org.springframework.test.context.DynamicPropertySource; +import org.springframework.transaction.annotation.Transactional; + +@SpringBootTest(classes = MySqlChar36IdentityTest.TestApplication.class) +class MySqlChar36IdentityTest { + private static final UUID USER_ID = UUID.fromString("33333333-3333-3333-3333-333333333333"); + + @Autowired + private EntityManager entityManager; + + @DynamicPropertySource + static void database(DynamicPropertyRegistry registry) { + registry.add("spring.datasource.url", () -> + "jdbc:h2:mem:vadmin-char36;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE"); + registry.add("spring.datasource.username", () -> "sa"); + registry.add("spring.datasource.password", () -> ""); + registry.add("spring.jpa.hibernate.ddl-auto", () -> "none"); + registry.add("spring.jpa.database-platform", () -> "org.hibernate.dialect.MySQLDialect"); + registry.add("spring.flyway.enabled", () -> "false"); + registry.add("spring.sql.init.mode", () -> "always"); + registry.add("spring.sql.init.schema-locations", () -> "classpath:mysql-iam/schema.sql"); + } + + @Test + @Transactional + void should_round_trip_a_char36_user_session_and_audit_row() { + entityManager.createNativeQuery(""" + insert into vadmin_users (id, username, password_hash, enabled, auth_version) + values (:id, 'ada', 'hash', true, 2) + """).setParameter("id", USER_ID.toString()).executeUpdate(); + entityManager.flush(); + entityManager.clear(); + + LocalUserAccountLookup accounts = new JpaLocalUserAccountLookup(entityManager, AccessControlTables.of(null)); + LocalUserSessionLookup sessions = new JpaLocalUserSessionLookup(entityManager); + var audit = new JpaAuditSink(entityManager, new AuditMetadataRedactor()); + + assertThat(accounts.findByUserId(USER_ID)).get().satisfies(account -> { + assertThat(account.userId()).isEqualTo(USER_ID); + assertThat(account.username()).isEqualTo("ada"); + }); + assertThat(sessions.findSessionByUserId(USER_ID)).get() + .extracting(session -> session.userId()) + .isEqualTo(USER_ID); + + audit.append(new AuditEvent(USER_ID, "user.enabled", "user", USER_ID.toString(), AuditOutcome.SUCCESS, + Instant.parse("2026-11-17T02:00:00Z"), "corr-1", Map.of())); + entityManager.flush(); + Object storedId = entityManager.createNativeQuery( + "select actor_user_id from vadmin_audit_entries where correlation_id = 'corr-1'") + .getSingleResult(); + assertThat(storedId.toString()).isEqualTo(USER_ID.toString()); + } + + @SpringBootConfiguration + @EnableAutoConfiguration(exclude = { + FlywayAutoConfiguration.class, + JpaAccessControlConfiguration.class + }) + @EntityScan(basePackages = "io.github.huahill.vadmin.springjpa") + static class TestApplication { } +} diff --git a/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java index c6ee272..bf13a89 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java +++ b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java @@ -34,6 +34,7 @@ static void database(DynamicPropertyRegistry registry) { registry.add("spring.datasource.username", () -> "sa"); registry.add("spring.datasource.password", () -> ""); registry.add("spring.jpa.hibernate.ddl-auto", () -> "none"); + registry.add("spring.jpa.database-platform", () -> "org.hibernate.dialect.MySQLDialect"); registry.add("spring.flyway.enabled", () -> "false"); registry.add("spring.sql.init.mode", () -> "always"); registry.add("spring.sql.init.schema-locations", () -> "classpath:mysql-iam/schema.sql"); From a0eab683c83beb7ce0950c100f7dabc739b47f5c Mon Sep 17 00:00:00 2001 From: Huang Xiao Date: Tue, 17 Nov 2026 10:41:27 +0800 Subject: [PATCH 3/4] fix: create JPA identity beans only when a DataSource exists Contexts that exclude datasource auto-configuration have no EntityManager. The administration and lookup beans now wait for that DataSource. --- .../springjpa/JpaAccessControlConfiguration.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/JpaAccessControlConfiguration.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/JpaAccessControlConfiguration.java index 7d9d464..13e7374 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/JpaAccessControlConfiguration.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/JpaAccessControlConfiguration.java @@ -15,8 +15,12 @@ import jakarta.persistence.EntityManager; import org.springframework.boot.autoconfigure.AutoConfiguration; import org.springframework.boot.autoconfigure.AutoConfigureBefore; +import org.springframework.boot.autoconfigure.condition.ConditionalOnBean; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; + +import javax.sql.DataSource; + @AutoConfiguration @AutoConfigureBefore({ org.springframework.boot.flyway.autoconfigure.FlywayAutoConfiguration.class, @@ -25,6 +29,7 @@ @EnableConfigurationProperties(LocalIamProperties.class) public class JpaAccessControlConfiguration { @Bean + @ConditionalOnBean(DataSource.class) AdministrationStore administrationStore(EntityManager entityManager, LocalIamProperties properties) { return new JpaAdministrationStore(entityManager, properties.tables()); } @@ -45,16 +50,19 @@ AccessControlNamingCustomizer accessControlNamingCustomizer(LocalIamProperties p } @Bean + @ConditionalOnBean(DataSource.class) AccessControlRepository accessControlRepository(EntityManager entityManager, AccessControlTables tables) { return new JpaAccessControlRepository(entityManager, tables); } @Bean + @ConditionalOnBean(DataSource.class) LocalUserAccountLookup localUserAccountLookup(EntityManager entityManager, AccessControlTables tables) { return new JpaLocalUserAccountLookup(entityManager, tables); } @Bean + @ConditionalOnBean(DataSource.class) LocalUserSessionLookup localUserSessionLookup(EntityManager entityManager) { return new JpaLocalUserSessionLookup(entityManager); } @@ -65,11 +73,13 @@ AuditMetadataRedactor auditMetadataRedactor() { } @Bean + @ConditionalOnBean(DataSource.class) AuditSink auditSink(EntityManager entityManager, AuditMetadataRedactor redactor) { return new JpaAuditSink(entityManager, redactor); } @Bean + @ConditionalOnBean(DataSource.class) PermissionCatalogSynchronizer permissionCatalogSynchronizer(EntityManager entityManager) { return new PermissionCatalogSynchronizer(entityManager); } From bf6f83a0fd277b19b27c7781b55cc1565d51c757 Mon Sep 17 00:00:00 2001 From: Huang Xiao Date: Tue, 17 Nov 2026 11:07:27 +0800 Subject: [PATCH 4/4] fix: store MySQL identity UUIDs as VARCHAR(36) PostgreSQL keeps native uuid columns. MySQL and MariaDB have no UUID type, and CHAR(36) only pads under utf8mb4. JDBC string mode and the JPA mapping now both use VARCHAR(36). --- docs/en/user/configuration.md | 2 +- docs/en/user/security.md | 2 +- docs/zh-CN/user/configuration.md | 2 +- docs/zh-CN/user/security.md | 2 +- .../vadmin/springjdbc/UuidStorage.java | 2 +- ...itional-spring-configuration-metadata.json | 2 +- .../JdbcAdministrationStoreTest.java | 2 +- .../springjdbc/JdbcIamTestDatabase.java | 2 +- .../vadmin/springjpa/IdentityUuid.java | 14 +++ .../springjpa/IdentityUuidJavaType.java | 22 +++++ .../springjpa/access/JpaPermissionEntity.java | 5 +- .../springjpa/access/JpaRoleEntity.java | 5 +- .../access/JpaUserAccountEntity.java | 5 +- .../springjpa/audit/JpaAuditEntryEntity.java | 5 +- .../springjpa/IdentityUuidMappingTest.java | 85 +++++++++++++++++++ ...t.java => MySqlVarchar36IdentityTest.java} | 6 +- .../JpaAdministrationStoreTest.java | 1 - .../src/test/resources/mysql-iam/schema.sql | 18 ++-- 18 files changed, 150 insertions(+), 32 deletions(-) create mode 100644 vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/IdentityUuid.java create mode 100644 vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/IdentityUuidJavaType.java create mode 100644 vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/IdentityUuidMappingTest.java rename vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/{MySqlChar36IdentityTest.java => MySqlVarchar36IdentityTest.java} (95%) diff --git a/docs/en/user/configuration.md b/docs/en/user/configuration.md index 9ff95e1..1ca012f 100644 --- a/docs/en/user/configuration.md +++ b/docs/en/user/configuration.md @@ -29,7 +29,7 @@ vadmin: | `vadmin.local-iam.table-prefix` | `vadmin` | Prefix for the six local IAM tables. The default produces `vadmin_users` and its siblings. A blank value is rejected and does not fall back to unprefixed names. | | `vadmin.jdbc.enabled` | `false` | Opt into complete JDBC IAM persistence and initial admin bootstrap on an existing schema. Replaces host identity/audit storage beans. | | `vadmin.jdbc.table-prefix` | `vadmin` | Prefix for all six JDBC IAM tables; validated as a SQL identifier. | -| `vadmin.jdbc.uuid-storage` | `string` | `string` for MySQL CHAR(36); `native` for PostgreSQL UUID and JSONB metadata. | +| `vadmin.jdbc.uuid-storage` | `string` | `string` for MySQL VARCHAR(36); `native` for PostgreSQL UUID and JSONB metadata. | | `vadmin.bootstrap.password` | Unset | First admin password for JDBC IAM; falls back to APP_BOOTSTRAP_PASSWORD, or `change-me` only in dev. Existing passwords are never reset. | | `vadmin.oidc.registration-id` | `oidc` | The Spring Security client registration used by the optional OIDC login. The registration itself is standard `spring.security.oauth2.client.*` configuration. | diff --git a/docs/en/user/security.md b/docs/en/user/security.md index 310cf70..c967451 100644 --- a/docs/en/user/security.md +++ b/docs/en/user/security.md @@ -61,7 +61,7 @@ Keep `vadmin.system-admin.enabled=true` to use the shared pages and enable the VAdmin Spring Security integration in the host. All six tables share `vadmin.jdbc.table-prefix` (default `vadmin`). -`vadmin.jdbc.uuid-storage=string` uses MySQL `CHAR(36)` identifiers; +`vadmin.jdbc.uuid-storage=string` uses MySQL `VARCHAR(36)` identifiers; `native` uses PostgreSQL UUIDs and JSONB audit metadata. Existing contract beans take precedence over the JDBC defaults. Exclude the starter's `vadmin-spring-jpa` and PostgreSQL driver when replacing the default persistence setup. diff --git a/docs/zh-CN/user/configuration.md b/docs/zh-CN/user/configuration.md index a461098..365d44c 100644 --- a/docs/zh-CN/user/configuration.md +++ b/docs/zh-CN/user/configuration.md @@ -28,7 +28,7 @@ vadmin: | `vadmin.local-iam.table-prefix` | `vadmin` | 本地 IAM 六张表的前缀。默认写成 `vadmin_users` 这一组;空字符串会被拒绝,不会退回没有前缀的表名。 | | `vadmin.jdbc.enabled` | `false` | 在已有表结构上启用完整 JDBC IAM 存储和初始管理员引导,宿主不再提供身份或审计存储 Bean。 | | `vadmin.jdbc.table-prefix` | `vadmin` | JDBC IAM 六张表统一前缀,按 SQL 标识符校验。 | -| `vadmin.jdbc.uuid-storage` | `string` | MySQL CHAR(36) 使用 `string`;PostgreSQL UUID 和 JSONB 使用 `native`。 | +| `vadmin.jdbc.uuid-storage` | `string` | MySQL VARCHAR(36) 使用 `string`;PostgreSQL UUID 和 JSONB 使用 `native`。 | | `vadmin.bootstrap.password` | 未配置 | JDBC IAM 首个管理员密码,回退到 APP_BOOTSTRAP_PASSWORD;仅 dev 使用默认 change-me,已有密码不会重置。 | | `vadmin.oidc.registration-id` | `oidc` | 可选 OIDC 登录使用的 Spring Security 客户端注册 ID。注册本身是标准的 `spring.security.oauth2.client.*` 配置。 | diff --git a/docs/zh-CN/user/security.md b/docs/zh-CN/user/security.md index 18ed812..b96c65d 100644 --- a/docs/zh-CN/user/security.md +++ b/docs/zh-CN/user/security.md @@ -47,7 +47,7 @@ VAdmin 在两层检查权限: 保留 `vadmin.system-admin.enabled=true` 以启用共享页面,并接入 VAdmin Spring Security。 六张表统一使用 `vadmin.jdbc.table-prefix`(默认 `vadmin`)。 -`vadmin.jdbc.uuid-storage=string` 对应 MySQL `CHAR(36)`;`native` 对应 PostgreSQL UUID +`vadmin.jdbc.uuid-storage=string` 对应 MySQL `VARCHAR(36)`;`native` 对应 PostgreSQL UUID 和 JSONB 审计字段。已有契约 Bean 优先于 JDBC 默认实现。替换默认持久化时,排除 starter 的 `vadmin-spring-jpa` 和 PostgreSQL 驱动。管理写操作、审计和初始化必须共享 DataSource 及事务管理器;宿主仍负责 Flyway 表结构迁移,本模块不会创建表。 diff --git a/vadmin-spring/vadmin-spring-jdbc/src/main/java/io/github/huahill/vadmin/springjdbc/UuidStorage.java b/vadmin-spring/vadmin-spring-jdbc/src/main/java/io/github/huahill/vadmin/springjdbc/UuidStorage.java index c6f7a17..6e60d00 100644 --- a/vadmin-spring/vadmin-spring-jdbc/src/main/java/io/github/huahill/vadmin/springjdbc/UuidStorage.java +++ b/vadmin-spring/vadmin-spring-jdbc/src/main/java/io/github/huahill/vadmin/springjdbc/UuidStorage.java @@ -2,7 +2,7 @@ import java.util.UUID; -/** Bind UUIDs as native PostgreSQL UUIDs or MySQL CHAR(36) strings. */ +/** Bind UUIDs as native PostgreSQL UUIDs or MySQL VARCHAR(36) strings. */ public enum UuidStorage { NATIVE, STRING; diff --git a/vadmin-spring/vadmin-spring-jdbc/src/main/resources/META-INF/additional-spring-configuration-metadata.json b/vadmin-spring/vadmin-spring-jdbc/src/main/resources/META-INF/additional-spring-configuration-metadata.json index ff1e376..aa59778 100644 --- a/vadmin-spring/vadmin-spring-jdbc/src/main/resources/META-INF/additional-spring-configuration-metadata.json +++ b/vadmin-spring/vadmin-spring-jdbc/src/main/resources/META-INF/additional-spring-configuration-metadata.json @@ -5,7 +5,7 @@ {"name": "vadmin.jdbc.table-prefix", "type": "java.lang.String", "defaultValue": "vadmin", "description": "SQL identifier prefix shared by all six JDBC IAM tables."}, {"name": "vadmin.jdbc.uuid-storage", "type": "io.github.huahill.vadmin.springjdbc.UuidStorage", "defaultValue": "STRING", - "description": "STRING binds MySQL CHAR(36) identifiers; NATIVE binds PostgreSQL UUIDs and JSONB audit metadata."}, + "description": "STRING binds MySQL VARCHAR(36) identifiers; NATIVE binds PostgreSQL UUIDs and JSONB audit metadata."}, {"name": "vadmin.bootstrap.password", "type": "java.lang.String", "description": "Initial admin password on an empty JDBC IAM schema. Falls back to APP_BOOTSTRAP_PASSWORD; never resets an existing account."} ] diff --git a/vadmin-spring/vadmin-spring-jdbc/src/test/java/io/github/huahill/vadmin/springjdbc/JdbcAdministrationStoreTest.java b/vadmin-spring/vadmin-spring-jdbc/src/test/java/io/github/huahill/vadmin/springjdbc/JdbcAdministrationStoreTest.java index 0379cb9..09a5aad 100644 --- a/vadmin-spring/vadmin-spring-jdbc/src/test/java/io/github/huahill/vadmin/springjdbc/JdbcAdministrationStoreTest.java +++ b/vadmin-spring/vadmin-spring-jdbc/src/test/java/io/github/huahill/vadmin/springjdbc/JdbcAdministrationStoreTest.java @@ -96,7 +96,7 @@ private static JdbcTemplate database(UuidStorage format) { dataSource.setURL("jdbc:h2:mem:" + UUID.randomUUID() + ";MODE=" + (format == UuidStorage.STRING ? "MySQL" : "PostgreSQL") + ";DB_CLOSE_DELAY=-1"); var jdbc = new JdbcTemplate(dataSource); - String id = format == UuidStorage.STRING ? "CHAR(36)" : "UUID"; + String id = format == UuidStorage.STRING ? "VARCHAR(36)" : "UUID"; jdbc.execute("CREATE TABLE ci_users (id " + id + " PRIMARY KEY, username VARCHAR(120) UNIQUE, " + "password_hash VARCHAR(255), enabled BOOLEAN, auth_version BIGINT)"); jdbc.execute("CREATE TABLE ci_roles (id " + id + " PRIMARY KEY, code VARCHAR(120) UNIQUE)"); diff --git a/vadmin-spring/vadmin-spring-jdbc/src/test/java/io/github/huahill/vadmin/springjdbc/JdbcIamTestDatabase.java b/vadmin-spring/vadmin-spring-jdbc/src/test/java/io/github/huahill/vadmin/springjdbc/JdbcIamTestDatabase.java index 1ea369d..41d7f51 100644 --- a/vadmin-spring/vadmin-spring-jdbc/src/test/java/io/github/huahill/vadmin/springjdbc/JdbcIamTestDatabase.java +++ b/vadmin-spring/vadmin-spring-jdbc/src/test/java/io/github/huahill/vadmin/springjdbc/JdbcIamTestDatabase.java @@ -11,7 +11,7 @@ static JdbcTemplate create(UuidStorage format, String prefix) { + (format == UuidStorage.STRING ? "MySQL" : "PostgreSQL") + ";DB_CLOSE_DELAY=-1"); var jdbc = new JdbcTemplate(dataSource); var tables = new JdbcIamTables(prefix); - String id = format == UuidStorage.STRING ? "CHAR(36)" : "UUID"; + String id = format == UuidStorage.STRING ? "VARCHAR(36)" : "UUID"; jdbc.execute("CREATE TABLE " + tables.users() + " (id " + id + " PRIMARY KEY, username VARCHAR(120) UNIQUE, " + "password_hash VARCHAR(255), enabled BOOLEAN, auth_version BIGINT)"); jdbc.execute("CREATE TABLE " + tables.roles() + " (id " + id + " PRIMARY KEY, code VARCHAR(120) UNIQUE)"); diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/IdentityUuid.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/IdentityUuid.java new file mode 100644 index 0000000..2854420 --- /dev/null +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/IdentityUuid.java @@ -0,0 +1,14 @@ +package io.github.huahill.vadmin.springjpa; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import org.hibernate.annotations.JavaType; + +/// Marks a VAdmin identity UUID. The JDBC type depends on the dialect. +@Target({ElementType.FIELD, ElementType.METHOD}) +@Retention(RetentionPolicy.RUNTIME) +@JavaType(IdentityUuidJavaType.class) +public @interface IdentityUuid { +} diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/IdentityUuidJavaType.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/IdentityUuidJavaType.java new file mode 100644 index 0000000..a03fb8b --- /dev/null +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/IdentityUuidJavaType.java @@ -0,0 +1,22 @@ +package io.github.huahill.vadmin.springjpa; + +import org.hibernate.dialect.MySQLDialect; +import org.hibernate.type.SqlTypes; +import org.hibernate.type.descriptor.java.UUIDJavaType; +import org.hibernate.type.descriptor.jdbc.JdbcType; +import org.hibernate.type.descriptor.jdbc.JdbcTypeIndicators; + +/// Identity UUID storage for VAdmin tables. +/// +/// MySQL and MariaDB have no native UUID column in the host schema, so those +/// dialects bind the same Java UUID as VARCHAR(36). PostgreSQL keeps the native +/// uuid column created by the Flyway migration. +public final class IdentityUuidJavaType extends UUIDJavaType { + @Override + public JdbcType getRecommendedJdbcType(JdbcTypeIndicators indicators) { + if (indicators.getDialect() instanceof MySQLDialect) { + return indicators.getJdbcType(SqlTypes.VARCHAR); + } + return super.getRecommendedJdbcType(indicators); + } +} diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaPermissionEntity.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaPermissionEntity.java index 4ab3c6b..ebe1248 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaPermissionEntity.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaPermissionEntity.java @@ -1,18 +1,17 @@ package io.github.huahill.vadmin.springjpa.access; +import io.github.huahill.vadmin.springjpa.IdentityUuid; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.Id; import jakarta.persistence.Table; import java.util.UUID; -import org.hibernate.annotations.JdbcTypeCode; -import org.hibernate.type.SqlTypes; @Entity @Table(name = "vadmin_permissions") public class JpaPermissionEntity { @Id - @JdbcTypeCode(SqlTypes.CHAR) + @IdentityUuid @Column(length = 36) private UUID id; diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaRoleEntity.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaRoleEntity.java index d5de103..1f58b6b 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaRoleEntity.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaRoleEntity.java @@ -1,18 +1,17 @@ package io.github.huahill.vadmin.springjpa.access; +import io.github.huahill.vadmin.springjpa.IdentityUuid; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.Id; import jakarta.persistence.Table; import java.util.UUID; -import org.hibernate.annotations.JdbcTypeCode; -import org.hibernate.type.SqlTypes; @Entity @Table(name = "vadmin_roles") public class JpaRoleEntity { @Id - @JdbcTypeCode(SqlTypes.CHAR) + @IdentityUuid @Column(length = 36) private UUID id; diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaUserAccountEntity.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaUserAccountEntity.java index 6b574ff..5e9b6b2 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaUserAccountEntity.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/access/JpaUserAccountEntity.java @@ -1,18 +1,17 @@ package io.github.huahill.vadmin.springjpa.access; +import io.github.huahill.vadmin.springjpa.IdentityUuid; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.Id; import jakarta.persistence.Table; import java.util.UUID; -import org.hibernate.annotations.JdbcTypeCode; -import org.hibernate.type.SqlTypes; @Entity @Table(name = "vadmin_users") public class JpaUserAccountEntity { @Id - @JdbcTypeCode(SqlTypes.CHAR) + @IdentityUuid @Column(length = 36) private UUID id; diff --git a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/audit/JpaAuditEntryEntity.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/audit/JpaAuditEntryEntity.java index 13d1691..ebf6395 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/audit/JpaAuditEntryEntity.java +++ b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/audit/JpaAuditEntryEntity.java @@ -1,6 +1,7 @@ package io.github.huahill.vadmin.springjpa.audit; import io.github.huahill.vadmin.contracts.audit.AuditOutcome; +import io.github.huahill.vadmin.springjpa.IdentityUuid; import jakarta.persistence.Column; import jakarta.persistence.Entity; import jakarta.persistence.EnumType; @@ -17,11 +18,11 @@ @Table(name = "vadmin_audit_entries") public class JpaAuditEntryEntity { @Id - @JdbcTypeCode(SqlTypes.CHAR) + @IdentityUuid @Column(length = 36) private UUID id; - @JdbcTypeCode(SqlTypes.CHAR) + @IdentityUuid @Column(name = "actor_user_id", nullable = false, length = 36) private UUID actorUserId; diff --git a/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/IdentityUuidMappingTest.java b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/IdentityUuidMappingTest.java new file mode 100644 index 0000000..fc4ba94 --- /dev/null +++ b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/IdentityUuidMappingTest.java @@ -0,0 +1,85 @@ +package io.github.huahill.vadmin.springjpa; + +import static org.assertj.core.api.Assertions.assertThat; + +import io.github.huahill.vadmin.springjpa.access.JpaPermissionEntity; +import io.github.huahill.vadmin.springjpa.access.JpaRoleEntity; +import io.github.huahill.vadmin.springjpa.access.JpaUserAccountEntity; +import io.github.huahill.vadmin.springjpa.audit.JpaAuditEntryEntity; +import java.sql.Types; +import java.util.List; +import java.util.function.Consumer; +import org.hibernate.boot.Metadata; +import org.hibernate.boot.MetadataSources; +import org.hibernate.boot.registry.StandardServiceRegistry; +import org.hibernate.boot.registry.StandardServiceRegistryBuilder; +import org.hibernate.dialect.Dialect; +import org.hibernate.dialect.MariaDBDialect; +import org.hibernate.dialect.MySQLDialect; +import org.hibernate.dialect.PostgreSQLDialect; +import org.hibernate.mapping.Column; +import org.hibernate.mapping.PersistentClass; +import org.junit.jupiter.api.Test; + +class IdentityUuidMappingTest { + @Test + void storesIdentityUuidsAsVarchar36OnMysqlAndNativeUuidOnPostgres() { + assertCharacterUuid(MySQLDialect.class); + assertCharacterUuid(MariaDBDialect.class); + assertNativeUuid(PostgreSQLDialect.class); + } + + private static void assertCharacterUuid(Class dialect) { + withMetadata(dialect, metadata -> { + for (Column column : identityColumns(metadata)) { + assertThat(column.getSqlType(metadata)).isEqualTo("varchar(36)"); + assertThat(column.getSqlTypeCode(metadata)).isEqualTo(Types.VARCHAR); + assertThat(column.getLength()).isEqualTo(36L); + } + }); + } + + private static void assertNativeUuid(Class dialect) { + withMetadata(dialect, metadata -> { + for (Column column : identityColumns(metadata)) { + assertThat(column.getSqlType(metadata)).isEqualTo("uuid"); + assertThat(column.getSqlTypeCode(metadata)).isNotEqualTo(Types.VARCHAR); + } + }); + } + + private static List identityColumns(Metadata metadata) { + return List.of( + column(metadata, JpaUserAccountEntity.class, null), + column(metadata, JpaRoleEntity.class, null), + column(metadata, JpaPermissionEntity.class, null), + column(metadata, JpaAuditEntryEntity.class, null), + column(metadata, JpaAuditEntryEntity.class, "actorUserId")); + } + + private static void withMetadata(Class dialect, Consumer assertion) { + StandardServiceRegistry registry = new StandardServiceRegistryBuilder() + .applySetting("hibernate.dialect", dialect.getName()) + .applySetting("hibernate.boot.allow_jdbc_metadata_access", "false") + .build(); + try { + Metadata metadata = new MetadataSources(registry) + .addAnnotatedClass(JpaUserAccountEntity.class) + .addAnnotatedClass(JpaRoleEntity.class) + .addAnnotatedClass(JpaPermissionEntity.class) + .addAnnotatedClass(JpaAuditEntryEntity.class) + .getMetadataBuilder() + .build(); + assertion.accept(metadata); + } finally { + StandardServiceRegistryBuilder.destroy(registry); + } + } + + private static Column column(Metadata metadata, Class entity, String property) { + PersistentClass binding = metadata.getEntityBinding(entity.getName()); + return property == null + ? (Column) binding.getIdentifier().getColumns().get(0) + : (Column) binding.getProperty(property).getValue().getColumns().get(0); + } +} diff --git a/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlChar36IdentityTest.java b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlVarchar36IdentityTest.java similarity index 95% rename from vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlChar36IdentityTest.java rename to vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlVarchar36IdentityTest.java index d4d1aec..65e8dea 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlChar36IdentityTest.java +++ b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlVarchar36IdentityTest.java @@ -25,8 +25,8 @@ import org.springframework.test.context.DynamicPropertySource; import org.springframework.transaction.annotation.Transactional; -@SpringBootTest(classes = MySqlChar36IdentityTest.TestApplication.class) -class MySqlChar36IdentityTest { +@SpringBootTest(classes = MySqlVarchar36IdentityTest.TestApplication.class) +class MySqlVarchar36IdentityTest { private static final UUID USER_ID = UUID.fromString("33333333-3333-3333-3333-333333333333"); @Autowired @@ -35,7 +35,7 @@ class MySqlChar36IdentityTest { @DynamicPropertySource static void database(DynamicPropertyRegistry registry) { registry.add("spring.datasource.url", () -> - "jdbc:h2:mem:vadmin-char36;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE"); + "jdbc:h2:mem:vadmin-varchar36;MODE=MySQL;DB_CLOSE_DELAY=-1;DATABASE_TO_LOWER=TRUE"); registry.add("spring.datasource.username", () -> "sa"); registry.add("spring.datasource.password", () -> ""); registry.add("spring.jpa.hibernate.ddl-auto", () -> "none"); diff --git a/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java index bf13a89..eda250f 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java +++ b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/administration/JpaAdministrationStoreTest.java @@ -38,7 +38,6 @@ static void database(DynamicPropertyRegistry registry) { registry.add("spring.flyway.enabled", () -> "false"); registry.add("spring.sql.init.mode", () -> "always"); registry.add("spring.sql.init.schema-locations", () -> "classpath:mysql-iam/schema.sql"); - registry.add("spring.jpa.properties.hibernate.type.preferred_uuid_jdbc_type", () -> "CHAR"); } @Test diff --git a/vadmin-spring/vadmin-spring-jpa/src/test/resources/mysql-iam/schema.sql b/vadmin-spring/vadmin-spring-jpa/src/test/resources/mysql-iam/schema.sql index e8d4acc..213307e 100644 --- a/vadmin-spring/vadmin-spring-jpa/src/test/resources/mysql-iam/schema.sql +++ b/vadmin-spring/vadmin-spring-jpa/src/test/resources/mysql-iam/schema.sql @@ -1,32 +1,32 @@ CREATE TABLE vadmin_users ( - id CHAR(36) NOT NULL PRIMARY KEY, + id VARCHAR(36) NOT NULL PRIMARY KEY, username VARCHAR(120) NOT NULL UNIQUE, password_hash VARCHAR(255) NOT NULL, enabled BOOLEAN NOT NULL, auth_version BIGINT NOT NULL ); CREATE TABLE vadmin_roles ( - id CHAR(36) NOT NULL PRIMARY KEY, + id VARCHAR(36) NOT NULL PRIMARY KEY, code VARCHAR(120) NOT NULL UNIQUE ); CREATE TABLE vadmin_permissions ( - id CHAR(36) NOT NULL PRIMARY KEY, + id VARCHAR(36) NOT NULL PRIMARY KEY, code VARCHAR(120) NOT NULL UNIQUE, system_managed BOOLEAN NOT NULL ); CREATE TABLE vadmin_user_roles ( - user_id CHAR(36) NOT NULL, - role_id CHAR(36) NOT NULL, + user_id VARCHAR(36) NOT NULL, + role_id VARCHAR(36) NOT NULL, PRIMARY KEY (user_id, role_id) ); CREATE TABLE vadmin_role_permissions ( - role_id CHAR(36) NOT NULL, - permission_id CHAR(36) NOT NULL, + role_id VARCHAR(36) NOT NULL, + permission_id VARCHAR(36) NOT NULL, PRIMARY KEY (role_id, permission_id) ); CREATE TABLE vadmin_audit_entries ( - id CHAR(36) NOT NULL PRIMARY KEY, - actor_user_id CHAR(36) NOT NULL, + id VARCHAR(36) NOT NULL PRIMARY KEY, + actor_user_id VARCHAR(36) NOT NULL, action_code VARCHAR(120) NOT NULL, target_type VARCHAR(120) NOT NULL, target_id VARCHAR(255) NOT NULL,