Introduce rest params and included record params to the json model

flow-model-generator/modules/flow-model-generator-core/src/main/java/io/ballerina/flowmodelgenerator/core/db/DatabaseManager.java

@@ -18,9 +18,9 @@
 
 package io.ballerina.flowmodelgenerator.core.db;
 
-import io.ballerina.compiler.api.symbols.ParameterKind;
 import io.ballerina.flowmodelgenerator.core.db.model.Function;
 import io.ballerina.flowmodelgenerator.core.db.model.FunctionResult;
+import io.ballerina.flowmodelgenerator.core.db.model.Parameter;
 import io.ballerina.flowmodelgenerator.core.db.model.ParameterResult;
 
 import java.io.IOException;
@@ -33,6 +33,7 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -224,7 +225,6 @@ public List<FunctionResult> searchFunctions(Map<String, String> queryMap, Functi
                         rs.getString("resource_path"),
                         Function.Kind.valueOf(rs.getString("kind")),
                         rs.getInt("return_error")
-
                 );
                 functionResults.add(functionResult);
             }
@@ -385,6 +385,7 @@ public List<ParameterResult> getFunctionParameters(int functionId) {
                 "p.name, " +
                 "p.type, " +
                 "p.kind, " +
+                "p.optional, " +
                 "p.default_value, " +
                 "p.description " +
                 "FROM Parameter p " +
@@ -399,9 +400,10 @@ public List<ParameterResult> getFunctionParameters(int functionId) {
                         rs.getInt("parameter_id"),
                         rs.getString("name"),
                         rs.getString("type"),
-                        ParameterKind.valueOf(rs.getString("kind")),
+                        Parameter.Kind.valueOf(rs.getString("kind")),
                         rs.getString("default_value"),
-                        rs.getString("description")
+                        rs.getString("description"),
+                        rs.getInt("optional")
                 );
                 parameterResults.add(parameterResult);
             }
@@ -412,6 +414,42 @@ public List<ParameterResult> getFunctionParameters(int functionId) {
         }
     }
 
+    public LinkedHashMap<String, ParameterResult> getFunctionParametersAsMap(int functionId) {
+        String sql = "SELECT " +
+                "p.parameter_id, " +
+                "p.name, " +
+                "p.type, " +
+                "p.kind, " +
+                "p.optional, " +
+                "p.default_value, " +
+                "p.description " +
+                "FROM Parameter p " +
+                "WHERE p.function_id = ?;";
+        try (Connection conn = DriverManager.getConnection(dbPath);
+             PreparedStatement stmt = conn.prepareStatement(sql)) {
+            stmt.setInt(1, functionId);
+            ResultSet rs = stmt.executeQuery();
+            LinkedHashMap<String, ParameterResult> parameterResults = new LinkedHashMap<>();
+            while (rs.next()) {
+                String paramName = rs.getString("name");
+                ParameterResult parameterResult = new ParameterResult(
+                        rs.getInt("parameter_id"),
+                        paramName,
+                        rs.getString("type"),
+                        Parameter.Kind.valueOf(rs.getString("kind")),
+                        rs.getString("default_value"),
+                        rs.getString("description"),
+                        rs.getInt("optional")
+                );
+                parameterResults.put(paramName, parameterResult);
+            }
+            return parameterResults;
+        } catch (SQLException e) {
+            Logger.getGlobal().severe("Error executing query: " + e.getMessage());
+            return new LinkedHashMap<>();
+        }
+    }
+
     public List<FunctionResult> getConnectorActions(int connectorId) {
         String sql = "SELECT " +
                 "f.function_id, " +

flow-model-generator/modules/flow-model-generator-core/src/main/java/io/ballerina/flowmodelgenerator/core/db/model/FunctionResult.java

@@ -28,6 +28,5 @@ public record FunctionResult(
         String version,
         String resourcePath,
         Function.Kind kind,
-        Integer returnError
-) {
+        Integer returnError) {
 }

flow-model-generator/modules/flow-model-generator-core/src/main/java/io/ballerina/flowmodelgenerator/core/db/model/Parameter.java

@@ -18,7 +18,13 @@
 public class Parameter {
 
     public enum Kind {
-        REQUIRED, DEFAULTABLE, INCLUDED_RECORD, REST
+        REQUIRED,
+        DEFAULTABLE,
+        INCLUDED_RECORD,
+        REST_PARAMETER,
+        INCLUDED_FIELD,
+        PARAM_FOR_TYPE_INFER,
+        INCLUDED_RECORD_REST
     }
 
     @Id
@@ -44,6 +50,9 @@ public enum Kind {
     @JoinColumn(name = "function_id")
     private Function function;
 
+    @Column(name = "optional")
+    private Integer optional;
+
     // Getters and setters
     public Long getParameterId() {
         return parameterId;
@@ -92,4 +101,12 @@ public Function getFunction() {
     public void setFunction(Function function) {
         this.function = function;
     }
+
+    public Integer getOptional() {
+        return optional;
+    }
+
+    public void setOptional(Integer optional) {
+        this.optional = optional;
+    }
 }

flow-model-generator/modules/flow-model-generator-core/src/main/java/io/ballerina/flowmodelgenerator/core/db/model/ParameterResult.java

@@ -18,18 +18,12 @@
 
 package io.ballerina.flowmodelgenerator.core.db.model;
 
-import io.ballerina.compiler.api.symbols.ParameterKind;
-
 public record ParameterResult(
         int parameterId,
         String name,
         String type,
-        ParameterKind kind,
+        Parameter.Kind kind,
         String defaultValue,
-        String description) {
-
-    public String getDefaultValue() {
-        //TODO: Remove included record params once #238 completed.
-        return (kind == ParameterKind.REQUIRED || kind == ParameterKind.INCLUDED_RECORD) ? defaultValue : "";
-    }
+        String description,
+        Integer optional) {
 }

flow-model-generator/modules/flow-model-generator-core/src/main/java/io/ballerina/flowmodelgenerator/core/model/Property.java

@@ -39,11 +39,12 @@
  * @param editable            whether the property is not readonly
  * @param advanced            whether the property should be shown in the advanced tab
  * @param diagnostics         diagnostics of the property
+ * @param kind                kind of the property
  * @since 1.4.0
  */
 public record Property(Metadata metadata, String valueType, Object valueTypeConstraint, Object value,
                        String placeholder, boolean optional, boolean editable, boolean advanced,
-                       Diagnostics diagnostics) {
+                       Diagnostics diagnostics, String kind) {
 
     private static final Gson gson = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
 
@@ -150,7 +151,9 @@ public enum ValueType {
         VIEW,
         INCLUSION,
         UNION,
-        FLAG
+        FLAG,
+        MAPPING_EXPRESSION_SET,
+        EXPRESSION_SET
     }
 
     public static ValueType valueTypeFrom(String s) {
@@ -170,6 +173,7 @@ public static class Builder<T> extends FacetedBuilder<T> implements DiagnosticHa
         private boolean editable;
         private boolean advanced;
         private Object typeConstraint;
+        private String kind;
         private Metadata.Builder<Builder<T>> metadataBuilder;
         private Diagnostics.Builder<Builder<T>> diagnosticsBuilder;
 
@@ -213,6 +217,11 @@ public Builder<T> advanced(boolean advanced) {
             return this;
         }
 
+        public Builder<T> kind(String kind) {
+            this.kind = kind;
+            return this;
+        }
+
         public Builder<T> editable() {
             this.editable = true;
             return this;
@@ -247,7 +256,7 @@ public Property build() {
             Property property =
                     new Property(metadataBuilder == null ? null : metadataBuilder.build(), type, typeConstraint, value,
                             placeholder, optional, editable, advanced,
-                            diagnosticsBuilder == null ? null : diagnosticsBuilder.build());
+                            diagnosticsBuilder == null ? null : diagnosticsBuilder.build(), kind);
             this.metadataBuilder = null;
             this.type = null;
             this.typeConstraint = null;
@@ -257,6 +266,7 @@ public Property build() {
             this.editable = false;
             this.advanced = false;
             this.diagnosticsBuilder = null;
+            this.kind = null;
             return property;
         }
     }

flow-model-generator/modules/flow-model-generator-core/src/main/java/io/ballerina/flowmodelgenerator/core/model/SourceBuilder.java

@@ -28,6 +28,7 @@
 import io.ballerina.compiler.syntax.tree.SyntaxKind;
 import io.ballerina.compiler.syntax.tree.SyntaxTree;
 import io.ballerina.flowmodelgenerator.core.CommonUtils;
+import io.ballerina.flowmodelgenerator.core.db.model.Parameter;
 import io.ballerina.projects.Document;
 import io.ballerina.projects.Module;
 import io.ballerina.projects.ModuleDescriptor;
@@ -268,30 +269,47 @@ public SourceBuilder functionParameters(FlowNode nodeTemplate, Set<String> ignor
         Set<String> keys = new LinkedHashSet<>(properties != null ? properties.keySet() : Set.of());
         keys.removeAll(ignoredProperties);
 
-        boolean hasEmptyParam = false;
         boolean firstParamAdded = false;
         for (String key : keys) {
             Optional<Property> property = flowNode.getProperty(key);
             if (property.isEmpty() || property.get().value() == null ||
                     (property.get().optional() && property.get().value().toString().isEmpty())) {
-                hasEmptyParam = true;
                 continue;
             }
 
+            Property prop = property.get();
+            String kind = prop.kind();
+
             if (firstParamAdded) {
-                tokenBuilder.keyword(SyntaxKind.COMMA_TOKEN);
+                if ((kind.equals(Parameter.Kind.REST_PARAMETER.name()))) {
+                    if (hasRestParamValues(prop)) {
+                        tokenBuilder.keyword(SyntaxKind.COMMA_TOKEN);
+                        addRestParamValues(prop);
+                        continue;
+                    }
+                } else if (kind.equals(Parameter.Kind.INCLUDED_RECORD_REST.name())) {
+                    if (hasRestParamValues(prop)) {
+                        tokenBuilder.keyword(SyntaxKind.COMMA_TOKEN);
+                        addIncludedRecordRestParamValues(prop);
+                        continue;
+                    }
+                } else {
+                    tokenBuilder.keyword(SyntaxKind.COMMA_TOKEN);
+                }
             } else {
                 firstParamAdded = true;
             }
 
-            if (hasEmptyParam) {
-                tokenBuilder
-                        .name(key)
-                        .keyword(SyntaxKind.EQUAL_TOKEN);
-                hasEmptyParam = false;
+            if (kind.equals(Parameter.Kind.REQUIRED.name()) || kind.equals(Parameter.Kind.DEFAULTABLE.name())
+                    || kind.equals(Parameter.Kind.INCLUDED_RECORD.name())) {
+                tokenBuilder.expression(prop);
+            } else if (kind.equals(Parameter.Kind.INCLUDED_FIELD.name())) {
+                tokenBuilder.name(key).whiteSpace().keyword(SyntaxKind.EQUAL_TOKEN).expression(prop);
+            } else if (kind.equals(Parameter.Kind.REST_PARAMETER.name())) {
+                addRestParamValues(prop);
+            } else if (kind.equals(Parameter.Kind.INCLUDED_RECORD_REST.name())) {
+                addIncludedRecordRestParamValues(prop);
             }
-
-            tokenBuilder.expression(property.get());
         }
 
         tokenBuilder
@@ -300,6 +318,37 @@ public SourceBuilder functionParameters(FlowNode nodeTemplate, Set<String> ignor
         return this;
     }
 
+    private boolean hasRestParamValues(Property prop) {
+        if (prop.value() instanceof List<?> values) {
+            return !values.isEmpty();
+        }
+        return false;
+    }
+
+    private void addRestParamValues(Property prop) {
+        if (prop.value() instanceof List<?>) {
+            List<String> values = (List<String>) prop.value();
+            if (!values.isEmpty()) {
+                tokenBuilder.expression(String.join(", ", values));
+            }
+        }
+    }
+
+    private void addIncludedRecordRestParamValues(Property prop) {
+        if (prop.value() instanceof List<?>) {
+            List<Map> values = (List<Map>) prop.value();
+            if (!values.isEmpty()) {
+                List<String> result = new ArrayList<>();
+                values.forEach(keyValuePair -> {
+                    String key = (String) keyValuePair.keySet().iterator().next();
+                    String value = (String) keyValuePair.values().iterator().next();
+                    result.add(key + " = " + value);
+                });
+                tokenBuilder.expression(String.join(", ", result));
+            }
+        }
+    }
+
     public SourceBuilder textEdit(boolean isExpression) {
         return textEdit(isExpression, filePath, CommonUtils.toRange(flowNode.codedata().lineRange()));
     }