refactor: rolled_back in markerType

cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/request/ChangeRequest.java

@@ -39,7 +39,7 @@ public static ChangeRequest ongoingExecution(String id, boolean transactional) {
     }
 
     public static ChangeRequest ongoingRollback(String id, boolean transactional) {
-        return new ChangeRequest(id, CloudTargetSystemAuditMarkType.ROLLBACK, transactional);
+        return new ChangeRequest(id, CloudTargetSystemAuditMarkType.ROLLED_BACK, transactional);
     }
 
     public ChangeRequest(String id, CloudTargetSystemAuditMarkType ongoingStatus, boolean transactional) {

cloud/flamingock-cloud-api/src/main/java/io/flamingock/cloud/api/vo/CloudTargetSystemAuditMarkType.java

@@ -16,5 +16,5 @@
 package io.flamingock.cloud.api.vo;
 
 public enum CloudTargetSystemAuditMarkType {
-    NONE, APPLIED, ROLLBACK
+    NONE, APPLIED, ROLLED_BACK
 }

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/targets/TargetSystemAuditMarkType.java

@@ -16,5 +16,5 @@
 package io.flamingock.internal.common.core.targets;
 
 public enum TargetSystemAuditMarkType {
-    NONE, APPLIED, ROLLBACK
+    NONE, APPLIED, ROLLED_BACK
 }

core/flamingock-core/src/main/java/io/flamingock/internal/core/external/store/audit/domain/AuditContextBundle.java

@@ -35,12 +35,33 @@ public enum Operation {
 
         START_EXECUTION, EXECUTION, ROLLBACK;
 
+        private static final java.util.Map<Operation, TargetSystemAuditMarkType> TO_MARK_TYPE;
+        private static final java.util.Map<TargetSystemAuditMarkType, Operation> FROM_MARK_TYPE;
+
+        static {
+            TO_MARK_TYPE = new java.util.EnumMap<>(Operation.class);
+            TO_MARK_TYPE.put(EXECUTION, TargetSystemAuditMarkType.APPLIED);
+            TO_MARK_TYPE.put(ROLLBACK, TargetSystemAuditMarkType.ROLLED_BACK);
+
+            FROM_MARK_TYPE = new java.util.EnumMap<>(TargetSystemAuditMarkType.class);
+            FROM_MARK_TYPE.put(TargetSystemAuditMarkType.APPLIED, EXECUTION);
+            FROM_MARK_TYPE.put(TargetSystemAuditMarkType.ROLLED_BACK, ROLLBACK);
+        }
+
         public TargetSystemAuditMarkType toOngoingStatusOperation() {
-            return TargetSystemAuditMarkType.valueOf(this.name());
+            TargetSystemAuditMarkType result = TO_MARK_TYPE.get(this);
+            if (result == null) {
+                throw new IllegalArgumentException("No TargetSystemAuditMarkType mapping for Operation." + this.name());
+            }
+            return result;
         }
 
-        public static AuditContextBundle.Operation fromOngoingStatusOperation(TargetSystemAuditMarkType ongoingOperation) {
-            return AuditContextBundle.Operation.valueOf(ongoingOperation.name());
+        public static Operation fromOngoingStatusOperation(TargetSystemAuditMarkType ongoingOperation) {
+            Operation result = FROM_MARK_TYPE.get(ongoingOperation);
+            if (result == null) {
+                throw new IllegalArgumentException("No Operation mapping for TargetSystemAuditMarkType." + ongoingOperation.name());
+            }
+            return result;
         }
 
     }

core/flamingock-core/src/test/java/io/flamingock/internal/core/external/store/audit/domain/OperationMappingTest.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2026 Flamingock (https://www.flamingock.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.flamingock.internal.core.external.store.audit.domain;
+
+import io.flamingock.internal.common.core.targets.TargetSystemAuditMarkType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class OperationMappingTest {
+
+    @Test
+    @DisplayName("EXECUTION should map to APPLIED")
+    void executionMapsToApplied() {
+        assertEquals(TargetSystemAuditMarkType.APPLIED,
+                AuditContextBundle.Operation.EXECUTION.toOngoingStatusOperation());
+    }
+
+    @Test
+    @DisplayName("ROLLBACK should map to ROLLED_BACK")
+    void rollbackMapsToRolledBack() {
+        assertEquals(TargetSystemAuditMarkType.ROLLED_BACK,
+                AuditContextBundle.Operation.ROLLBACK.toOngoingStatusOperation());
+    }
+
+    @Test
+    @DisplayName("APPLIED should map back to EXECUTION")
+    void appliedMapsToExecution() {
+        assertEquals(AuditContextBundle.Operation.EXECUTION,
+                AuditContextBundle.Operation.fromOngoingStatusOperation(TargetSystemAuditMarkType.APPLIED));
+    }
+
+    @Test
+    @DisplayName("ROLLED_BACK should map back to ROLLBACK")
+    void rolledBackMapsToRollback() {
+        assertEquals(AuditContextBundle.Operation.ROLLBACK,
+                AuditContextBundle.Operation.fromOngoingStatusOperation(TargetSystemAuditMarkType.ROLLED_BACK));
+    }
+
+    @Test
+    @DisplayName("START_EXECUTION should throw when mapped to TargetSystemAuditMarkType")
+    void startExecutionHasNoMapping() {
+        assertThrows(IllegalArgumentException.class,
+                () -> AuditContextBundle.Operation.START_EXECUTION.toOngoingStatusOperation());
+    }
+
+    @Test
+    @DisplayName("NONE should throw when mapped to Operation")
+    void noneHasNoMapping() {
+        assertThrows(IllegalArgumentException.class,
+                () -> AuditContextBundle.Operation.fromOngoingStatusOperation(TargetSystemAuditMarkType.NONE));
+    }
+
+    @ParameterizedTest(name = "Every mappable Operation.{0} should round-trip through TargetSystemAuditMarkType")
+    @EnumSource(value = AuditContextBundle.Operation.class, names = {"EXECUTION", "ROLLBACK"})
+    void operationRoundTrips(AuditContextBundle.Operation operation) {
+        TargetSystemAuditMarkType markType = operation.toOngoingStatusOperation();
+        AuditContextBundle.Operation back = AuditContextBundle.Operation.fromOngoingStatusOperation(markType);
+        assertEquals(operation, back);
+    }
+
+    @ParameterizedTest(name = "Every mappable TargetSystemAuditMarkType.{0} should round-trip through Operation")
+    @EnumSource(value = TargetSystemAuditMarkType.class, names = {"APPLIED", "ROLLED_BACK"})
+    void markTypeRoundTrips(TargetSystemAuditMarkType markType) {
+        AuditContextBundle.Operation operation = AuditContextBundle.Operation.fromOngoingStatusOperation(markType);
+        TargetSystemAuditMarkType back = operation.toOngoingStatusOperation();
+        assertEquals(markType, back);
+    }
+
+    @Test
+    @DisplayName("All mappable Operations must have a mapping — fails if a new Operation is added without updating the map")
+    void allMappableOperationsCovered() {
+        int expectedMappable = 2; // EXECUTION, ROLLBACK — START_EXECUTION is intentionally unmapped
+        int actualMappable = 0;
+        for (AuditContextBundle.Operation op : AuditContextBundle.Operation.values()) {
+            try {
+                op.toOngoingStatusOperation();
+                actualMappable++;
+            } catch (IllegalArgumentException ignored) {
+            }
+        }
+        assertEquals(expectedMappable, actualMappable,
+                "A new Operation value was added without updating the mapping in Operation. " +
+                "Update TO_MARK_TYPE/FROM_MARK_TYPE maps and this test.");
+    }
+
+    @Test
+    @DisplayName("All mappable TargetSystemAuditMarkTypes must have a mapping — fails if a new value is added without updating the map")
+    void allMappableMarkTypesCovered() {
+        int expectedMappable = 2; // APPLIED, ROLLED_BACK — NONE is intentionally unmapped
+        int actualMappable = 0;
+        for (TargetSystemAuditMarkType mt : TargetSystemAuditMarkType.values()) {
+            try {
+                AuditContextBundle.Operation.fromOngoingStatusOperation(mt);
+                actualMappable++;
+            } catch (IllegalArgumentException ignored) {
+            }
+        }
+        assertEquals(expectedMappable, actualMappable,
+                "A new TargetSystemAuditMarkType value was added without updating the mapping in Operation. " +
+                "Update TO_MARK_TYPE/FROM_MARK_TYPE maps and this test.");
+    }
+}

core/target-systems/flamingock-sql-targetsystem/src/main/java/io/flamingock/targetsystem/sql/SqlTargetSystemAuditMarker.java

@@ -18,7 +18,7 @@
 import io.flamingock.internal.common.core.error.FlamingockException;
 import io.flamingock.internal.common.sql.SqlDialect;
 import io.flamingock.internal.core.transaction.TransactionManager;
-import io.flamingock.internal.core.external.store.audit.domain.AuditContextBundle;
+import io.flamingock.internal.common.core.targets.TargetSystemAuditMarkType;
 import io.flamingock.internal.core.external.targets.mark.TargetSystemAuditMark;
 import io.flamingock.internal.core.external.targets.mark.TargetSystemAuditMarker;
 
@@ -66,8 +66,8 @@ public Set<TargetSystemAuditMark> listAll() {
             Set<TargetSystemAuditMark> ongoingStatuses = new HashSet<>();
             while (resultSet.next()) {
                 String changeId = resultSet.getString("change_id");
-                AuditContextBundle.Operation operation = AuditContextBundle.Operation.valueOf(resultSet.getString("operation"));
-                ongoingStatuses.add(new TargetSystemAuditMark(changeId, operation.toOngoingStatusOperation()));
+                TargetSystemAuditMarkType markType = TargetSystemAuditMarkType.valueOf(resultSet.getString("operation"));
+                ongoingStatuses.add(new TargetSystemAuditMark(changeId, markType));
             }
             return ongoingStatuses;
         } catch (SQLException ex) {

core/target-systems/flamingock-sql-targetsystem/src/test/java/io/flamingock/targetsystem/sql/SqlAuditMarkerDialectHelperTest.java

@@ -175,7 +175,7 @@ void addOngoingChangeMark(SqlDialect dialect) {
             // GIVEN
             String changeId1 = "test-change-id1";
             String changeId2 = "test-change-id2";
-            TargetSystemAuditMarkType operation = TargetSystemAuditMarkType.ROLLBACK;
+            TargetSystemAuditMarkType operation = TargetSystemAuditMarkType.ROLLED_BACK;
 
             TargetSystemAuditMark mark1 = new TargetSystemAuditMark(changeId1, operation);
             TargetSystemAuditMark mark2 = new TargetSystemAuditMark(changeId2, operation);
@@ -221,7 +221,7 @@ void removeOngoingChangeMark(SqlDialect dialect) {
             // GIVEN
             String changeId1 = "test-change-id1";
             String changeId2 = "test-change-id2";
-            TargetSystemAuditMarkType operation = TargetSystemAuditMarkType.ROLLBACK;
+            TargetSystemAuditMarkType operation = TargetSystemAuditMarkType.ROLLED_BACK;
 
             TargetSystemAuditMark mark1 = new TargetSystemAuditMark(changeId1, operation);
             TargetSystemAuditMark mark2 = new TargetSystemAuditMark(changeId2, operation);