refactor: replace word transaction to saga (#120)

* refactor: replace word transaction to saga

* build: netx version 0.3.8 to 0.3.9

gradle.properties

@@ -2,7 +2,7 @@ kotlin.code.style=official
 
 ### Project ###
 group=org.rooftop.netx
-version=0.3.8
+version=0.3.9
 compatibility=17
 
 ### Sonarcloud ###

src/main/kotlin/org/rooftop/netx/api/Exceptions.kt

@@ -4,14 +4,14 @@ class EncodeException(message: String, throwable: Throwable) : RuntimeException(
 
 class DecodeException(message: String, throwable: Throwable) : RuntimeException(message, throwable)
 
-open class TransactionException(message: String) : RuntimeException(message)
+open class SagaException(message: String) : RuntimeException(message)
 
-class AlreadyCommittedTransactionException(transactionId: String, state: String) :
-    TransactionException("Cannot join transaction cause, transaction \"$transactionId\" already \"$state\"")
+class AlreadyCommittedSagaException(id: String, state: String) :
+    SagaException("Cannot join saga cause, saga \"$id\" already \"$state\"")
 
 class NotFoundDispatchFunctionException(message: String) : RuntimeException(message)
 
-class FailedAckTransactionException(message: String) : RuntimeException(message)
+class FailedAckSagaException(message: String) : RuntimeException(message)
 
 class ResultTimeoutException(message: String, throwable: Throwable) :
     RuntimeException(message, throwable)

src/main/kotlin/org/rooftop/netx/api/Orchestrator.kt

@@ -4,19 +4,19 @@ import reactor.core.publisher.Mono
 
 interface Orchestrator<T : Any, V : Any> {
 
-    fun transaction(request: T): Mono<Result<V>>
+    fun saga(request: T): Mono<Result<V>>
 
-    fun transaction(timeoutMillis: Long, request: T): Mono<Result<V>>
+    fun saga(timeoutMillis: Long, request: T): Mono<Result<V>>
 
-    fun transaction(request: T, context: MutableMap<String, Any>): Mono<Result<V>>
+    fun saga(request: T, context: MutableMap<String, Any>): Mono<Result<V>>
 
-    fun transaction(timeoutMillis: Long, request: T, context: MutableMap<String, Any>): Mono<Result<V>>
+    fun saga(timeoutMillis: Long, request: T, context: MutableMap<String, Any>): Mono<Result<V>>
 
-    fun transactionSync(request: T): Result<V>
+    fun sagaSync(request: T): Result<V>
 
-    fun transactionSync(timeoutMillis: Long, request: T): Result<V>
+    fun sagaSync(timeoutMillis: Long, request: T): Result<V>
 
-    fun transactionSync(request: T, context: MutableMap<String, Any>): Result<V>
+    fun sagaSync(request: T, context: MutableMap<String, Any>): Result<V>
 
-    fun transactionSync(timeoutMillis: Long, request: T, context: MutableMap<String, Any>): Result<V>
+    fun sagaSync(timeoutMillis: Long, request: T, context: MutableMap<String, Any>): Result<V>
 }

src/main/kotlin/org/rooftop/netx/api/SagaCommitEvent.kt

@@ -0,0 +1,13 @@
+package org.rooftop.netx.api
+
+class SagaCommitEvent internal constructor(
+    id: String,
+    nodeName: String,
+    group: String,
+    event: String?,
+    codec: Codec,
+) : SagaEvent(id, nodeName, group, event, codec) {
+
+    override fun copy(): SagaCommitEvent =
+        SagaCommitEvent(id, nodeName, group, event, codec)
+}

src/main/kotlin/org/rooftop/netx/api/TransactionCommitListener.kt → src/main/kotlin/org/rooftop/netx/api/SagaCommitListener.kt

@@ -4,7 +4,7 @@ import kotlin.reflect.KClass
 
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.RUNTIME)
-annotation class TransactionCommitListener(
+annotation class SagaCommitListener(
     val event: KClass<*> = Any::class,
     val noRollbackFor: Array<KClass<out Throwable>> = [],
 )

src/main/kotlin/org/rooftop/netx/api/TransactionEvent.kt → src/main/kotlin/org/rooftop/netx/api/SagaEvent.kt

@@ -2,8 +2,8 @@ package org.rooftop.netx.api
 
 import kotlin.reflect.KClass
 
-sealed class TransactionEvent(
-    val transactionId: String,
+sealed class SagaEvent(
+    val id: String,
     val nodeName: String,
     val group: String,
     internal val event: String?,
@@ -24,5 +24,5 @@ sealed class TransactionEvent(
             type
         )
 
-    internal abstract fun copy(): TransactionEvent
+    internal abstract fun copy(): SagaEvent
 }

src/main/kotlin/org/rooftop/netx/api/SagaJoinEvent.kt

@@ -0,0 +1,13 @@
+package org.rooftop.netx.api
+
+class SagaJoinEvent internal constructor(
+    id: String,
+    nodeName: String,
+    group: String,
+    event: String?,
+    codec: Codec,
+) : SagaEvent(id, nodeName, group, event, codec) {
+
+    override fun copy(): SagaJoinEvent =
+        SagaJoinEvent(id, nodeName, group, event, codec)
+}

src/main/kotlin/org/rooftop/netx/api/TransactionJoinListener.kt → src/main/kotlin/org/rooftop/netx/api/SagaJoinListener.kt

@@ -4,7 +4,7 @@ import kotlin.reflect.KClass
 
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.RUNTIME)
-annotation class TransactionJoinListener(
+annotation class SagaJoinListener(
     val event: KClass<*> = Any::class,
     val noRollbackFor: Array<KClass<out Throwable>> = [],
     val successWith: SuccessWith = SuccessWith.PUBLISH_JOIN,

src/main/kotlin/org/rooftop/netx/api/SagaManager.kt

@@ -0,0 +1,43 @@
+package org.rooftop.netx.api
+
+import reactor.core.publisher.Mono
+
+interface SagaManager {
+
+    fun start(): Mono<String>
+
+    fun <T : Any> start(event: T): Mono<String>
+
+    fun syncStart(): String
+
+    fun <T : Any> syncStart(event: T): String
+
+    fun join(id: String): Mono<String>
+
+    fun <T : Any> join(id: String, event: T): Mono<String>
+
+    fun syncJoin(id: String): String
+
+    fun <T : Any> syncJoin(id: String, event: T): String
+
+    fun exists(id: String): Mono<String>
+
+    fun syncExists(id: String): String
+
+    fun commit(id: String): Mono<String>
+
+    fun <T : Any> commit(id: String, event: T): Mono<String>
+
+    fun syncCommit(id: String): String
+
+    fun <T : Any> syncCommit(id: String, event: T): String
+
+    fun rollback(id: String, cause: String): Mono<String>
+
+    fun <T : Any> rollback(id: String, cause: String, event: T): Mono<String>
+
+    fun syncRollback(id: String, cause: String): String
+
+    fun <T : Any> syncRollback(id: String, cause: String, event: T): String
+
+}

src/main/kotlin/org/rooftop/netx/api/SagaRollbackEvent.kt

@@ -0,0 +1,14 @@
+package org.rooftop.netx.api
+
+class SagaRollbackEvent internal constructor(
+    id: String,
+    nodeName: String,
+    group: String,
+    event: String?,
+    val cause: String,
+    codec: Codec,
+) : SagaEvent(id, nodeName, group, event, codec) {
+
+    override fun copy(): SagaRollbackEvent =
+        SagaRollbackEvent(id, nodeName, group, event, cause, codec)
+}

src/main/kotlin/org/rooftop/netx/api/TransactionRollbackListener.kt → src/main/kotlin/org/rooftop/netx/api/SagaRollbackListener.kt

@@ -4,6 +4,6 @@ import kotlin.reflect.KClass
 
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.RUNTIME)
-annotation class TransactionRollbackListener(
+annotation class SagaRollbackListener(
     val event: KClass<*> = Any::class,
 )

src/main/kotlin/org/rooftop/netx/api/SagaStartEvent.kt

@@ -0,0 +1,13 @@
+package org.rooftop.netx.api
+
+class SagaStartEvent internal constructor(
+    id: String,
+    nodeName: String,
+    group: String,
+    event: String?,
+    codec: Codec,
+) : SagaEvent(id, nodeName, group, event, codec) {
+
+    override fun copy(): SagaStartEvent =
+        SagaStartEvent(id, nodeName, group, event, codec)
+}

src/main/kotlin/org/rooftop/netx/api/TransactionStartListener.kt → src/main/kotlin/org/rooftop/netx/api/SagaStartListener.kt

@@ -4,7 +4,7 @@ import kotlin.reflect.KClass
 
 @Target(AnnotationTarget.FUNCTION)
 @Retention(AnnotationRetention.RUNTIME)
-annotation class TransactionStartListener(
+annotation class SagaStartListener(
     val event: KClass<*> = Any::class,
     val noRollbackFor: Array<KClass<out Throwable>> = [],
     val successWith: SuccessWith = SuccessWith.PUBLISH_JOIN,

src/main/kotlin/org/rooftop/netx/engine/AbstractDispatchFunction.kt

@@ -1,7 +1,7 @@
 package org.rooftop.netx.engine
 
-import org.rooftop.netx.api.TransactionEvent
-import org.rooftop.netx.api.TransactionManager
+import org.rooftop.netx.api.SagaEvent
+import org.rooftop.netx.api.SagaManager
 import reactor.core.scheduler.Schedulers
 import kotlin.reflect.KClass
 import kotlin.reflect.KFunction
@@ -11,48 +11,48 @@ internal sealed class AbstractDispatchFunction<T>(
     protected val function: KFunction<T>,
     protected val handler: Any,
     private val noRollbackFor: Array<KClass<out Throwable>>,
-    private val nextState: NextTransactionState,
-    private val transactionManager: TransactionManager,
+    private val nextState: NextSagaState,
+    private val sagaManager: SagaManager,
 ) {
     fun name(): String = function.name
 
-    abstract fun call(transactionEvent: TransactionEvent): T
+    abstract fun call(sagaEvent: SagaEvent): T
 
     protected fun isNoRollbackFor(throwable: Throwable): Boolean {
         return noRollbackFor.isNotEmpty() && throwable.cause != null && noRollbackFor.contains(
             throwable.cause!!::class
         )
     }
 
-    protected fun isProcessable(transactionEvent: TransactionEvent): Boolean {
+    protected fun isProcessable(sagaEvent: SagaEvent): Boolean {
         return runCatching {
-            transactionEvent.decodeEvent(eventType)
+            sagaEvent.decodeEvent(eventType)
         }.onFailure {
             return it is NullPointerException && eventType == Any::class
         }.isSuccess
     }
 
-    protected fun rollback(transactionEvent: TransactionEvent, throwable: Throwable) {
-        transactionEvent.nextEvent?.let {
-            transactionManager.rollback(transactionEvent.transactionId, throwable.getCause(), it)
+    protected fun rollback(sagaEvent: SagaEvent, throwable: Throwable) {
+        sagaEvent.nextEvent?.let {
+            sagaManager.rollback(sagaEvent.id, throwable.getCause(), it)
                 .subscribeOn(Schedulers.parallel())
                 .subscribe()
-        } ?: transactionManager.rollback(transactionEvent.transactionId, throwable.getCause())
+        } ?: sagaManager.rollback(sagaEvent.id, throwable.getCause())
             .subscribeOn(Schedulers.parallel())
             .subscribe()
     }
 
-    protected fun publishNextTransaction(transactionEvent: TransactionEvent) {
+    protected fun publishNextSaga(sagaEvent: SagaEvent) {
         when (nextState) {
-            NextTransactionState.JOIN -> transactionEvent.nextEvent?.let {
-                transactionManager.join(transactionEvent.transactionId, it)
-            } ?: transactionManager.join(transactionEvent.transactionId)
+            NextSagaState.JOIN -> sagaEvent.nextEvent?.let {
+                sagaManager.join(sagaEvent.id, it)
+            } ?: sagaManager.join(sagaEvent.id)
 
-            NextTransactionState.COMMIT -> transactionEvent.nextEvent?.let {
-                transactionManager.commit(transactionEvent.transactionId, it)
-            } ?: transactionManager.commit(transactionEvent.transactionId)
+            NextSagaState.COMMIT -> sagaEvent.nextEvent?.let {
+                sagaManager.commit(sagaEvent.id, it)
+            } ?: sagaManager.commit(sagaEvent.id)
 
-            NextTransactionState.END -> return
+            NextSagaState.END -> return
         }.subscribeOn(Schedulers.parallel())
             .subscribe()
     }
@@ -61,7 +61,7 @@ internal sealed class AbstractDispatchFunction<T>(
         return this.message ?: this.cause?.message ?: this::class.java.name
     }
 
-    internal enum class NextTransactionState {
+    internal enum class NextSagaState {
         JOIN,
         COMMIT,
         END