feat(core): add validationOnly mode to prevent change execution

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/error/PendingChangesException.java

@@ -0,0 +1,26 @@
+/*
+ * 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.common.core.error;
+
+/**
+ * Exception thrown when Flamingock runs in validation-only mode and detects pending changes.
+ */
+public class PendingChangesException extends FlamingockException {
+
+    public PendingChangesException() {
+        super("Flamingock validationOnly=true: pending changes detected. Apply them before running in validation-only mode.");
+    }
+}

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/operation/OperationType.java

@@ -18,8 +18,8 @@
 public enum OperationType {
     EXECUTE_APPLY,
     EXECUTE_ROLLBACK,
-    EXECUTE_VALIDATE,
     EXECUTE_DRYRUN,
+    VALIDATE,
     AUDIT_LIST,
     AUDIT_FIX,
     ISSUE_LIST,

core/flamingock-core/src/main/java/io/flamingock/internal/core/builder/AbstractChangeRunnerBuilder.java

@@ -31,6 +31,7 @@
 import io.flamingock.internal.core.context.SimpleContext;
 import io.flamingock.internal.core.external.store.AuditStore;
 import io.flamingock.internal.core.external.store.audit.AuditPersistence;
+import io.flamingock.internal.core.operation.OperationResolver;
 import io.flamingock.internal.core.plan.ExecutionPlanner;
 import io.flamingock.internal.core.event.CompositeEventPublisher;
 import io.flamingock.internal.core.event.EventPublisher;
@@ -43,7 +44,6 @@
 import io.flamingock.internal.core.event.model.IStageFailedEvent;
 import io.flamingock.internal.core.event.model.IStageIgnoredEvent;
 import io.flamingock.internal.core.event.model.IStageStartedEvent;
-import io.flamingock.internal.core.operation.OperationFactory;
 import io.flamingock.internal.core.operation.RunnableOperation;
 import io.flamingock.internal.core.pipeline.loaded.LoadedPipeline;
 import io.flamingock.internal.core.plugin.Plugin;
@@ -213,7 +213,7 @@ public final Runner build() {
 
         FlamingockArguments flamingockArgs = FlamingockArguments.parse(applicationArgs);
 
-        OperationFactory operationFactory = new OperationFactory(
+        OperationResolver operationResolver = new OperationResolver(
                 runnerId,
                 flamingockArgs,
                 pipeline,
@@ -227,7 +227,7 @@ public final Runner build() {
                 coreConfiguration.isThrowExceptionIfCannotObtainLock(),
                 persistence.getCloser()
         );
-        RunnableOperation<?, ?> operation = operationFactory.getOperation();
+        RunnableOperation<?, ?> operation = operationResolver.getOperation();
 
         return new RunnerFactory(runnerId, flamingockArgs, operation, persistence.getCloser()).create();
     }
@@ -359,6 +359,15 @@ public HOLDER setEnabled(boolean enabled) {
         return getSelf();
     }
 
+    public HOLDER setValidationOnly(boolean validationOnly) {
+        coreConfiguration.setValidationOnly(validationOnly);
+        return getSelf();
+    }
+
+    public boolean isValidationOnly() {
+        return coreConfiguration.isValidationOnly();
+    }
+
     @Override
     public HOLDER setServiceIdentifier(String serviceIdentifier) {
         coreConfiguration.setServiceIdentifier(serviceIdentifier);

core/flamingock-core/src/main/java/io/flamingock/internal/core/builder/args/FlamingockArguments.java

@@ -35,25 +35,22 @@ public class FlamingockArguments {
 
     private final boolean cliMode;
     private final OperationType operation;
-    private final boolean operationProvided;
     private final String outputFile;
     private final Map<String, String> remainingArgs;
 
     private FlamingockArguments(boolean cliMode,
                                 OperationType operation,
-                                boolean operationProvided,
                                 String outputFile,
                                 Map<String, String> remainingArgs) {
         this.cliMode = cliMode;
         this.operation = operation;
-        this.operationProvided = operationProvided;
         this.outputFile = outputFile;
         this.remainingArgs = Collections.unmodifiableMap(remainingArgs);
     }
 
     public static FlamingockArguments parse(String[] args) {
         if (args == null || args.length == 0) {
-            return new FlamingockArguments(false, OperationType.EXECUTE_APPLY, false, null, Collections.emptyMap());
+            return new FlamingockArguments(false, null, null, Collections.emptyMap());
         }
 
         boolean cliMode = false;
@@ -105,8 +102,8 @@ public static FlamingockArguments parse(String[] args) {
             }
         }
 
-        OperationType effectiveOperation = operationProvided ? operation : OperationType.EXECUTE_APPLY;
-        return new FlamingockArguments(cliMode, effectiveOperation, operationProvided, outputFile, remaining);
+        OperationType effectiveOperation = operationProvided ? operation : null;
+        return new FlamingockArguments(cliMode, effectiveOperation, outputFile, remaining);
     }
 
     private static boolean parseBoolean(String key, String value) {
@@ -150,12 +147,8 @@ public boolean isCliMode() {
         return cliMode;
     }
 
-    public OperationType getOperation() {
-        return operation;
-    }
-
-    public boolean isOperationProvided() {
-        return operationProvided;
+    public Optional<OperationType> getOperation() {
+        return Optional.ofNullable(operation);
     }
 
     public Optional<String> getOutputFile() {

core/flamingock-core/src/main/java/io/flamingock/internal/core/builder/runner/CliRunner.java

@@ -18,8 +18,8 @@
 import io.flamingock.internal.common.core.response.ResponseChannel;
 import io.flamingock.internal.common.core.response.ResponseEnvelope;
 import io.flamingock.internal.common.core.response.ResponseError;
+import io.flamingock.internal.core.builder.args.FlamingockArguments;
 import io.flamingock.internal.core.operation.AbstractOperationResult;
-import io.flamingock.internal.common.core.operation.OperationType;
 import io.flamingock.internal.core.operation.RunnableOperation;
 import io.flamingock.internal.util.log.FlamingockLoggerFactory;
 import org.slf4j.Logger;
@@ -35,16 +35,16 @@ public class CliRunner implements Runner {
     private final RunnableOperation<?, ?> operation;
     private final Runnable finalizer;
     private final ResponseChannel channel;
-    private final OperationType operationType;
+    private final FlamingockArguments flamingockArgs;
 
     public CliRunner(RunnableOperation<?, ?> operation,
                      Runnable finalizer,
                      ResponseChannel channel,
-                     OperationType operationType) {
+                     FlamingockArguments flamingockArgs) {
         this.operation = operation;
         this.finalizer = finalizer;
         this.channel = channel;
-        this.operationType = operationType;
+        this.flamingockArgs = flamingockArgs;
     }
 
     @Override
@@ -92,7 +92,9 @@ public void run() {
 
     private void writeResponse(AbstractOperationResult result, Throwable error, long durationMs) {
         ResponseEnvelope envelope;
-        String operationName = operationType.name();
+        String operationName = flamingockArgs.getOperation()
+            .map(Enum::name)
+            .orElse("unknown");
 
         if (error != null) {
             envelope = ResponseEnvelope.failure(operationName, ResponseError.from(error), durationMs);

core/flamingock-core/src/main/java/io/flamingock/internal/core/builder/runner/RunnerFactory.java

@@ -60,7 +60,7 @@ private Runner createCliRunner() {
                 .map(outputFile -> (ResponseChannel) new FileResponseChannel(outputFile, JsonObjectMapper.DEFAULT_INSTANCE))
                 .orElseGet(NoOpResponseChannel::new);
 
-        return new CliRunner(operation, finalizer, channel, flamingockArgs.getOperation());
+        return new CliRunner(operation, finalizer, channel, flamingockArgs);
     }
 
     private Runner createDefaultRunner() {

core/flamingock-core/src/main/java/io/flamingock/internal/core/configuration/core/CoreConfigurable.java

@@ -38,6 +38,10 @@ public interface CoreConfigurable {
 
     void setEnabled(boolean enabled);
 
+    void setValidationOnly(boolean validationOnly);
+
+    boolean isValidationOnly();
+
     void setServiceIdentifier(String serviceIdentifier);
 
     void setMetadata(Map<String, Object> metadata);

core/flamingock-core/src/main/java/io/flamingock/internal/core/configuration/core/CoreConfiguration.java

@@ -35,6 +35,13 @@ public class CoreConfiguration implements CoreConfigurable {
      */
     private boolean enabled = true;
 
+    /**
+     * If true, Flamingock will only validate that no pending changes exist without applying them
+     * When Flamingock runs through the CLI, the CLI operation takes precedence over this flag
+     * Default false
+     */
+    private boolean validationOnly = false;
+
     /**
      * Service identifier.
      */
@@ -91,6 +98,11 @@ public void setEnabled(boolean enabled) {
         this.enabled = enabled;
     }
 
+    @Override
+    public void setValidationOnly(boolean validationOnly) {
+        this.validationOnly = validationOnly;
+    }
+
     @Override
     public void setServiceIdentifier(String serviceIdentifier) {
         this.serviceIdentifier = serviceIdentifier;
@@ -126,6 +138,11 @@ public boolean isEnabled() {
         return enabled;
     }
 
+    @Override
+    public boolean isValidationOnly() {
+        return validationOnly;
+    }
+
     @Override
     public String getServiceIdentifier() {
         return serviceIdentifier;

core/flamingock-core/src/main/java/io/flamingock/internal/core/operation/execute/ExecuteOperation.java → core/flamingock-core/src/main/java/io/flamingock/internal/core/operation/AbstractPipelineTraverseOperation.java

@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.flamingock.internal.core.operation.execute;
+package io.flamingock.internal.core.operation;
 
 import io.flamingock.internal.common.core.error.FlamingockException;
+import io.flamingock.internal.common.core.error.PendingChangesException;
 import io.flamingock.internal.common.core.response.data.ErrorInfo;
 import io.flamingock.internal.common.core.response.data.ExecuteResponseData;
 import io.flamingock.internal.common.core.response.data.StageResult;
@@ -26,8 +27,8 @@
 import io.flamingock.internal.core.event.model.impl.StageCompletedEvent;
 import io.flamingock.internal.core.event.model.impl.StageFailedEvent;
 import io.flamingock.internal.core.event.model.impl.StageStartedEvent;
-import io.flamingock.internal.core.operation.Operation;
-import io.flamingock.internal.core.operation.OperationException;
+import io.flamingock.internal.core.operation.execute.ExecuteArgs;
+import io.flamingock.internal.core.operation.execute.ExecuteResult;
 import io.flamingock.internal.core.operation.result.ExecutionResultBuilder;
 import io.flamingock.internal.core.pipeline.execution.ExecutableStage;
 import io.flamingock.internal.core.pipeline.execution.ExecutionContext;
@@ -48,9 +49,9 @@
 import java.util.List;
 
 /**
- * Executes the pipeline and returns structured result data.
+ * Common execution flow for Apply and Validate operations
  */
-public class ExecuteOperation implements Operation<ExecuteArgs, ExecuteResult> {
+public abstract class AbstractPipelineTraverseOperation implements Operation<ExecuteArgs, ExecuteResult> {
 
     private static final Logger logger = FlamingockLoggerFactory.getLogger("PipelineRunner");
 
@@ -66,15 +67,15 @@ public class ExecuteOperation implements Operation<ExecuteArgs, ExecuteResult> {
 
     private final OrphanExecutionContext orphanExecutionContext;
 
-    private final Runnable finalizer;
+    protected final Runnable finalizer;
 
-    public ExecuteOperation(RunnerId runnerId,
-                            ExecutionPlanner executionPlanner,
-                            StageExecutor stageExecutor,
-                            OrphanExecutionContext orphanExecutionContext,
-                            EventPublisher eventPublisher,
-                            boolean throwExceptionIfCannotObtainLock,
-                            Runnable finalizer) {
+    public AbstractPipelineTraverseOperation(RunnerId runnerId,
+                                             ExecutionPlanner executionPlanner,
+                                             StageExecutor stageExecutor,
+                                             OrphanExecutionContext orphanExecutionContext,
+                                             EventPublisher eventPublisher,
+                                             boolean throwExceptionIfCannotObtainLock,
+                                             Runnable finalizer) {
         this.runnerId = runnerId;
         this.executionPlanner = executionPlanner;
         this.stageExecutor = stageExecutor;
@@ -84,19 +85,19 @@ public ExecuteOperation(RunnerId runnerId,
         this.finalizer = finalizer;
     }
 
+    protected abstract boolean validateOnlyMode();
 
     @Override
     public ExecuteResult execute(ExecuteArgs args) {
         ExecuteResponseData result;
         try {
             result = this.execute(args.getPipeline());
         } catch (OperationException operationException) {
-            result = operationException.getResult();
             throw operationException;
         } catch (Throwable throwable) {
             throw processAndGetFlamingockException(throwable, null);
         } finally {
-            finalizer.run();
+            this.finalizer.run();
         }
         return new ExecuteResult(result);
     }
@@ -130,6 +131,9 @@ private ExecuteResponseData execute(LoadedPipeline pipeline) throws FlamingockEx
                 execution.validate();
 
                 if (execution.isExecutionRequired()) {
+                    if (validateOnlyMode()) {
+                        throw new PendingChangesException();
+                    }
                     execution.applyOnEach((executionId, lock, executableStage) -> {
                         StageResult stageResult = runStage(executionId, lock, executableStage);
                         resultBuilder.addStage(stageResult);
@@ -208,5 +212,4 @@ private FlamingockException processAndGetFlamingockException(Throwable exception
         eventPublisher.publish(new PipelineFailedEvent(flamingockException));
         return flamingockException;
     }
-
 }