I played around with the code a bit more and I think I might be a bit closer in understanding my confusion.

So like mentioned I have a longish background with Rails so I tend to compare functionality to it quite often (which might or might not make sense). It seems that there is a difference between .all method in rails and .all() method in Exposed. In rails transaction is not opened nor is it required when .all is called. In Exposed (and to my recollection other JVM ORM libraries like Hibernate actually hibernate does not require transaction in db reads) you are required to open a transaction if you want to read from the db. I wonder why there is a difference like this? I suppose the difference is there because in rails .save is wrapped automatically in a transaction and committed also but in Exposed .new {} does not do that, right? For this reason we need to flush entitites in db before any queries are made.

@harjis , I agree that validation on DSL level will be a nice feature.

About .all() function: it doesn't require transaction until you start iterating over its result.

About new{} and flushing: it works the same way as a changing of an existing entity (see here). Moreover, if you create an entity with new{} and then modify it before any other queries, changes will be accumulated and only a single insert will be executed.

We are going to release updated documentation later this year where this will be covered.

My point about .all() method is that in those frameworks I have used repository or the activerecord class can be considered as public API for the table.

Hibernate:

class PostController(private val postRepository) {
    fun index() = postRepository.findAll()
}

Rails:

class PostController < ApplicationController
    def index
       @posts = Post.all
    end
end

Even though exposed DAO API looks very similar to Rails ActiveRercord one you can not use it the same way:

data class PostView
class PostController {
    fun index() = Post.all().map { PostView() } // Not OK because transaction has not been opened
}

In order to make this to work I see 2 options. Either open a transaction in controller:

class PostController {
    fun index() = transaction { Post.all().map { PostView() } }
}

Or create a repository class which opens the transaction:

data class PostView
class PostRepository {
    fun all() = transaction { Post.all() }
}
class PostController(private val postRepository) {
    fun all() = postRepository.all().map { PostView() }
}

Argument against opening transaction in controller is that in MVC controller should not know that much about the underlying persistence layer as that responsibility should be on the model.

For me the repository one is a bit confusing as the exposed DAO API is so close Rails ActiveRercord one that I thought that should be the public API for the table but actually you can not use it the same way.

My comments regarding .new {} and .all() were related to this. As this is old version of the code I think we can disregard the comments for now.

Any update on this? Also supporting lifecycle hooks like "before save" etc. would be a way to hook in an existing validation library but those hooks don't exist either