Adding Json Schema Generator Plugin

buildSrc/src/main/groovy/io.micronaut.internal.build.gradle-plugin.gradle

@@ -14,7 +14,7 @@ pluginManager.apply(io.micronaut.build.MicronautQualityChecksParticipantPlugin)
 repositories {
     mavenCentral()
     gradlePluginPortal()
-//    maven { url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/") }
+    maven { url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/") }
 }
 
 project.extensions.create("micronautPlugins", MicronautPluginExtension, gradlePlugin)

gradle/libs.versions.toml

@@ -17,6 +17,7 @@ micronaut-platform = "4.7.4" # This is the platform version, used in our tests
 micronaut-aot = "2.6.0"
 micronaut-testresources = "2.7.2"
 micronaut-openapi = "6.13.2"
+micronaut-jsonschema = "1.3.1-SNAPSHOT" # TODO: update to include new generation plugin
 
 [libraries]
 # Core
@@ -45,6 +46,8 @@ micronaut-openapi-generator = { module = "io.micronaut.openapi:micronaut-openapi
 
 micronaut-testresources = { module = "io.micronaut.testresources:micronaut-test-resources-build-tools", version.ref = "micronaut-testresources" }
 
+micronaut-jsonschema-generator = { module = "io.micronaut.jsonschema:micronaut-json-schema-generator", version.ref = "micronaut-jsonschema" }
+
 mockserver-netty = { module = "org.mock-server:mockserver-netty", version.ref = "mockserver" }
 mockserver-client = { module = "org.mock-server:mockserver-client-java", version.ref = "mockserver" }
 

jsonschema-plugin/build.gradle

@@ -0,0 +1,15 @@
+plugins {
+    id "io.micronaut.internal.build.gradle-plugin"
+}
+
+description = "Micronaut JSON Schema Gradle plugin"
+
+micronautPlugins {
+    register('jsonschema', 'io.micronaut.gradle.jsonschema.MicronautJSONSchemaPlugin', 'Micronaut JSON Schema Plugin')
+}
+
+dependencies {
+    compileOnly libs.micronaut.jsonschema.generator
+    implementation projects.micronautMinimalPlugin
+    testImplementation testFixtures(projects.micronautMinimalPlugin)
+}

jsonschema-plugin/src/main/java/io/micronaut/gradle/jsonschema/DefaultJSONSchemaExtension.java

@@ -0,0 +1,124 @@
+package io.micronaut.gradle.jsonschema;
+
+import io.micronaut.gradle.PluginsHelper;
+import io.micronaut.gradle.jsonschema.tasks.AbstractJsonSchemaGenerator;
+import io.micronaut.gradle.jsonschema.tasks.JsonSchemaFileGenerator;
+import io.micronaut.gradle.jsonschema.tasks.JsonSchemaFolderGenerator;
+import io.micronaut.gradle.jsonschema.tasks.JsonSchemaUrlGenerator;
+import org.gradle.api.Action;
+import org.gradle.api.Project;
+import org.gradle.api.artifacts.Configuration;
+import org.gradle.api.file.Directory;
+import org.gradle.api.file.SourceDirectorySet;
+import org.gradle.api.provider.Provider;
+import org.gradle.api.tasks.SourceSet;
+import org.gradle.api.tasks.SourceSetContainer;
+import org.gradle.api.tasks.TaskProvider;
+
+import javax.inject.Inject;
+import java.io.File;
+import java.util.List;
+import java.util.function.Consumer;
+
+import static org.codehaus.groovy.runtime.StringGroovyMethods.capitalize;
+
+public abstract class DefaultJSONSchemaExtension implements JSONSchemaExtension {
+    private final Project project;
+    private final Configuration classpath;
+
+    @Inject
+    public DefaultJSONSchemaExtension(Project project, Configuration classpath) {
+        this.project = project;
+        this.classpath = classpath;
+    }
+
+    @Override
+    public void url(String url, Action<JsonSchemaSpec> spec) {
+        var urlSpec = project.getObjects().newInstance(JsonSchemaURLSpec.class);
+        configureCommonExtensionDefaults(urlSpec);
+        urlSpec.getInputUrl().convention("");
+        spec.execute(urlSpec);
+        var generator = project.getTasks().register(generateTaskName(url.substring(url.lastIndexOf("/") + 1)), JsonSchemaUrlGenerator.class, task -> {
+            task.setDescription("Generates source files from an URL of a JSON Schema file");
+            configureCommonProperties(task, urlSpec);
+            task.getJsonURL().convention(url);
+        });
+        addSourceDir(generator);
+    }
+
+    @Override
+    public void fromFile(File file, Action<JsonSchemaSpec> spec) {
+        var specInstance = file.isDirectory() ? JsonSchemaFolderSpec.class : JsonSchemaFileSpec.class;
+        var fileSpec = project.getObjects().newInstance(specInstance);
+        configureCommonExtensionDefaults(fileSpec);
+        spec.execute(fileSpec);
+        if (file.isDirectory()) {
+            var regularDirProperty = project.getObjects().directoryProperty();
+            var generator = project.getTasks().register(generateTaskName(file.getName()), JsonSchemaFolderGenerator.class, task -> {
+                task.setDescription("Generates source files from an URL of a JSON Schema file");
+                configureCommonProperties(task, fileSpec);
+                task.getInputDirectory().convention(regularDirProperty.fileValue(file));
+            });
+            addSourceDir(generator);
+        } else {
+            var regularFileProperty = project.getObjects().fileProperty();
+            var generator = project.getTasks().register(generateTaskName(file.getName()), JsonSchemaFileGenerator.class, task -> {
+                task.setDescription("Generates source files from an URL of a JSON Schema file");
+                configureCommonProperties(task, fileSpec);
+                task.getInputFile().convention(regularFileProperty.fileValue(file));
+            });
+            addSourceDir(generator);
+        }
+    }
+
+    private void configureCommonExtensionDefaults(JsonSchemaSpec spec) {
+        spec.getAcceptedUrlPatterns().convention(List.of());
+        spec.getLang().convention("JAVA");
+        spec.getOutputPackageName().convention("io.micronaut.jsonschema.generated");
+        spec.getOutputFileName().convention("");
+        spec.getOutputDirectory().convention(project.getLayout().getBuildDirectory().dir("generated/jsonschema/"));
+    }
+
+    private void configureCommonProperties(AbstractJsonSchemaGenerator<?, ?> task, JsonSchemaSpec schemaSpec) {
+        task.getClasspath().from(classpath);
+        task.getOutputDirectory().convention(schemaSpec.getOutputDirectory().dir(task.getName()));
+        task.getPackageName().convention(schemaSpec.getOutputPackageName());
+        task.getOutputFileName().convention(schemaSpec.getOutputFileName());
+        task.getAcceptedUrlPatterns().convention(schemaSpec.getAcceptedUrlPatterns());
+        task.getLanguage().convention(schemaSpec.getLang());
+    }
+
+    private void addSourceDir(TaskProvider<? extends AbstractJsonSchemaGenerator<?, ?>> generator) {
+        withJavaSourceSets(sourceSets -> {
+            var javaMain = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).getJava();
+            javaMain.srcDir(generator.map(DefaultJSONSchemaExtension::mainSrcDir));
+            project.getPluginManager().withPlugin("org.jetbrains.kotlin.jvm", unused -> {
+                var ext = sourceSets.getByName(SourceSet.MAIN_SOURCE_SET_NAME).getExtensions().getByName("kotlin");
+                if (ext instanceof SourceDirectorySet kotlinMain) {
+                    kotlinMain.srcDir(generator.map(d -> DefaultJSONSchemaExtension.mainSrcDir(d, "kotlin")));
+                }
+            });
+        });
+    }
+
+    private void withJava(Runnable runnable) {
+        project.getPlugins().withId("java", unused -> runnable.run());
+    }
+
+    private void withJavaSourceSets(Consumer<? super SourceSetContainer> consumer) {
+        project.getPlugins().withId("java", unused -> consumer.accept(PluginsHelper.findSourceSets(project)));
+    }
+
+    private static Provider<Directory> mainSrcDir(AbstractJsonSchemaGenerator<?, ?> t, String language) {
+        return t.getOutputDirectory().dir("src/main/" + language);
+    }
+
+    private static Provider<Directory> mainSrcDir(AbstractJsonSchemaGenerator<?, ?> t) {
+        return mainSrcDir(t, "java");
+    }
+
+    private static String generateTaskName(String name) {
+        int endIndex = name.contains(".") ? name.indexOf(".") : name.length();
+        return "generatingSourcesFrom" + capitalize(name.substring(0, endIndex));
+    }
+}

jsonschema-plugin/src/main/java/io/micronaut/gradle/jsonschema/JSONSchemaExtension.java

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2003-2021 the original author or authors.
+ *
+ * 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
+ *
+ *     https://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.micronaut.gradle.jsonschema;
+
+import org.gradle.api.Action;
+import org.gradle.api.provider.Property;
+
+import java.io.File;
+
+/**
+ * Configures the JSON Schema code generator.
+ */
+public interface JSONSchemaExtension {
+    /**
+     * The version of the Micronaut JSON Schema generator.
+     * @return the version
+     */
+    Property<String> getVersion();
+
+    /**
+     * Configures generation, given a schema URL.
+     * @param url the url string of a json schema
+     * @param spec configuration for the server generation
+     */
+    void url(String url, Action<JsonSchemaSpec> spec);
+
+    /**
+     * Configures generation, given a schema file.
+     * @param file the json file
+     * @param spec configuration for the server generation
+     */
+    void fromFile(File file, Action<JsonSchemaSpec> spec);
+}

jsonschema-plugin/src/main/java/io/micronaut/gradle/jsonschema/JsonSchemaFileSpec.java

@@ -0,0 +1,9 @@
+package io.micronaut.gradle.jsonschema;
+
+import org.gradle.api.provider.Property;
+
+import java.io.File;
+
+public interface JsonSchemaFileSpec extends JsonSchemaSpec {
+    Property<File> getInputFile();
+}

jsonschema-plugin/src/main/java/io/micronaut/gradle/jsonschema/JsonSchemaFolderSpec.java

@@ -0,0 +1,9 @@
+package io.micronaut.gradle.jsonschema;
+
+import org.gradle.api.provider.Property;
+
+import java.io.File;
+
+public interface JsonSchemaFolderSpec extends JsonSchemaSpec {
+    Property<File> getInputFolder();
+}

jsonschema-plugin/src/main/java/io/micronaut/gradle/jsonschema/JsonSchemaSpec.java

@@ -0,0 +1,17 @@
+package io.micronaut.gradle.jsonschema;
+
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.provider.ListProperty;
+import org.gradle.api.provider.Property;
+
+public interface JsonSchemaSpec {
+    Property<String> getLang();
+
+    ListProperty<String> getAcceptedUrlPatterns();
+
+    Property<String> getOutputFileName();
+
+    Property<String> getOutputPackageName();
+
+    DirectoryProperty getOutputDirectory();
+}

jsonschema-plugin/src/main/java/io/micronaut/gradle/jsonschema/JsonSchemaURLSpec.java

@@ -0,0 +1,7 @@
+package io.micronaut.gradle.jsonschema;
+
+import org.gradle.api.provider.Property;
+
+public interface JsonSchemaURLSpec extends JsonSchemaSpec {
+    Property<String> getInputUrl();
+}

jsonschema-plugin/src/main/java/io/micronaut/gradle/jsonschema/MicronautJSONSchemaPlugin.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2003-2021 the original author or authors.
+ *
+ * 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
+ *
+ *     https://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.micronaut.gradle.jsonschema;
+
+import io.micronaut.gradle.MicronautBasePlugin;
+import io.micronaut.gradle.PluginsHelper;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+
+import java.util.List;
+
+public class MicronautJSONSchemaPlugin implements Plugin<Project> {
+
+    public static final String JSON_SCHEMA_GENERATOR_CONFIGURATION = "jsonSchemaGenerator";
+    public static final String JSON_SCHEMA_GENERATOR_CLASSPATH_CONFIGURATION = "jsonSchemaGeneratorClasspath";
+
+    @Override
+    public void apply(Project project) {
+        project.getPluginManager().apply(MicronautBasePlugin.class);
+        createJSONSchemaExtension(project);
+    }
+
+    private static void createJSONSchemaExtension(Project project) {
+        var micronautExtension = PluginsHelper.findMicronautExtension(project);
+        var generatorDependencies = project.getConfigurations().create(JSON_SCHEMA_GENERATOR_CONFIGURATION, conf -> {
+            conf.setCanBeResolved(false);
+            conf.setCanBeConsumed(false);
+            conf.setDescription("The JSON Schema Generator dependencies");
+        });
+        var generatorClasspath = project.getConfigurations().create(JSON_SCHEMA_GENERATOR_CLASSPATH_CONFIGURATION, conf -> {
+            conf.setCanBeResolved(true);
+            conf.setCanBeConsumed(false);
+            conf.setDescription("The JSON Schema Generator classpath");
+            conf.extendsFrom(generatorDependencies);
+        });
+        var jsonSchemaExtension = micronautExtension.getExtensions().create(JSONSchemaExtension.class, "jsonschema", DefaultJSONSchemaExtension.class, project, generatorClasspath);
+        jsonSchemaExtension.getVersion().convention("1.3.1-SNAPSHOT"); //TODO: update after released version of json schema
+        generatorDependencies.getDependencies().addAllLater(jsonSchemaExtension.getVersion().map(version ->
+            List.of(project.getDependencies().create("io.micronaut.jsonschema:micronaut-json-schema-generator:" + version))
+        ));
+    }
+}

jsonschema-plugin/src/main/java/io/micronaut/gradle/jsonschema/tasks/AbstractJsonSchemaGenerator.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2003-2021 the original author or authors.
+ *
+ * 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
+ *
+ *     https://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.micronaut.gradle.jsonschema.tasks;
+
+import org.gradle.api.DefaultTask;
+import org.gradle.api.file.ConfigurableFileCollection;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.provider.ListProperty;
+import org.gradle.api.provider.Property;
+import org.gradle.api.tasks.Classpath;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Internal;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.TaskAction;
+import org.gradle.workers.WorkerExecutor;
+
+import javax.inject.Inject;
+
+public abstract class AbstractJsonSchemaGenerator<W extends AbstractJsonSchemaWorkAction<P>, P extends AbstractJsonSchemaWorkAction.JsonSchemaParameters> extends DefaultTask {
+
+    @Classpath
+    public abstract ConfigurableFileCollection getClasspath();
+
+    @Input
+    @Optional
+    public abstract Property<String> getLanguage();
+
+    @OutputDirectory
+    public abstract DirectoryProperty getOutputDirectory();
+
+    @Input
+    @Optional
+    public abstract Property<String> getPackageName();
+
+    @Input
+    @Optional
+    public abstract Property<String> getOutputFileName();
+
+    @Input
+    @Optional
+    public abstract ListProperty<String> getAcceptedUrlPatterns();
+
+    @Inject
+    protected abstract WorkerExecutor getWorkerExecutor();
+
+    @Internal
+    protected abstract Class<W> getWorkerAction();
+
+    protected abstract void configureWorkerParameters(P params);
+
+    @TaskAction
+    public final void execute() {
+        getWorkerExecutor().classLoaderIsolation(spec -> spec.getClasspath().from(getClasspath()))
+                .submit(getWorkerAction(), params -> {
+                    params.getLang().set(getLanguage());
+                    params.getAcceptedUrlPatterns().set(getAcceptedUrlPatterns());
+                    params.getPackageName().set(getPackageName());
+                    params.getOutputFileName().set(getOutputFileName());
+                    params.getOutputDirectory().set(getOutputDirectory());
+                    configureWorkerParameters(params);
+                });
+    }
+}
+