Generate Maven and Gradle plugin code stubs

[andriy-dmytruk]

Description

There is a lot of maven and gradle-specific code for micronaut plugins that seems to be generateable. An example is micronaut openapi generators. We will also need plugins for JSON schema generations and possibly others in the future.

For openapi all the parameters are repeated 3 times currently:

• In the entrypoint to the openapi generator: https://github.com/micronaut-projects/micronaut-openapi/blob/6.13.x/openapi-generator/src/main/java/io/micronaut/openapi/generator/MicronautCodeGeneratorEntryPoint.java (there are separate options, option builders and their implementation to simplify the usage in plugins).
• In the maven plugin: https://github.com/micronaut-projects/micronaut-maven-plugin/blob/4.7.x/micronaut-maven-plugin/src/main/java/io/micronaut/maven/openapi/AbstractOpenApiMojo.java. The parameters are fed into the entrypoint and generation is called.
• In the gradle plugin task: https://github.com/micronaut-projects/micronaut-gradle-plugin/blob/master/openapi-plugin/src/main/java/io/micronaut/gradle/openapi/tasks/AbstractOpenApiGenerator.java. But also in the gradle plugin work action and extension.

Generating would have the advanatage that both versions would have consistent parameters and possibly similar API.

Generation description

Add a new module to generate plugins.

Given a configuration for an plugin executable, like

/**
 * Test configuration.
 *
 * @param packageName The package name to generate to
 */
@PluginConfig(mavenPropertyPrefix = "test")
public record TestConfig(
   @PluginParameter(mavenProperty = "packageName", required = true)
   String packageName,
   @PluginParameter(defaultValue = false)
   boolean serverGeneration,
   Map<String, String> additionalProperties,
   @PluginParameter(internal = true)
   String outputDirectory
) implements PluginExecutable {

   public void execute() {
       doWork(packageName, serverGeneration, additionalProperties, outputDirectory);
   }

}

we would want to generate plugin code stubs for reading these properties and calling the execute method.

Maven

we could generate maven Mojo:

public abstract class AbstractTestMojo extends AbstractMicronautMojo {

    /**
     * The package name to generate to.
     */
    @Parameter(property = "test.packageName", required = true)
    protected String packageName;

    @Parameter(defaultValue = "false")
    protected boolean serverGeneration;
    
    @Parameter
    protected Map<String, Object> additionalProperties;
    
    @Parameter(property = "test.enabled")
    protected boolean enabled;
    
    protected abstract String getOutputDirectory();
    
    @Override
    public void execute() throws MojoExecutionException, MojoFailureException {
        if (!isEnabled()) {
            getLog().debug(this.getClass().getSimpleName() + " is disabled");
            return;
        }
        
        new TestConfig(packageName, serverGeneration, additionalProperties, getOutputDirectory()).execute();
   }
}

The mojo is abstract, so that it can be extended with custom code like (the project logic is different for gradle and maven, so we have to keep it write it separate):

public class TestMojo extends AbstractTestMojo {
    @Parameter(defaultValue = "${project.build.directory}/generated-sources/openapi", required = true)
    protected File outputDirectory;
    
    @Parameter(defaultValue = "${project}", readonly = true)
    protected MavenProject project;
    
    protected String getOutputDirectory() {
        return outputDirectory;
    }
    
    public void execute() throws MojoExecutionException, MojoFailureException {
       super.execute();
       project.addCompileSourceRoot(outputDirectory.getAbsolutePath());
    }
}

Gradle

Generate a Gradle Task:

public abstract class  AbstractTestTask extends DefaultTask {
   
   /**
     * The package name to generate to.
     */
   @Input
   public abstract Property<String> getPackageName();
   
   @Input
   @Optional
   public abstract Property<Boolean> getServerGeneration();
   
   @Input
   @Optional
   public abstract MapProperty<String, Object> getAdditionalProperties();
   
   protected abstract Provider<String> getOutputDirectory();
  
   @Classpath
   public abstract ConfigurableFileCollection getClasspath();
  
   @Inject
   protected abstract WorkerExecutor getWorkerExecutor();
    
   @TaskAction
   public final void execute() {
        getWorkerExecutor().classLoaderIsolation(spec -> spec.getClasspath().from(getClasspath()))
            .submit(getWorkerAction(), params -> {
                params.getPackageName().set(getPackageName());
                params.getServerGeneration().set(getServerGeneration.orElse(false)); // default value here
                params.getAdditionalProperties().set(getAdditionalProperties.orElse(null)); // optional, so set null
                params.getOutputDirectory().set(getOutputDirectory().orElse(null)); // optional internal
            });
            
    }
    
    protected interface TestWorkActionParameters extends AbstractOpenApiWorkAction.OpenApiParameters {
        Property<String> getPackageName();
        Property<Boolean> getServerGeneration();
        MapProperty<String, Object> getAdditionalProperties();
        Property<String> getOutputDirectory();
    }
    
    public abstact TestWorkAction implements WorkAction<TestWorkActionParameters> {
    
        public void execute() {
            var parameters = getParameters();
            new TestConfig(getPackageName().get(), getServerGeneration.get(), getAdditionalProperties.get(), getoutputDirectory().get()).execute();
        }
    
    }

}

The task is abstract, so that it can be extended with custom code like (the project logic is different for gradle and maven, so we have to keep it write it separate):

@CacheableTask
public abstract class TestTask extends AbstractTestTask {
   
   @OutputDirectory
    public abstract DirectoryProperty getOutputDirectoryProp();
    
    public abstract Property<String> getOutputDirectory() {
        return getOutputDirectoryProp().map(dir -> dir.toAbsolutePath().toString());
    }

}

Additionally, gradle plugin will be written by user to extend the logic. For it an extension can be generated, as well:

public interface TestExtension {

   public abstract Property<String> getPackageName();
   
   @Optional
   public abstract Property<Boolean> getServerGeneration();
   
   @Optional
   public abstract MapProperty<String, Object> getAdditionalProperties();

}

@melix Could you take a look and give feedback if you think this could be possible? I see for OpenAPI there is more logic and it might be impossible to change now. But perhaps we can add it for new plugins.

cc @elifKurtay @graemerocher

[graemerocher]

looks like a good idea

[melix]

Sounds like a good idea. As always the devil is in the details, but we can probably try something with the new json schema plugins. We should make sure not to end in a chicken and egg situation though, that is the Maven/Gradle plugin depends on Micronaut Sourcegen to generate sources of its plugins, but also at runtime. I think whatever we generate shouldn't depend on Micronaut runtime at all (basically we should use the generator infrastructure, but not the runtime).