[reactive/hibernate/panache/kotlin/postgres] While persisting data into SQL, all fields become null

[polymorph233]

By coincidence, during hot reload it was possible to persist data within the SQL even if nullish fields violate the non-null contract in database side.

In the point of view of database, I got something similar to:

id	kind	name	res_type	access_id	level	admin_id	parent_id
12	null	null	null	149	null	225	null

Here id are referenced to entries in other tables and it seems work perfectly.
But all fields belonging to the entity are null.

Another symptom is that, I have coded the logic to first check if an object with the same name is already in the database before inserting it. Since at each query a new object is created, with the same name, this shows in evidence that the fields are lost during persistence.

After a stopping and restart of quarkusdev, now the database just refuse to persist these entities full of nulls, which is quite expected by me. But I would like to know why these data got lost during persistence.

I am using reactive components of Quarkus, but this should not be relevant.

I am wondering if this could be happening because of the inheritance classes used for entity design as I used two abstract classes for the base of several specialized classes. Another guess is that this may come with how properties and fields are mapped from Kotlin to Java side.

Here is my query level code:

@ApplicationScoped
open class ModuleHandler {

  @Inject
  lateinit var logger: Logger
  @Inject
  lateinit var vertx: Vertx

  open suspend fun createGroup(name: String) =
    VertxContextSupport.subscribeAndAwait {
      Panache.withTransaction {
        GroupNode.find("name", name)
          .firstResult()
          .onItem()
          .ifNotNull()
          .failWith(Unchecked
            .supplier {
              throw IllegalStateException("A group with given name has already exist")
            })
          .onItem()
          .ifNull()
          .switchTo {
            // Create Access Grant and dedicated Admin Node
            val accessGrant = AccessGrantNode()
            val adminAccessGrant = AccessGrantNode()
            val adminNode = AdminNode()
            adminNode.name = "group:$name:admin"
            val newGroup = GroupNode()
            newGroup.name = name

            accessGrant.attachedGroup = newGroup
            adminNode.attachedGroup = newGroup

            newGroup.accessGrant = accessGrant
            newGroup.adminNode = adminNode

            adminNode.accessGrant = adminAccessGrant
            adminAccessGrant.attachedGroup = adminNode

            accessGrant.persist<AccessGrantNode>()
              .chain { _ ->
                adminAccessGrant.persist<AccessGrantNode>()
              }
              .chain { _ ->
                adminNode.persist<AdminNode>()
              }
              .chain {  _ ->
                newGroup.persist<GroupNode>()
              }
          }
          .onFailure()
          .invoke(Unchecked.consumer { _ ->
            throw IllegalStateException("Error occurred while creating new group")
          })
      }
    }
  ....
}

The abstract classes are like this:

@Entity(name = "AbstractResource")
@Table(name = "abstract_resources")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
@DiscriminatorColumn(name = "RES_TYPE")
abstract class AbstractResource(
) : PanacheEntity() {

  @Column(nullable = false)
  open lateinit var name: String

  @Column(name = "RES_TYPE")
  open lateinit var resourceType: String

  @Column(name = "RES_KIND")
  open lateinit var kind: ResourceKind

  @OneToOne
  @JoinColumn(name="access_id", unique=true, nullable=false, updatable=false)
  lateinit var accessGrant: AccessGrantNode

  companion object : PanacheCompanion<AbstractResource> { }
}

And the concrete class like:

@Entity(name = "GroupNodeGroup")
@Table(name = "group_nodes")
class GroupNode(
) : AbstractGroup() {

  override var kind = AbstractResource.ResourceKind.Group

  override var level = SubGroupLevel.Group

  @OneToMany(cascade = [(CascadeType.ALL)], fetch = FetchType.LAZY, mappedBy = "parentNode", orphanRemoval = true)
  private var _subAreas = mutableSetOf<AreaNode>()
  val subAreas get() = _subAreas.toList()

  @ManyToOne
  open var parentNode: RootNode? = null

  companion object : PanacheCompanion<GroupNode> { }
}