Rename missleading properties

src/main/java/tech/jhipster/lite/module/domain/JHipsterModuleContext.java

@@ -22,7 +22,7 @@ private JHipsterModuleContext(JHipsterModuleContextBuilder builder) {
   }
 
   private Indentation loadIndentation() {
-    Object contextIndentation = context.get(JHipsterModuleProperties.INDENTATION_PROPERTY);
+    Object contextIndentation = context.get(JHipsterModuleProperties.INDENTATION_PARAMETER);
 
     if (contextIndentation instanceof Integer integerIndentation) {
       return Indentation.from(integerIndentation);
@@ -59,11 +59,11 @@ private JHipsterModuleContextBuilder(JHipsterModuleBuilder module) {
     private Map<String, Object> initialContext(JHipsterModuleProperties properties) {
       HashMap<String, Object> init = new HashMap<>();
 
-      init.put(JHipsterModuleProperties.PROJECT_BASE_NAME_PROPERTY, properties.projectBaseName().get());
-      init.put(JHipsterModuleProperties.PROJECT_NAME_PROPERTY, properties.projectName().get());
-      init.put(JHipsterModuleProperties.BASE_PACKAGE_PROPERTY, properties.basePackage().get());
-      init.put(JHipsterModuleProperties.SERVER_PORT_PROPERTY, properties.serverPort().get());
-      init.put(JHipsterModuleProperties.INDENTATION_PROPERTY, properties.indentation().spacesCount());
+      init.put(JHipsterModuleProperties.PROJECT_BASE_NAME_PARAMETER, properties.projectBaseName().get());
+      init.put(JHipsterModuleProperties.PROJECT_NAME_PARAMETER, properties.projectName().get());
+      init.put(JHipsterModuleProperties.BASE_PACKAGE_PARAMETER, properties.basePackage().get());
+      init.put(JHipsterModuleProperties.SERVER_PORT_PARAMETER, properties.serverPort().get());
+      init.put(JHipsterModuleProperties.INDENTATION_PARAMETER, properties.indentation().spacesCount());
 
       return init;
     }

src/main/java/tech/jhipster/lite/module/domain/properties/JHipsterModuleParameters.java

@@ -0,0 +1,41 @@
+package tech.jhipster.lite.module.domain.properties;
+
+import java.util.Map;
+import tech.jhipster.lite.common.domain.JHipsterCollections;
+import tech.jhipster.lite.error.domain.Assert;
+
+record JHipsterModuleParameters(Map<String, Object> parameters) {
+  public JHipsterModuleParameters(Map<String, Object> parameters) {
+    this.parameters = JHipsterCollections.immutable(parameters);
+  }
+
+  <T> T getOrDefault(String key, T defaultValue, Class<T> clazz) {
+    Assert.notBlank("key", key);
+
+    if (!parameters.containsKey(key)) {
+      return defaultValue;
+    }
+
+    return get(key, clazz);
+  }
+
+  <T> T get(String key, Class<T> clazz) {
+    Assert.notBlank("key", key);
+
+    Object property = parameters.get(key);
+
+    if (property == null) {
+      throw new UnknownPropertyException(key);
+    }
+
+    if (clazz.isInstance(property)) {
+      return clazz.cast(property);
+    }
+
+    throw InvalidPropertyTypeException.builder().key(key).expectedType(clazz).actualType(property.getClass());
+  }
+
+  public Map<String, Object> get() {
+    return parameters();
+  }
+}

src/main/java/tech/jhipster/lite/module/domain/properties/JHipsterModuleProperties.java

@@ -1,43 +1,37 @@
 package tech.jhipster.lite.module.domain.properties;
 
 import java.util.Map;
-import tech.jhipster.lite.common.domain.JHipsterCollections;
 import tech.jhipster.lite.error.domain.Assert;
 import tech.jhipster.lite.module.domain.Indentation;
 
 public class JHipsterModuleProperties {
 
-  public static final String BASE_PACKAGE_PROPERTY = "packageName";
-  public static final String INDENTATION_PROPERTY = "prettierDefaultIndent";
-  public static final String PROJECT_NAME_PROPERTY = "projectName";
-  public static final String PROJECT_BASE_NAME_PROPERTY = "baseName";
-  public static final String SERVER_PORT_PROPERTY = "serverPort";
+  public static final String BASE_PACKAGE_PARAMETER = "packageName";
+  public static final String INDENTATION_PARAMETER = "prettierDefaultIndent";
+  public static final String PROJECT_NAME_PARAMETER = "projectName";
+  public static final String PROJECT_BASE_NAME_PARAMETER = "baseName";
+  public static final String SERVER_PORT_PARAMETER = "serverPort";
 
   private final JHipsterProjectFolder projectFolder;
   private final boolean commitModule;
-  private final Map<String, Object> properties;
+  private final JHipsterModuleParameters parameters;
+
   private final Indentation indentation;
   private final JHipsterBasePackage basePackage;
   private final JHipsterProjectName projectName;
   private final JHipsterProjectBaseName projectBaseName;
   private final JHipsterServerPort serverPort;
 
-  public JHipsterModuleProperties(String projectFolder, boolean commitModule, Map<String, Object> properties) {
-    this(new JHipsterProjectFolder(projectFolder), commitModule, properties);
-  }
-
-  public JHipsterModuleProperties(JHipsterProjectFolder projectFolder, boolean commitModule, Map<String, Object> properties) {
-    Assert.notNull("projectFolder", projectFolder);
-
-    this.projectFolder = projectFolder;
+  public JHipsterModuleProperties(String projectFolder, boolean commitModule, Map<String, Object> parameters) {
+    this.projectFolder = new JHipsterProjectFolder(projectFolder);
     this.commitModule = commitModule;
-    this.properties = JHipsterCollections.immutable(properties);
+    this.parameters = new JHipsterModuleParameters(parameters);
 
-    indentation = Indentation.from(getOrDefault(INDENTATION_PROPERTY, null, Integer.class));
-    basePackage = new JHipsterBasePackage(getOrDefault(BASE_PACKAGE_PROPERTY, null, String.class));
-    projectName = new JHipsterProjectName(getOrDefault(PROJECT_NAME_PROPERTY, null, String.class));
-    projectBaseName = new JHipsterProjectBaseName(getOrDefault(PROJECT_BASE_NAME_PROPERTY, null, String.class));
-    serverPort = new JHipsterServerPort(getOrDefault(SERVER_PORT_PROPERTY, null, Integer.class));
+    indentation = Indentation.from(this.parameters.getOrDefault(INDENTATION_PARAMETER, null, Integer.class));
+    basePackage = new JHipsterBasePackage(this.parameters.getOrDefault(BASE_PACKAGE_PARAMETER, null, String.class));
+    projectName = new JHipsterProjectName(this.parameters.getOrDefault(PROJECT_NAME_PARAMETER, null, String.class));
+    projectBaseName = new JHipsterProjectBaseName(this.parameters.getOrDefault(PROJECT_BASE_NAME_PARAMETER, null, String.class));
+    serverPort = new JHipsterServerPort(this.parameters.getOrDefault(SERVER_PORT_PARAMETER, null, Integer.class));
   }
 
   public JHipsterProjectFolder projectFolder() {
@@ -49,29 +43,29 @@ public boolean commitNeeded() {
   }
 
   public String getString(String key) {
-    return get(key, String.class);
+    return parameters.get(key, String.class);
   }
 
   public String getOrDefaultString(String key, String defaultValue) {
     Assert.notBlank("defaultValue", defaultValue);
 
-    return getOrDefault(key, defaultValue, String.class);
+    return parameters.getOrDefault(key, defaultValue, String.class);
   }
 
   public boolean getBoolean(String key) {
-    return get(key, Boolean.class);
+    return parameters.get(key, Boolean.class);
   }
 
   public boolean getOrDefaultBoolean(String key, boolean defaultValue) {
-    return getOrDefault(key, defaultValue, Boolean.class);
+    return parameters.getOrDefault(key, defaultValue, Boolean.class);
   }
 
   public int getInteger(String key) {
-    return get(key, Integer.class);
+    return parameters.get(key, Integer.class);
   }
 
   public int getOrDefaultInteger(String key, int defaultValue) {
-    return getOrDefault(key, defaultValue, Integer.class);
+    return parameters.getOrDefault(key, defaultValue, Integer.class);
   }
 
   public Indentation indentation() {
@@ -98,33 +92,7 @@ public JHipsterServerPort serverPort() {
     return serverPort;
   }
 
-  private <T> T getOrDefault(String key, T defaultValue, Class<T> clazz) {
-    Assert.notBlank("key", key);
-
-    if (!properties.containsKey(key)) {
-      return defaultValue;
-    }
-
-    return get(key, clazz);
-  }
-
-  private <T> T get(String key, Class<T> clazz) {
-    Assert.notBlank("key", key);
-
-    Object property = properties.get(key);
-
-    if (property == null) {
-      throw new UnknownPropertyException(key);
-    }
-
-    if (clazz.isInstance(property)) {
-      return clazz.cast(property);
-    }
-
-    throw InvalidPropertyTypeException.builder().key(key).expectedType(clazz).actualType(property.getClass());
-  }
-
-  public Map<String, Object> get() {
-    return properties;
+  public Map<String, Object> getParameters() {
+    return parameters.get();
   }
 }

src/main/java/tech/jhipster/lite/module/domain/resource/JHipsterModulePropertyDefinition.java

@@ -30,39 +30,39 @@ private JHipsterModulePropertyDefinition(JHipsterModulePropertyDefinitionBuilder
   }
 
   public static JHipsterModulePropertyDefinition basePackageProperty() {
-    return mandatoryStringProperty(JHipsterModuleProperties.BASE_PACKAGE_PROPERTY)
+    return mandatoryStringProperty(JHipsterModuleProperties.BASE_PACKAGE_PARAMETER)
       .description("Base java package")
       .example("tech.jhipster.lite")
       .order(-300)
       .build();
   }
 
   public static JHipsterModulePropertyDefinition projectNameProperty() {
-    return mandatoryStringProperty(JHipsterModuleProperties.PROJECT_NAME_PROPERTY)
+    return mandatoryStringProperty(JHipsterModuleProperties.PROJECT_NAME_PARAMETER)
       .description("Project full name")
       .example("JHipster Project")
       .order(-200)
       .build();
   }
 
   static JHipsterModulePropertyDefinition projectBaseNameProperty() {
-    return mandatoryStringProperty(JHipsterModuleProperties.PROJECT_BASE_NAME_PROPERTY)
+    return mandatoryStringProperty(JHipsterModuleProperties.PROJECT_BASE_NAME_PARAMETER)
       .description("Project short name (only letters and numbers)")
       .example("jhipster")
       .order(-100)
       .build();
   }
 
   static JHipsterModulePropertyDefinition serverPortProperty() {
-    return mandatoryIntegerProperty(JHipsterModuleProperties.SERVER_PORT_PROPERTY)
+    return mandatoryIntegerProperty(JHipsterModuleProperties.SERVER_PORT_PARAMETER)
       .description("Server port")
       .example("8080")
       .order(-50)
       .build();
   }
 
   public static JHipsterModulePropertyDefinition indentationProperty() {
-    return optionalIntegerProperty(JHipsterModuleProperties.INDENTATION_PROPERTY)
+    return optionalIntegerProperty(JHipsterModuleProperties.INDENTATION_PARAMETER)
       .description("Number of spaces in indentation")
       .example("2")
       .order(500)

src/main/java/tech/jhipster/lite/module/infrastructure/primary/RestJHipsterModuleProperties.java

@@ -1,6 +1,7 @@
 package tech.jhipster.lite.module.infrastructure.primary;
 
 import com.fasterxml.jackson.annotation.JsonProperty;
+import io.swagger.v3.oas.annotations.media.Schema;
 import java.util.Map;
 import tech.jhipster.lite.error.domain.Assert;
 import tech.jhipster.lite.module.domain.properties.JHipsterModuleProperties;
@@ -10,29 +11,44 @@ class RestJHipsterModuleProperties {
 
   private final String projectFolder;
   private final boolean commit;
-  private final Map<String, Object> properties;
+  private final Map<String, Object> parameters;
 
   RestJHipsterModuleProperties(
     @JsonProperty("projectFolder") String projectFolder,
     @JsonProperty("commit") boolean commit,
-    @JsonProperty("properties") Map<String, Object> properties
+    @JsonProperty("parameters") Map<String, Object> parameters
   ) {
     this.projectFolder = projectFolder;
     this.commit = commit;
-    this.properties = properties;
+    this.parameters = parameters;
   }
 
   public JHipsterModuleProperties toDomain(ProjectFolder jHipsterProjectFolderFactory) {
     Assert.notNull("jHipsterProjectFolderFactory", jHipsterProjectFolderFactory);
 
     assertValidProjectFolder(jHipsterProjectFolderFactory);
 
-    return new JHipsterModuleProperties(projectFolder, commit, properties);
+    return new JHipsterModuleProperties(getProjectFolder(), isCommit(), getParameters());
   }
 
   private void assertValidProjectFolder(ProjectFolder jHipsterProjectFolderFactory) {
     if (jHipsterProjectFolderFactory.isInvalid(projectFolder)) {
       throw new InvalidProjectFolderException();
     }
   }
+
+  @Schema(description = "Path to the project folder", required = true)
+  public String getProjectFolder() {
+    return projectFolder;
+  }
+
+  @Schema(description = "True to commit each module application, false otherwise", required = true)
+  public boolean isCommit() {
+    return commit;
+  }
+
+  @Schema(description = "Parameters to apply on modules")
+  public Map<String, Object> getParameters() {
+    return parameters;
+  }
 }

src/main/java/tech/jhipster/lite/project/domain/history/ModuleParameters.java

@@ -0,0 +1,28 @@
+package tech.jhipster.lite.project.domain.history;
+
+import java.util.HashMap;
+import java.util.Map;
+import tech.jhipster.lite.common.domain.JHipsterCollections;
+import tech.jhipster.lite.error.domain.Assert;
+
+public record ModuleParameters(Map<String, Object> parameters) {
+  public static final ModuleParameters EMPTY = new ModuleParameters(Map.of());
+
+  public ModuleParameters(Map<String, Object> parameters) {
+    this.parameters = JHipsterCollections.immutable(parameters);
+  }
+
+  public Map<String, Object> get() {
+    return parameters();
+  }
+
+  public ModuleParameters merge(ModuleParameters other) {
+    Assert.notNull("other", other);
+
+    Map<String, Object> mergedParameters = new HashMap<>();
+    mergedParameters.putAll(parameters);
+    mergedParameters.putAll(other.parameters);
+
+    return new ModuleParameters(mergedParameters);
+  }
+}