feat(exposed): add layer extensions & DbManager

kraftx/exposed/src/main/kotlin/sh/illumi/kraft/x/exposed/DbManager.kt

@@ -3,17 +3,63 @@ package sh.illumi.kraft.x.exposed
 import com.zaxxer.hikari.HikariConfig
 import com.zaxxer.hikari.HikariDataSource
 import org.jetbrains.exposed.sql.Database
+import sh.illumi.kraft.layer.RootLayer
+import sh.illumi.kraft.x.exposed.dsl.ExposedConfigurationDsl
 
 sealed interface DbManager {
     val db: Database
     val isPooled: Boolean
+    val layer: RootLayer
 
-    class Hikari() : DbManager {
-        private val dataSource = HikariDataSource(HikariConfig())
+    class Hikari(
+        override val layer: RootLayer,
+        configure: ExposedConfigurationDsl.Hikari.() -> Unit
+    ) : DbManager {
+        private val dataSource: HikariDataSource
+
+        init {
+            val dsl = ExposedConfigurationDsl.Hikari().apply(configure)
+            dsl.check()
+
+            dataSource = HikariDataSource(HikariConfig().apply {
+                jdbcUrl = dsl.jdbcUrl
+                driverClassName = dsl.driverClassName
+                username = dsl.username
+                password = dsl.password
+                maximumPoolSize = dsl.hikari.maximumPoolSize
+                isReadOnly = dsl.hikari.isReadOnly
+                transactionIsolation = dsl.hikari.transactionIsolationLevel
+            })
+        }
 
         override val isPooled = true
         override val db by lazy {
             Database.connect(dataSource)
         }
     }
+
+    class Single(
+        override val layer: RootLayer,
+        configure: ExposedConfigurationDsl.() -> Unit
+    ) : DbManager {
+        private val jdbcUrl: String
+        private val driverClassName: String
+        private val username: String
+        private val password: String
+
+        init {
+            val dsl = ExposedConfigurationDsl().apply(configure)
+            dsl.check()
+
+            jdbcUrl = dsl.jdbcUrl
+            driverClassName = dsl.driverClassName
+            username = dsl.username
+            password = dsl.password
+        }
+
+        override val isPooled = false
+        override val db by lazy {
+            Database.connect(jdbcUrl, driverClassName, username, password)
+        }
+    }
 }

kraftx/exposed/src/main/kotlin/sh/illumi/kraft/x/exposed/dsl/config.kt

@@ -0,0 +1,38 @@
+package sh.illumi.kraft.x.exposed.dsl
+
+open class ExposedConfigurationDsl {
+    var jdbcUrl: String = ""
+    var driverClassName: String = ""
+    var username: String = ""
+    var password: String = ""
+
+    open fun check() {
+        require(jdbcUrl.isNotBlank()) { "jdbcUrl must be set" }
+        require(driverClassName.isNotBlank()) { "driverClassName must be set" }
+        require(username.isNotBlank()) { "username must be set" }
+        require(password.isNotBlank()) { "password must be set" }
+    }
+
+    class Hikari : ExposedConfigurationDsl() {
+        lateinit var hikari: ExposedHikariConfigurationDsl
+
+        fun hikari(block: ExposedHikariConfigurationDsl.() -> Unit) {
+            hikari = ExposedHikariConfigurationDsl().apply(block)
+        }
+
+        override fun check() {
+            super.check()
+            hikari.check()
+        }
+    }
+}
+
+class ExposedHikariConfigurationDsl {
+    var maximumPoolSize = 10
+    var isReadOnly = false
+    var transactionIsolationLevel: String? = null
+
+    fun check() {
+        require(maximumPoolSize > 0) { "maximumPoolSize must be greater than 0" }
+    }
+}

kraftx/exposed/src/main/kotlin/sh/illumi/kraft/x/exposed/extensions/layer.kt

@@ -0,0 +1,19 @@
+package sh.illumi.kraft.x.exposed.extensions
+
+import sh.illumi.kraft.layer.RootLayer
+import sh.illumi.kraft.x.exposed.DbManager
+import sh.illumi.kraft.x.exposed.dsl.ExposedConfigurationDsl
+import sh.illumi.kraft.x.exposed.layer.LayerWithExposed
+
+fun <TLayer> TLayer.createExposedHikari(configure: ExposedConfigurationDsl.Hikari.() -> Unit)
+where
+    TLayer : RootLayer,
+    TLayer : LayerWithExposed
+= DbManager.Hikari(this, configure)
+
+
+fun <TLayer> TLayer.createExposedSingle(configure: ExposedConfigurationDsl.() -> Unit)
+where
+    TLayer : RootLayer,
+    TLayer : LayerWithExposed
+= DbManager.Single(this, configure)

kraftx/exposed/src/main/kotlin/sh/illumi/kraft/x/exposed/layer/LayerWithExposed.kt

@@ -0,0 +1,7 @@
+package sh.illumi.kraft.x.exposed.layer
+
+import sh.illumi.kraft.x.exposed.DbManager
+
+interface LayerWithExposed {
+    val db: DbManager
+}