bedre dokumentasjon og logging i transaction

inliner noen funksjoner for å forenkle

Author: di0nys1us

database/src/main/kotlin/no/nav/hjelpemidler/database/JdbcTransactionContext.kt

@@ -1,11 +1,15 @@
 package no.nav.hjelpemidler.database
 
 import io.github.oshai.kotlinlogging.KotlinLogging
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.coroutines.withContext
 import no.nav.hjelpemidler.database.kotliquery.SessionJdbcOperations
 import no.nav.hjelpemidler.database.kotliquery.SessionProperties
 import no.nav.hjelpemidler.database.kotliquery.createSession
 import javax.sql.DataSource
+import kotlin.coroutines.AbstractCoroutineContextElement
+import kotlin.coroutines.CoroutineContext
 
 private val log = KotlinLogging.logger {}
 
@@ -14,23 +18,26 @@ interface Transaction<T : Any> {
 }
 
 /**
- * Opprett [JdbcOperations] og start transaksjon eller gjenbruk eksisterende.
+ * Opprett [JdbcOperations] og start transaksjon eller gjenbruk eksisterende [JdbcOperations].
  *
  * Tilsvarer `PROPAGATION_REQUIRED` i Spring.
  *
  * Tillater suspending functions i transaksjonen for nettverkskall etc.
  *
- * NB! Ikke gjør parallelle kall med [JdbcOperations] i [block] som f.eks.:
+ * NB! Ikke gjør parallelle kall med samme [JdbcOperations] i [block] som f.eks.:
  * ```kotlin
- * transaction { tx ->
+ * transaction { operations ->
  *     coroutineScope {
- *         launch { tx... }
- *         val deferred = async { tx... }
+ *         launch { operations... }
+ *         val deferred = async { operations... }
  *     }
  * }
  * ```
  *
- * @see [JdbcTransactionContext]
+ * NB! Parametre som [readOnly] etc. kan ikke endres i nestede transaksjoner siden transaksjonen gjenbrukes.
+ * Eventuelle endringer vil bli ignorert.
+ *
+ * @see [TransactionJdbcOperations]
  * @see <a href="https://docs.spring.io/spring-framework/reference/data-access/transaction/declarative/tx-propagation.html#tx-propagation-required">Understanding PROPAGATION_REQUIRED</a>
  */
 suspend fun <T> transaction(
@@ -47,20 +54,27 @@ suspend fun <T> transaction(
         strict = strict,
         queryTimeout = queryTimeout,
     )
-    val context = currentTransactionContext() ?: return withTransactionContext(
-        closeable = createSession(dataSource, properties),
-    ) { session ->
-        log.trace { "Establishing new database transaction, $properties" }
-        session.transaction {
-            val tx = SessionJdbcOperations(it)
-            withContext(JdbcTransactionContext(properties, tx)) {
-                block(tx)
+    val outer = currentCoroutineContext()[TransactionJdbcOperations] ?: return withContext(Dispatchers.IO) {
+        log.trace { "Oppretter ny databasetransaksjon, $properties" }
+        createSession(dataSource, properties).use { session ->
+            session.transaction { transactionalSession ->
+                val operations = SessionJdbcOperations(transactionalSession)
+                withContext(TransactionJdbcOperations(properties, operations)) {
+                    block(operations)
+                }
             }
         }
     }
-    log.trace { "Existing database transaction is reused, ${context.properties}" }
-    if (properties != context.properties) {
-        log.debug { "Session properties changed. Ignoring modifications in nested transaction because the outer transaction is reused, outer: (${context.properties}), nested: ($properties)" }
+    log.trace { "Gjenbruker eksisterende databasetransaksjon, ${outer.properties}" }
+    if (properties != outer.properties) {
+        log.debug { "Transaksjonen ble forsøkt endret, men endringene ignoreres siden transaksjonen gjenbrukes, ytre: (${outer.properties}), indre: ($properties)" }
     }
-    return block(context.tx)
+    return block(outer.operations)
+}
+
+internal class TransactionJdbcOperations(
+    val properties: SessionProperties,
+    val operations: JdbcOperations,
+) : AbstractCoroutineContextElement(TransactionJdbcOperations) {
+    companion object Key : CoroutineContext.Key<TransactionJdbcOperations>
 }