feat: adapt to TemplateValidationContext and add transactional compatibility validation

The TemplatePayload interface changed from validate() to
validate(TemplateValidationContext). This updates MongoOperation to match
the new signature and implements transactional compatibility checks at
load time: non-transactional operations in a transactional change produce
a validation error, while transactional operations in a non-transactional
change log a warning.

- Add boolean transactional field to MongoOperationType enum
- Update MongoOperation.validate() to accept TemplateValidationContext
- Update MongoChangeTemplate javadoc @link references
- Update all 93 test validate() calls and add TransactionalValidationTests

Author: dieppa

src/main/java/io/flamingock/template/mongodb/MongoChangeTemplate.java

@@ -23,6 +23,7 @@
 import io.flamingock.api.annotations.Rollback;
 import io.flamingock.api.template.AbstractChangeTemplate;
 import io.flamingock.api.template.wrappers.TemplateVoid;
+import io.flamingock.api.template.TemplateValidationContext;
 import io.flamingock.template.mongodb.model.MongoOperation;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -86,7 +87,7 @@ public MongoChangeTemplate() {
      * Executes the apply operation for the current step.
      * <p>
      * Precondition: {@code applyPayload} has been structurally validated at load time
-     * via {@link MongoOperation#validate()}, which delegates to the appropriate
+     * via {@link MongoOperation#validate(TemplateValidationContext)}, which delegates to the appropriate
      * {@code ParametersValidator} for each operation type. No validation is performed here.
      */
     @Apply
@@ -99,7 +100,7 @@ public void apply(MongoDatabase db, @Nullable ClientSession clientSession) {
      * Executes the rollback operation for the current step.
      * <p>
      * Precondition: {@code rollbackPayload} has been structurally validated at load time
-     * via {@link MongoOperation#validate()}, which delegates to the appropriate
+     * via {@link MongoOperation#validate(TemplateValidationContext)}, which delegates to the appropriate
      * {@code ParametersValidator} for each operation type. No validation is performed here.
      */
     @Rollback

src/main/java/io/flamingock/template/mongodb/model/MongoOperation.java

@@ -20,17 +20,23 @@
 import io.flamingock.api.NonLockGuardedType;
 import io.flamingock.api.template.TemplatePayload;
 import io.flamingock.api.template.TemplatePayloadValidationError;
+import io.flamingock.api.template.TemplateValidationContext;
 import io.flamingock.template.mongodb.model.operator.MongoOperator;
 import io.flamingock.template.mongodb.validation.CollectionValidator;
 import io.flamingock.template.mongodb.validation.TypeValidator;
 import org.bson.Document;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
 @NonLockGuarded(NonLockGuardedType.NONE)
 public class MongoOperation implements TemplatePayload {
+
+    private static final Logger logger = LoggerFactory.getLogger(MongoOperation.class);
+
     private String type;
     private String collection;
     private Map<String, Object> parameters;
@@ -87,7 +93,7 @@ public String toString() {
     private static final CollectionValidator COLLECTION_VALIDATOR = new CollectionValidator();
 
     @Override
-    public List<TemplatePayloadValidationError> validate() {
+    public List<TemplatePayloadValidationError> validate(TemplateValidationContext context) {
 
         List<TemplatePayloadValidationError> typeErrors = TYPE_VALIDATOR.validate(this);
         List<TemplatePayloadValidationError> errors = new ArrayList<>(typeErrors);
@@ -101,6 +107,18 @@ public List<TemplatePayloadValidationError> validate() {
         errors.addAll(COLLECTION_VALIDATOR.validate(this));
         errors.addAll(operationType.getOperationValidator().validate(this));
 
+        if (!operationType.isTransactional() && context.isTransactional()) {
+            errors.add(new TemplatePayloadValidationError("type",
+                    "Operation type '" + type + "' does not support transactions. "
+                            + "Transactional changes require all operations to be transactional "
+                            + "(insert, update, delete)."));
+        }
+        if (operationType.isTransactional() && !context.isTransactional()) {
+            logger.warn("Operation '{}' on collection '{}' supports transactions but the change "
+                    + "is not marked as transactional. Consider setting transactional: true "
+                    + "for native rollback on failure.", type, collection);
+        }
+
         return errors;
     }
 }

src/main/java/io/flamingock/template/mongodb/model/MongoOperationType.java

@@ -45,28 +45,31 @@
 
 public enum MongoOperationType {
 
-    CREATE_COLLECTION("createCollection", CreateCollectionOperator::new, new NoParametersValidator("CreateCollection")),
-    CREATE_INDEX("createIndex", CreateIndexOperator::new, new CreateIndexParametersValidator()),
-    INSERT("insert", InsertOperator::new, new InsertParametersValidator()),
-    UPDATE("update", UpdateOperator::new, new UpdateParametersValidator()),
-    DELETE("delete", DeleteOperator::new, new DeleteParametersValidator()),
-    DROP_COLLECTION("dropCollection", DropCollectionOperator::new, new NoParametersValidator("DropCollection")),
-    DROP_INDEX("dropIndex", DropIndexOperator::new, new DropIndexParametersValidator()),
-    RENAME_COLLECTION("renameCollection", RenameCollectionOperator::new, new RenameCollectionParametersValidator()),
-    MODIFY_COLLECTION("modifyCollection", ModifyCollectionOperator::new, new ModifyCollectionParametersValidator()),
-    CREATE_VIEW("createView", CreateViewOperator::new, new CreateViewParametersValidator()),
-    DROP_VIEW("dropView", DropViewOperator::new, new NoParametersValidator("DropView"));
+    CREATE_COLLECTION("createCollection", CreateCollectionOperator::new, new NoParametersValidator("CreateCollection"), false),
+    CREATE_INDEX("createIndex", CreateIndexOperator::new, new CreateIndexParametersValidator(), false),
+    INSERT("insert", InsertOperator::new, new InsertParametersValidator(), true),
+    UPDATE("update", UpdateOperator::new, new UpdateParametersValidator(), true),
+    DELETE("delete", DeleteOperator::new, new DeleteParametersValidator(), true),
+    DROP_COLLECTION("dropCollection", DropCollectionOperator::new, new NoParametersValidator("DropCollection"), false),
+    DROP_INDEX("dropIndex", DropIndexOperator::new, new DropIndexParametersValidator(), false),
+    RENAME_COLLECTION("renameCollection", RenameCollectionOperator::new, new RenameCollectionParametersValidator(), false),
+    MODIFY_COLLECTION("modifyCollection", ModifyCollectionOperator::new, new ModifyCollectionParametersValidator(), false),
+    CREATE_VIEW("createView", CreateViewOperator::new, new CreateViewParametersValidator(), false),
+    DROP_VIEW("dropView", DropViewOperator::new, new NoParametersValidator("DropView"), false);
 
     private final String value;
     private final BiFunction<MongoDatabase, MongoOperation, MongoOperator> createOperatorFunction;
     private final OperationValidator operationValidator;
+    private final boolean transactional;
 
     MongoOperationType(String value,
                        BiFunction<MongoDatabase, MongoOperation, MongoOperator> createOperatorFunction,
-                       OperationValidator operationValidator) {
+                       OperationValidator operationValidator,
+                       boolean transactional) {
         this.value = value;
         this.createOperatorFunction = createOperatorFunction;
         this.operationValidator = operationValidator;
+        this.transactional = transactional;
     }
 
     public static MongoOperationType findByTypeOrThrow(String typeValue) {
@@ -90,6 +93,10 @@ public OperationValidator getOperationValidator() {
         return operationValidator;
     }
 
+    public boolean isTransactional() {
+        return transactional;
+    }
+
     private boolean matches(String operationType) {
         return this.value.equals(operationType);
     }