requiredAnnotations parameter (#443)

- opposite of `optionalAnnotations`
- properties optional by default
- properties required when annotated with specified annotation

Author: vojtechhabarta

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/Settings.java

@@ -110,6 +110,7 @@ public class Settings {
     public List<Class<? extends Annotation>> includePropertyAnnotations = new ArrayList<>();
     public List<Class<? extends Annotation>> excludePropertyAnnotations = new ArrayList<>();
     public List<Class<? extends Annotation>> optionalAnnotations = new ArrayList<>();
+    public List<Class<? extends Annotation>> requiredAnnotations = new ArrayList<>();
     public List<Class<? extends Annotation>> nullableAnnotations = new ArrayList<>();
     public boolean generateInfoJson = false;
     public boolean generateNpmPackageJson = false;
@@ -237,6 +238,10 @@ public void loadOptionalAnnotations(ClassLoader classLoader, List<String> option
         this.optionalAnnotations = loadClasses(classLoader, optionalAnnotations, Annotation.class);
     }
 
+    public void loadRequiredAnnotations(ClassLoader classLoader, List<String> requiredAnnotations) {
+        this.requiredAnnotations = loadClasses(classLoader, requiredAnnotations, Annotation.class);
+    }
+
     public void loadNullableAnnotations(ClassLoader classLoader, List<String> nullableAnnotations) {
         this.nullableAnnotations = loadClasses(classLoader, nullableAnnotations, Annotation.class);
     }
@@ -345,6 +350,9 @@ public void validate() {
                         annotation.getName()));
             }
         }
+        if (!optionalAnnotations.isEmpty() && !requiredAnnotations.isEmpty()) {
+            throw new RuntimeException("Only one of 'optionalAnnotations' and 'requiredAnnotations' can be used at the same time.");
+        }
         for (Class<? extends Annotation> annotation : nullableAnnotations) {
             final Target target = annotation.getAnnotation(Target.class);
             final List<ElementType> elementTypes = target != null ? Arrays.asList(target.value()) : Arrays.asList();

typescript-generator-core/src/main/java/cz/habarta/typescript/generator/parser/ModelParser.java

@@ -159,7 +159,12 @@ protected boolean isPropertyOptional(PropertyMember propertyMember) {
             return true;
         }
         if (settings.optionalProperties == null || settings.optionalProperties == OptionalProperties.useSpecifiedAnnotations) {
-            return Utils.hasAnyAnnotation(propertyMember::getAnnotation, settings.optionalAnnotations);
+            if (!settings.optionalAnnotations.isEmpty()) {
+                return Utils.hasAnyAnnotation(propertyMember::getAnnotation, settings.optionalAnnotations);
+            }
+            if (!settings.requiredAnnotations.isEmpty()) {
+                return !Utils.hasAnyAnnotation(propertyMember::getAnnotation, settings.requiredAnnotations);
+            }
         }
         return false;
     }

typescript-generator-core/src/test/java/cz/habarta/typescript/generator/OptionalAnnotationTest.java

@@ -10,6 +10,7 @@
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
+import java.util.Arrays;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -161,4 +162,50 @@ public Long getSelectedId() {
     public @interface TypescriptOptional {
     }
 
+    @Test
+    public void testOptionalAndRequiredProperty() {
+        {
+            final Settings settings = TestUtils.settings();
+            settings.optionalAnnotations = Arrays.asList();
+            settings.requiredAnnotations = Arrays.asList();
+            final String output = new TypeScriptGenerator(settings).generateTypeScript(Input.from(ClassWithMarkedField.class));
+            Assert.assertTrue(output.contains("a: string;"));
+            Assert.assertTrue(output.contains("b: string;"));
+        }
+        {
+            final Settings settings = TestUtils.settings();
+            settings.optionalAnnotations = Arrays.asList(MarkerAnnotation.class);
+            settings.requiredAnnotations = Arrays.asList();
+            final String output = new TypeScriptGenerator(settings).generateTypeScript(Input.from(ClassWithMarkedField.class));
+            Assert.assertTrue(output.contains("a: string;"));
+            Assert.assertTrue(output.contains("b?: string;"));
+        }
+        {
+            final Settings settings = TestUtils.settings();
+            settings.optionalAnnotations = Arrays.asList();
+            settings.requiredAnnotations = Arrays.asList(MarkerAnnotation.class);
+            final String output = new TypeScriptGenerator(settings).generateTypeScript(Input.from(ClassWithMarkedField.class));
+            Assert.assertTrue(output.contains("a?: string;"));
+            Assert.assertTrue(output.contains("b: string;"));
+        }
+        try {
+            final Settings settings = TestUtils.settings();
+            settings.optionalAnnotations = Arrays.asList(MarkerAnnotation.class);
+            settings.requiredAnnotations = Arrays.asList(MarkerAnnotation.class);
+            final String output = new TypeScriptGenerator(settings).generateTypeScript(Input.from(ClassWithMarkedField.class));
+            Assert.fail();
+        } catch (Exception e) {
+            // expected - optionalAnnotations and requiredAnnotations cannot be used together
+        }
+    }
+
+    public class ClassWithMarkedField {
+        public String a;
+        @MarkerAnnotation public String b;
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface MarkerAnnotation {
+    }
+
 }

typescript-generator-gradle-plugin/src/main/java/cz/habarta/typescript/generator/gradle/GenerateTask.java

@@ -103,6 +103,7 @@ public class GenerateTask extends DefaultTask {
     public List<String> extensions;
     public List<Settings.ConfiguredExtension> extensionsWithConfiguration;
     public List<String> optionalAnnotations;
+    public List<String> requiredAnnotations;
     public List<String> nullableAnnotations;
     public boolean generateInfoJson;
     public boolean generateNpmPackageJson;
@@ -205,6 +206,7 @@ public void generate() throws Exception {
             settings.loadIncludePropertyAnnotations(classLoader, includePropertyAnnotations);
             settings.loadExcludePropertyAnnotations(classLoader, excludePropertyAnnotations);
             settings.loadOptionalAnnotations(classLoader, optionalAnnotations);
+            settings.loadRequiredAnnotations(classLoader, requiredAnnotations);
             settings.loadNullableAnnotations(classLoader, nullableAnnotations);
             settings.generateInfoJson = generateInfoJson;
             settings.generateNpmPackageJson = generateNpmPackageJson;

typescript-generator-maven-plugin/src/main/java/cz/habarta/typescript/generator/maven/GenerateMojo.java

@@ -225,7 +225,7 @@ public class GenerateMojo extends AbstractMojo {
      * Specifies how properties are defined to be optional.
      * Supported values are:
      * <ul>
-     * <li><code>useSpecifiedAnnotations</code> - annotations specified using {@link #optionalAnnotations} parameter</li>
+     * <li><code>useSpecifiedAnnotations</code> - annotations specified using {@link #optionalAnnotations} or {@link #requiredAnnotations} parameter</li>
      * <li><code>useLibraryDefinition</code> - examples: <code>@JsonProperty(required = false)</code> when using <code>jackson2</code> library
      *   or <code>@XmlElement(required = false)</code> when using <code>jaxb</code> library</li>
      * <li><code>all</code> - all properties are optional</li>
@@ -625,11 +625,19 @@ public class GenerateMojo extends AbstractMojo {
      * The presence of any annotation in this list on a JSON property will cause
      * the typescript-generator to treat that property as optional when generating
      * the corresponding TypeScript interface.
-     * Example optional annotation: <code>javax.annotation.Nullable</code>
+     * Example optional annotation: <code>javax.annotation.Nullable</code>.
+     * This parameter is "opposite" of {@link #requiredAnnotations}, only one of them could be used.
      */
     @Parameter
     private List<String> optionalAnnotations;
 
+    /**
+     * Properties will be treated as optional except those annotated with any of specified annotations.
+     * This parameter is "opposite" of {@link #optionalAnnotations}, only one of them could be used.
+     */
+    @Parameter
+    private List<String> requiredAnnotations;
+
     /**
      * When any of specified annotations is used on a Java type typescript-generator treats this type as nullable.
      * For example Java type <code>List&lt;@Nullable String&gt;</code>
@@ -836,6 +844,7 @@ public void execute() {
             settings.loadIncludePropertyAnnotations(classLoader, includePropertyAnnotations);
             settings.loadExcludePropertyAnnotations(classLoader, excludePropertyAnnotations);
             settings.loadOptionalAnnotations(classLoader, optionalAnnotations);
+            settings.loadRequiredAnnotations(classLoader, requiredAnnotations);
             settings.loadNullableAnnotations(classLoader, nullableAnnotations);
             settings.generateInfoJson = generateInfoJson;
             settings.generateNpmPackageJson = generateNpmPackageJson;