fix: actionable error message in ExposedConnectionProvider (#32)

## Summary

- `ExposedConnectionProvider.withConnection` previously delegated to
`TransactionManager.current()`, which throws a generic Exposed
`IllegalStateException("No transaction in context")` when called outside
a transaction. The message gives no hint about okapi.
- Wrap with `TransactionManager.currentOrNull()` and throw a clearer
`IllegalStateException` naming the okapi method and the missing
`transaction { }` block. Brings `ExposedConnectionProvider` to parity
with how `JdbcConnectionProvider` (test helper) reports its own
missing-scope precondition.
- Added two unit tests: one for the negative path (asserts the message
contains both okapi method name and the `Exposed transaction { } block`
hint), one for the positive path (asserts the active Exposed connection
is supplied to the block).

## Motivation

Follow-up to PR #26 review feedback (`code-reviewer` Suggestion #6 on
the second review round). Three-line code change but it materially
improves diagnostics for users who hit this misconfiguration in Ktor +
Exposed setups.

## Test plan

- [x] `./gradlew :okapi-exposed:test --tests
"*ExposedConnectionProviderTest*"` — both cases pass
- [x] `./gradlew build` — full project build, all existing tests pass
- [x] `./gradlew ktlintFormat` — no formatting issues

Author: endrju19

okapi-exposed/src/main/kotlin/com/softwaremill/okapi/exposed/ExposedConnectionProvider.kt

@@ -13,12 +13,16 @@ import java.sql.Connection
  * `transaction(database) { }` block completes — so this provider performs no cleanup.
  *
  * Use when your application manages transactions via Exposed (e.g. Ktor + Exposed apps).
- * Must be called from within an active Exposed transaction; otherwise
- * `TransactionManager.current()` throws.
+ * Must be called from within an active Exposed transaction; otherwise [withConnection]
+ * throws an [IllegalStateException] pointing the caller at the missing `transaction { }`
+ * block, instead of letting Exposed's own less specific error surface.
  */
 class ExposedConnectionProvider : ConnectionProvider {
     override fun <T> withConnection(block: (Connection) -> T): T {
-        val connection = TransactionManager.current().connection.connection as Connection
-        return block(connection)
+        val transaction = TransactionManager.currentOrNull()
+            ?: throw IllegalStateException(
+                "ExposedConnectionProvider.withConnection must be called within an Exposed transaction { } block",
+            )
+        return block(transaction.connection.connection as Connection)
     }
 }

okapi-exposed/src/test/kotlin/com/softwaremill/okapi/exposed/ExposedConnectionProviderTest.kt

@@ -0,0 +1,34 @@
+package com.softwaremill.okapi.exposed
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldContain
+import org.jetbrains.exposed.v1.jdbc.Database
+import org.jetbrains.exposed.v1.jdbc.transactions.transaction
+
+class ExposedConnectionProviderTest : FunSpec({
+
+    val provider = ExposedConnectionProvider()
+
+    test("throws IllegalStateException with actionable message when called outside an Exposed transaction") {
+        val ex = shouldThrow<IllegalStateException> {
+            provider.withConnection { /* unreachable */ }
+        }
+        ex.message shouldContain "ExposedConnectionProvider.withConnection"
+        ex.message shouldContain "Exposed transaction { } block"
+    }
+
+    test("supplies the active Exposed transaction's connection to the block") {
+        val db = Database.connect(
+            "jdbc:h2:mem:exposed_provider_test_${System.nanoTime()};DB_CLOSE_DELAY=-1",
+            driver = "org.h2.Driver",
+        )
+
+        val connectionWasOpen: Boolean = transaction(db) {
+            provider.withConnection { conn -> !conn.isClosed }
+        }
+
+        connectionWasOpen shouldBe true
+    }
+})