feat: springboot management mode

core/flamingock-core-api/src/main/java/io/flamingock/api/annotations/EnableFlamingock.java

@@ -15,17 +15,15 @@
  */
 package io.flamingock.api.annotations;
 
-import io.flamingock.api.SetupType;
-
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * Core annotation for configuring Flamingock setup execution and framework integration.
+ * Core annotation for configuring Flamingock pipeline execution.
  * This annotation must be placed on a class to enable Flamingock processing and define
- * how the pipeline should be configured and applied.
+ * how the pipeline should be configured.
  *
  * <h2>Pipeline Configuration</h2>
  *
@@ -55,48 +53,6 @@
  * }
  * </pre>
  *
- * <h2>Framework Integration Setup</h2>
- *
- * The {@link #setup()} field controls how Flamingock integrates with application frameworks:
- *
- * <h3>DEFAULT Setup (Automatic Integration)</h3>
- * In framework environments like Spring Boot, Flamingock automatically registers and configures
- * the Flamingock runner bean based on configuration properties and annotation settings.
- * In standalone applications, behaves the same as BUILDER setup.
- *
- * <pre>
- * &#64;EnableFlamingock(
- *     setup = SetupType.DEFAULT,  // Default value - automatic framework integration
- *     stages = { &#64;Stage(location = "com.example.migrations") }
- * )
- * &#64;Configuration
- * public class FlamingockConfig {
- *     // Spring Boot will automatically create and configure the Flamingock runner
- *     // No manual bean configuration required
- * }
- * </pre>
- *
- * <h3>BUILDER Setup (Manual Configuration)</h3>
- * Disables automatic framework integration, requiring manual Flamingock runner configuration.
- * Useful when you need full control over the Flamingock setup process.
- *
- * <pre>
- * &#64;EnableFlamingock(
- *     setup = SetupType.BUILDER,  // Manual configuration required
- *     stages = { &#64;Stage(location = "com.example.migrations") }
- * )
- * &#64;Configuration
- * public class FlamingockConfig {
- *
- *     &#64;Bean
- *     public Flamingock flamingock(MongoTemplate mongoTemplate) {
- *         return FlamingockFactory.cloudBuilder()
- *             .setAuditStore(new MongoDBSyncAuditStore())
- *             .buildRunner();
- *     }
- * }
- * </pre>
- *
  * <h2>Validation Rules</h2>
  * <ul>
  *     <li>Either {@link #configFile()} OR {@link #stages()} must be specified (mutually exclusive)</li>
@@ -107,7 +63,6 @@
  *
  * @since 1.0
  * @see Stage
- * @see SetupType
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
@@ -165,51 +120,6 @@
      */
     String configFile() default "";
 
-    /**
-     * Controls how Flamingock integrates with application frameworks.
-     *
-     * <p><b>DEFAULT</b> - Automatic framework integration:
-     * <ul>
-     *     <li>In Spring Boot: Flamingock automatically registers and configures the runner bean</li>
-     *     <li>In standalone applications: Behaves the same as BUILDER</li>
-     *     <li>Configuration is derived from application properties and annotation settings</li>
-     * </ul>
-     *
-     * <p><b>BUILDER</b> - Manual configuration required:
-     * <ul>
-     *     <li>Framework integration is disabled</li>
-     *     <li>Developer must manually create and configure Flamingock beans</li>
-     *     <li>Provides full control over the setup process</li>
-     * </ul>
-     *
-     * <p>Example with automatic setup (DEFAULT):
-     * <pre>
-     * &#64;EnableFlamingock(setup = SetupType.DEFAULT)  // or omit for default
-     * &#64;Configuration
-     * public class Config {
-     *     // Spring Boot auto-configures Flamingock
-     * }
-     * </pre>
-     *
-     * <p>Example with manual setup (BUILDER):
-     * <pre>
-     * &#64;EnableFlamingock(setup = SetupType.BUILDER)
-     * &#64;Configuration
-     * public class Config {
-     *     &#64;Bean
-     *     public Flamingock flamingock(AuditStore auditStore) {
-     *         return FlamingockFactory.cloudBuilder()
-     *             .setAuditStore(auditStore)
-     *             .buildRunner();
-     *     }
-     * }
-     * </pre>
-     *
-     * @return the setup type for framework integration
-     * @see SetupType
-     */
-    SetupType setup() default SetupType.DEFAULT;
-
     /**
      * If true, the annotation processor will validate that all code-based changes
      * (classes annotated with @Change) are mapped to some stage. When unmapped changes

core/flamingock-core-commons/src/main/java/io/flamingock/internal/common/core/metadata/FlamingockMetadata.java

@@ -20,15 +20,13 @@
 public class FlamingockMetadata {
 
     private PreviewPipeline pipeline;
-    private String setup;
     private String configFile;
 
     public FlamingockMetadata() {
     }
 
-    public FlamingockMetadata(PreviewPipeline pipeline, String setup, String configFile) {
+    public FlamingockMetadata(PreviewPipeline pipeline, String configFile) {
         this.pipeline = pipeline;
-        this.setup = setup;
         this.configFile = configFile;
     }
 
@@ -40,14 +38,6 @@ public void setPipeline(PreviewPipeline pipeline) {
         this.pipeline = pipeline;
     }
 
-    public String getSetup() {
-        return setup;
-    }
-
-    public void setSetup(String setup) {
-        this.setup = setup;
-    }
-
     public String getPipelineFile() {
         return configFile;
     }
@@ -59,8 +49,7 @@ public void setPipelineFile(String configFile) {
     @Override
     public String toString() {
         return "FlamingockMetadata{" + "pipeline=" + pipeline +
-                ", setup='" + setup + '\'' +
                 ", configFile='" + configFile + '\'' +
                 '}';
     }
-}
+}

core/flamingock-processor/src/main/java/io/flamingock/core/processor/FlamingockAnnotationProcessor.java

@@ -220,9 +220,8 @@ public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment
         validateAllChangesAreMappedToStages(standardChangesMapByPackage, pipeline, flamingockAnnotation.strictStageMapping());
 
         Serializer serializer = new Serializer(processingEnv, logger);
-        String setup = flamingockAnnotation.setup().toString();
         String configFile = flamingockAnnotation.configFile();
-        FlamingockMetadata flamingockMetadata = new FlamingockMetadata(pipeline, setup, configFile);
+        FlamingockMetadata flamingockMetadata = new FlamingockMetadata(pipeline, configFile);
         serializer.serializeFullPipeline(flamingockMetadata);
 
         // Generate summary - count all changes from the final pipeline (code-based + template-based)

core/flamingock-processor/src/test/java/io/flamingock/core/processor/PipelinePreProcessorTest.java

@@ -513,7 +513,6 @@ public EnableFlamingock build() {
             return new EnableFlamingock() {
                 @Override public Stage[] stages() { return stages; }
                 @Override public String configFile() { return configFile; }
-                @Override public io.flamingock.api.SetupType setup() { return io.flamingock.api.SetupType.DEFAULT; }
 
                 @Override
                 public boolean strictStageMapping() {

platform-plugins/flamingock-springboot-integration/src/main/java/io/flamingock/springboot/FlamingockAutoConfiguration.java

@@ -19,62 +19,94 @@
 import io.flamingock.internal.core.builder.FlamingockFactory;
 import io.flamingock.internal.core.builder.AbstractChangeRunnerBuilder;
 import io.flamingock.internal.core.store.CommunityAuditStore;
-import io.flamingock.internal.core.runner.RunnerBuilder;
-import io.flamingock.internal.util.Constants;
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.boot.ApplicationRunner;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Profile;
 
 import java.util.List;
 
+/**
+ * Spring Boot auto-configuration for Flamingock.
+ *
+ * <p>The configuration behavior is controlled by the {@code flamingock.management-mode} property:</p>
+ * <ul>
+ *   <li>{@code APPLICATION_RUNNER} (default) - Spring creates, builds, and executes the runner as an ApplicationRunner</li>
+ *   <li>{@code INITIALIZING_BEAN} - Spring creates, builds, and executes the runner as an InitializingBean</li>
+ *   <li>{@code DEFERRED} - Spring creates the builder; the application controls execution</li>
+ *   <li>{@code UNMANAGED} - No beans are created; the application manages everything</li>
+ * </ul>
+ */
 @Configuration
 @ConditionalOnClass(name = "org.springframework.boot.SpringApplication")
-@ConditionalOnFlamingockEnabled
+@ConditionalOnExpression("!'${flamingock.management-mode:APPLICATION_RUNNER}'.toUpperCase().equals('UNMANAGED')")
 @EnableConfigurationProperties(SpringbootProperties.class)
 public class FlamingockAutoConfiguration {
 
+    /**
+     * Creates an ApplicationRunner that builds and executes Flamingock at application startup.
+     * Only created when management-mode is APPLICATION_RUNNER (the default).
+     */
     @Bean("flamingock-runner")
-    @Profile(Constants.NON_CLI_PROFILE)
-    @ConditionalOnExpression("'${flamingock.runner-type:ApplicationRunner}'.toLowerCase().equals('applicationrunner')")
-    public ApplicationRunner applicationRunner(RunnerBuilder runnerBuilder,
-                                               @Value("${flamingock.autorun:true}") boolean autoRun) {
-        return SpringbootUtil.toApplicationRunner(runnerBuilder, autoRun);
+    @ConditionalOnExpression("'${flamingock.management-mode:APPLICATION_RUNNER}'.toUpperCase().equals('APPLICATION_RUNNER')")
+    public ApplicationRunner applicationRunner(SpringbootProperties configurationProperties,
+                                               ApplicationContext springContext,
+                                               ApplicationEventPublisher applicationEventPublisher,
+                                               @Autowired(required = false) CommunityAuditStore auditStore,
+                                               List<TargetSystem> targetSystems) {
+        AbstractChangeRunnerBuilder<?, ?> builder = createBuilder(
+                configurationProperties, springContext, applicationEventPublisher, auditStore, targetSystems);
+        return SpringbootUtil.toApplicationRunner(builder);
     }
 
+    /**
+     * Creates an InitializingBean that builds and executes Flamingock during bean initialization.
+     * Only created when management-mode is INITIALIZING_BEAN.
+     */
     @Bean("flamingock-runner")
-    @Profile(Constants.NON_CLI_PROFILE)
-    @ConditionalOnExpression("'${flamingock.runner-type:null}'.toLowerCase().equals('initializingbean')")
-    public InitializingBean initializingBeanRunner(RunnerBuilder runnerBuilder,
-                                                   @Value("${flamingock.autorun:true}") boolean autoRun) {
-        return SpringbootUtil.toInitializingBean(runnerBuilder, autoRun);
+    @ConditionalOnExpression("'${flamingock.management-mode:APPLICATION_RUNNER}'.toUpperCase().equals('INITIALIZING_BEAN')")
+    public InitializingBean initializingBeanRunner(SpringbootProperties configurationProperties,
+                                                   ApplicationContext springContext,
+                                                   ApplicationEventPublisher applicationEventPublisher,
+                                                   @Autowired(required = false) CommunityAuditStore auditStore,
+                                                   List<TargetSystem> targetSystems) {
+        AbstractChangeRunnerBuilder<?, ?> builder = createBuilder(
+                configurationProperties, springContext, applicationEventPublisher, auditStore, targetSystems);
+        return SpringbootUtil.toInitializingBean(builder);
     }
 
+    /**
+     * Exposes the Flamingock builder for manual control over execution.
+     * Only created when management-mode is DEFERRED.
+     */
     @Bean("flamingock-builder")
-    @Profile(Constants.NON_CLI_PROFILE)
-    @ConditionalOnMissingBean(RunnerBuilder.class)
-    public AbstractChangeRunnerBuilder<?,?> flamingockBuilder(SpringbootProperties configurationProperties,
-                                           ApplicationContext springContext,
-                                           ApplicationEventPublisher applicationEventPublisher,
-                                           @Autowired(required = false) CommunityAuditStore auditStore,
-                                           List<TargetSystem> targetSystems) {
+    @ConditionalOnExpression("'${flamingock.management-mode:APPLICATION_RUNNER}'.toUpperCase().equals('DEFERRED')")
+    public AbstractChangeRunnerBuilder<?, ?> flamingockBuilder(SpringbootProperties configurationProperties,
+                                                               ApplicationContext springContext,
+                                                               ApplicationEventPublisher applicationEventPublisher,
+                                                               @Autowired(required = false) CommunityAuditStore auditStore,
+                                                               List<TargetSystem> targetSystems) {
+        return createBuilder(configurationProperties, springContext, applicationEventPublisher, auditStore, targetSystems);
+    }
 
-        AbstractChangeRunnerBuilder<?,?> builder = FlamingockFactory.getEditionAwareBuilder(
+    private AbstractChangeRunnerBuilder<?, ?> createBuilder(SpringbootProperties configurationProperties,
+                                                            ApplicationContext springContext,
+                                                            ApplicationEventPublisher applicationEventPublisher,
+                                                            CommunityAuditStore auditStore,
+                                                            List<TargetSystem> targetSystems) {
+        AbstractChangeRunnerBuilder<?, ?> builder = FlamingockFactory.getEditionAwareBuilder(
                         configurationProperties.getCoreConfiguration(),
                         configurationProperties.getCloudProperties(),
                         configurationProperties.getLocalConfiguration(),
                         auditStore
                 )
-                .addDependency(SpringRunnerType.class, configurationProperties.getRunnerType())
+                .addDependency(SpringbootManagementMode.class, configurationProperties.getManagementMode())
                 .addDependency(ApplicationContext.class, springContext)
                 .addDependency(ApplicationEventPublisher.class, applicationEventPublisher);
 
@@ -83,6 +115,5 @@ public AbstractChangeRunnerBuilder<?,?> flamingockBuilder(SpringbootProperties c
         }
 
         return builder;
-
     }
 }