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/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/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/JpaAccessControlConfiguration.java b/vadmin-spring/vadmin-spring-jpa/src/main/java/io/github/huahill/vadmin/springjpa/JpaAccessControlConfiguration.java index b6b1a48..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 @@ -6,19 +6,20 @@ 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.autoconfigure.condition.ConditionalOnBean; import org.springframework.boot.context.properties.EnableConfigurationProperties; import org.springframework.context.annotation.Bean; -import org.springframework.jdbc.core.JdbcTemplate; + +import javax.sql.DataSource; @AutoConfiguration @AutoConfigureBefore({ @@ -28,8 +29,9 @@ @EnableConfigurationProperties(LocalIamProperties.class) public class JpaAccessControlConfiguration { @Bean - AdministrationStore administrationStore(JdbcTemplate jdbcTemplate, LocalIamProperties properties) { - return new JdbcAdministrationStore(jdbcTemplate, properties.getTablePrefix(), UuidStorage.NATIVE); + @ConditionalOnBean(DataSource.class) + AdministrationStore administrationStore(EntityManager entityManager, LocalIamProperties properties) { + return new JpaAdministrationStore(entityManager, properties.tables()); } @Bean @@ -48,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); } @@ -68,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); } 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..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,5 +1,6 @@ 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; @@ -10,6 +11,8 @@ @Table(name = "vadmin_permissions") public class JpaPermissionEntity { @Id + @IdentityUuid + @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..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,5 +1,6 @@ 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; @@ -10,6 +11,8 @@ @Table(name = "vadmin_roles") public class JpaRoleEntity { @Id + @IdentityUuid + @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..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,5 +1,6 @@ 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; @@ -10,6 +11,8 @@ @Table(name = "vadmin_users") public class JpaUserAccountEntity { @Id + @IdentityUuid + @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/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/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..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,9 +18,12 @@ @Table(name = "vadmin_audit_entries") public class JpaAuditEntryEntity { @Id + @IdentityUuid + @Column(length = 36) private UUID id; - @Column(name = "actor_user_id", nullable = false) + @IdentityUuid + @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/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/MySqlVarchar36IdentityTest.java b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlVarchar36IdentityTest.java new file mode 100644 index 0000000..65e8dea --- /dev/null +++ b/vadmin-spring/vadmin-spring-jpa/src/test/java/io/github/huahill/vadmin/springjpa/MySqlVarchar36IdentityTest.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 = MySqlVarchar36IdentityTest.TestApplication.class) +class MySqlVarchar36IdentityTest { + 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-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"); + 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 new file mode 100644 index 0000000..eda250f --- /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.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_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..213307e --- /dev/null +++ b/vadmin-spring/vadmin-spring-jpa/src/test/resources/mysql-iam/schema.sql @@ -0,0 +1,37 @@ +CREATE TABLE vadmin_users ( + 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 VARCHAR(36) NOT NULL PRIMARY KEY, + code VARCHAR(120) NOT NULL UNIQUE +); +CREATE TABLE vadmin_permissions ( + 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 VARCHAR(36) NOT NULL, + role_id VARCHAR(36) NOT NULL, + PRIMARY KEY (user_id, role_id) +); +CREATE TABLE vadmin_role_permissions ( + role_id VARCHAR(36) NOT NULL, + permission_id VARCHAR(36) NOT NULL, + PRIMARY KEY (role_id, permission_id) +); +CREATE TABLE vadmin_audit_entries ( + 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, + outcome VARCHAR(16) NOT NULL, + occurred_at TIMESTAMP NOT NULL, + correlation_id VARCHAR(64), + metadata VARCHAR(4000) +);