Improve support @constraint annotation mapping to OpenAPI spec

openapi-bal-service/src/main/java/io/ballerina/openapi/converter/service/OpenAPIComponentMapper.java

@@ -18,24 +18,7 @@
 
 package io.ballerina.openapi.converter.service;
 
-import io.ballerina.compiler.api.symbols.ArrayTypeSymbol;
-import io.ballerina.compiler.api.symbols.ConstantSymbol;
-import io.ballerina.compiler.api.symbols.Documentable;
-import io.ballerina.compiler.api.symbols.Documentation;
-import io.ballerina.compiler.api.symbols.EnumSymbol;
-import io.ballerina.compiler.api.symbols.IntersectionTypeSymbol;
-import io.ballerina.compiler.api.symbols.MapTypeSymbol;
-import io.ballerina.compiler.api.symbols.ReadonlyTypeSymbol;
-import io.ballerina.compiler.api.symbols.RecordFieldSymbol;
-import io.ballerina.compiler.api.symbols.RecordTypeSymbol;
-import io.ballerina.compiler.api.symbols.Symbol;
-import io.ballerina.compiler.api.symbols.SymbolKind;
-import io.ballerina.compiler.api.symbols.TupleTypeSymbol;
-import io.ballerina.compiler.api.symbols.TypeDefinitionSymbol;
-import io.ballerina.compiler.api.symbols.TypeDescKind;
-import io.ballerina.compiler.api.symbols.TypeReferenceTypeSymbol;
-import io.ballerina.compiler.api.symbols.TypeSymbol;
-import io.ballerina.compiler.api.symbols.UnionTypeSymbol;
+import io.ballerina.compiler.api.symbols.*;
 import io.ballerina.compiler.syntax.tree.AnnotationNode;
 import io.ballerina.compiler.syntax.tree.ExpressionNode;
 import io.ballerina.compiler.syntax.tree.IntersectionTypeDescriptorNode;
@@ -719,54 +702,107 @@ private ArraySchema handleArray(int arrayDimensions, Schema property, ArraySchem
     }
 
     /**
-     * This util uses to set the constraint value for relevant schema field.
+     * This util uses to set the integer constraint values for relevant schema field.
      */
-    private Schema setConstraintValueToSchema(ConstraintAnnotation constraintAnnot, Schema property) {
-
-        if (property instanceof ArraySchema) {
-            property.setMaxItems(constraintAnnot.getMaxLength().isPresent() ?
-                    Integer.valueOf(constraintAnnot.getMaxLength().get()) : null);
-            property.setMinItems(constraintAnnot.getMinLength().isPresent() ?
-                    Integer.valueOf(constraintAnnot.getMinLength().get()) : null);
-        } else {
-            property.setMaxLength(constraintAnnot.getMaxLength().isPresent() ?
-                    Integer.valueOf(constraintAnnot.getMaxLength().get()) : null);
-            property.setMinLength(constraintAnnot.getMinLength().isPresent() ?
-                    Integer.valueOf(constraintAnnot.getMinLength().get()) : null);
-        }
+    private Schema setIntegerConstraintValuesToSchema(ConstraintAnnotation constraintAnnot, Schema properties) {
+        BigDecimal minimum = null;
+        BigDecimal maximum = null;
+        if (constraintAnnot.getMinValue().isPresent()) {
+            minimum = BigDecimal.valueOf(Integer.parseInt(constraintAnnot.getMinValue().get()));
+        } else if (constraintAnnot.getMinValueExclusive().isPresent()) {
+            minimum = BigDecimal.valueOf(Integer.parseInt(constraintAnnot.getMinValueExclusive().get()));
+            properties.setExclusiveMinimum(true);
+        }
+
+        if (constraintAnnot.getMaxValue().isPresent()) {
+            maximum = BigDecimal.valueOf(Integer.parseInt(constraintAnnot.getMaxValue().get()));
+        } else if (constraintAnnot.getMaxValueExclusive().isPresent()) {
+            maximum = BigDecimal.valueOf(Integer.parseInt(constraintAnnot.getMaxValueExclusive().get()));
+            properties.setExclusiveMaximum(true);
+        }
+        properties.setMinimum(minimum);
+        properties.setMaximum(maximum);
+        return properties;
+    }
 
+    /**
+     * This util uses to set the number (float, double) constraint values for relevant schema field.
+     */
+    private Schema setNumberConstraintValuesToSchema(ConstraintAnnotation constraintAnnot, Schema properties) {
+        BigDecimal minimum = null;
+        BigDecimal maximum = null;
         try {
-            BigDecimal minimum = null;
-            BigDecimal maximum = null;
             if (constraintAnnot.getMinValue().isPresent()) {
-                try {
-                    minimum = BigDecimal.valueOf(Integer.parseInt(constraintAnnot.getMinValue().get()));
-                } catch (NumberFormatException e) {
-                    minimum = BigDecimal.valueOf(NumberFormat.getInstance().parse(
-                            constraintAnnot.getMinValue().get()).doubleValue());
-                }
+                minimum = BigDecimal.valueOf((NumberFormat.getInstance()
+                                .parse(constraintAnnot.getMinValue().get()).doubleValue()));
+            } else if (constraintAnnot.getMinValueExclusive().isPresent()) {
+                minimum = BigDecimal.valueOf((NumberFormat.getInstance()
+                                .parse(constraintAnnot.getMinValueExclusive().get()).doubleValue()));
+                properties.setExclusiveMinimum(true);
             }
 
             if (constraintAnnot.getMaxValue().isPresent()) {
-                try {
-                    maximum = BigDecimal.valueOf(Integer.parseInt(constraintAnnot.getMaxValue().get()));
-                } catch (NumberFormatException e) {
-                    maximum = BigDecimal.valueOf((NumberFormat.getInstance()
-                                    .parse(constraintAnnot.getMaxValue().get()).doubleValue()));
-                }
-
+                maximum = BigDecimal.valueOf((NumberFormat.getInstance()
+                                .parse(constraintAnnot.getMaxValue().get()).doubleValue()));
+            } else if (constraintAnnot.getMaxValueExclusive().isPresent()) {
+                maximum = BigDecimal.valueOf((NumberFormat.getInstance()
+                                .parse(constraintAnnot.getMaxValueExclusive().get()).doubleValue()));
+                properties.setExclusiveMaximum(true);
             }
-            property.setMinimum(minimum);
-            property.setMaximum(maximum);
-
-        } catch (ParseException parserMessage) {
+            properties.setMinimum(minimum);
+            properties.setMaximum(maximum);
+        } catch (ParseException exception) {
             DiagnosticMessages error = DiagnosticMessages.OAS_CONVERTOR_110;
             ExceptionDiagnostic diagnostic = new ExceptionDiagnostic(error.getCode(),
-                    error.getDescription(), null, parserMessage.getMessage());
+                    error.getDescription(), null, exception.getMessage());
             diagnostics.add(diagnostic);
         }
+        return properties;
+    }
 
-        return property;
+    /**
+     * This util uses to set the string constraint values for relevant schema field.
+     */
+    private Schema setStringConstraintValuesToSchema(ConstraintAnnotation constraintAnnot, Schema properties) {
+        properties.setMaxLength(constraintAnnot.getMaxLength().isPresent() ?
+                Integer.valueOf(constraintAnnot.getMaxLength().get()) : null);
+        properties.setMinLength(constraintAnnot.getMinLength().isPresent() ?
+                Integer.valueOf(constraintAnnot.getMinLength().get()) : null);
+        return properties;
+    }
+
+    /**
+     * This util uses to set the array constraint values for relevant schema field.
+     */
+    private Schema setArrayConstraintValuesToSchema(ConstraintAnnotation constraintAnnot, Schema properties) {
+        properties.setMaxItems(constraintAnnot.getMaxLength().isPresent() ?
+                Integer.valueOf(constraintAnnot.getMaxLength().get()) : null);
+        properties.setMinItems(constraintAnnot.getMinLength().isPresent() ?
+                Integer.valueOf(constraintAnnot.getMinLength().get()) : null);
+        return properties;
+    }
+
+    /**
+     * This util uses to set the constraint values for relevant schema field.
+     */
+    private Schema setConstraintValueToSchema(ConstraintAnnotation constraintAnnot, Schema properties) {
+        try {
+            if (properties instanceof ArraySchema) {
+                setArrayConstraintValuesToSchema(constraintAnnot, properties);
+            } else if (properties instanceof StringSchema){
+                setStringConstraintValuesToSchema(constraintAnnot, properties);
+            } else if (properties instanceof IntegerSchema) {
+                setIntegerConstraintValuesToSchema(constraintAnnot, properties);
+            } else if (properties instanceof NumberSchema) {
+                setNumberConstraintValuesToSchema(constraintAnnot, properties);
+            }
+        } catch (NumberFormatException exception) {
+            DiagnosticMessages error = DiagnosticMessages.OAS_CONVERTOR_110;
+            ExceptionDiagnostic diagnostic = new ExceptionDiagnostic(error.getCode(),
+                    error.getDescription(), null, exception.getMessage());
+            diagnostics.add(diagnostic);
+        }
+        return properties;
     }
 
     /**
@@ -776,8 +812,8 @@ private void extractedConstraintAnnotation(MetadataNode metadata,
                                                ConstraintAnnotation.ConstraintAnnotationBuilder constraintBuilder) {
         NodeList<AnnotationNode> annotations = metadata.annotations();
         annotations.stream().filter(annot -> (annot.annotReference() instanceof QualifiedNameReferenceNode &&
-                                ((QualifiedNameReferenceNode) annot.annotReference()).modulePrefix().text()
-                                        .equals("constraint")))
+                        ((QualifiedNameReferenceNode) annot.annotReference()).modulePrefix().text()
+                                .equals("constraint")))
                 .forEach(value -> {
                     Optional<MappingConstructorExpressionNode> fieldValues = value.annotValue();
                     if (fieldValues.isPresent()) {
@@ -791,7 +827,7 @@ private void extractedConstraintAnnotation(MetadataNode metadata,
                                     ExpressionNode expressionNode = specificFieldNode.valueExpr().get();
                                     SyntaxKind kind = expressionNode.kind();
                                     if (kind == SyntaxKind.NUMERIC_LITERAL) {
-                                        String constraintValue = expressionNode.toString();
+                                        String constraintValue = expressionNode.toString().trim();
                                         fillConstraintValue(constraintBuilder, name, constraintValue);
                                     }
                                 }

openapi-cli/src/test/java/io/ballerina/openapi/generators/openapi/ConstraintTests.java

@@ -44,4 +44,46 @@ public void testArrayType() throws IOException {
         //Compare generated yaml file with expected yaml content
         TestUtils.compareWithGeneratedFile(ballerinaFilePath, "constraint/array.yaml");
     }
+
+    @Test(description = "When the record field has integer (minValueExclusive) type")
+    public void testIntegerMinType() throws IOException {
+        Path ballerinaFilePath = RES_DIR.resolve("constraint/integerMin.bal");
+        //Compare generated yaml file with expected yaml content
+        TestUtils.compareWithGeneratedFile(ballerinaFilePath, "constraint/integerMin.yaml");
+    }
+
+    @Test(description = "When the record field has integer (maxValueExclusive) type")
+    public void testIntegerMaxType() throws IOException {
+        Path ballerinaFilePath = RES_DIR.resolve("constraint/integerMax.bal");
+        //Compare generated yaml file with expected yaml content
+        TestUtils.compareWithGeneratedFile(ballerinaFilePath, "constraint/integerMax.yaml");
+    }
+
+    @Test(description = "When the record field has float (minValueExclusive) type")
+    public void testFloatMinType() throws IOException {
+        Path ballerinaFilePath = RES_DIR.resolve("constraint/floatMin.bal");
+        //Compare generated yaml file with expected yaml content
+        TestUtils.compareWithGeneratedFile(ballerinaFilePath, "constraint/floatMin.yaml");
+    }
+
+    @Test(description = "When the record field has float (maxValueExclusive) type")
+    public void testFloatMaxType() throws IOException {
+        Path ballerinaFilePath = RES_DIR.resolve("constraint/floatMax.bal");
+        //Compare generated yaml file with expected yaml content
+        TestUtils.compareWithGeneratedFile(ballerinaFilePath, "constraint/floatMax.yaml");
+    }
+
+    @Test(description = "When the record field has decimal (minValueExclusive) type")
+    public void testDecimalMinType() throws IOException {
+        Path ballerinaFilePath = RES_DIR.resolve("constraint/decimalMin.bal");
+        //Compare generated yaml file with expected yaml content
+        TestUtils.compareWithGeneratedFile(ballerinaFilePath, "constraint/decimalMin.yaml");
+    }
+
+    @Test(description = "When the record field has decimal (maxValueExclusive) type")
+    public void testDecimalMaxType() throws IOException {
+        Path ballerinaFilePath = RES_DIR.resolve("constraint/decimalMax.bal");
+        //Compare generated yaml file with expected yaml content
+        TestUtils.compareWithGeneratedFile(ballerinaFilePath, "constraint/decimalMax.yaml");
+    }
 }

openapi-cli/src/test/java/io/ballerina/openapi/generators/openapi/ResponseTests.java

@@ -238,22 +238,22 @@ public void testForNoContentReturnCode() throws IOException {
 
     @Test(description = "When the response has float return type")
     public void testResponseWithFloatReturnType() throws IOException {
-        Path ballerinaFilePath = RES_DIR.resolve("response/float.bal");
+        Path ballerinaFilePath = RES_DIR.resolve("response/floatMin.bal");
         OASContractGenerator openApiConverterUtils = new OASContractGenerator();
         openApiConverterUtils.generateOAS3DefinitionsAllService(ballerinaFilePath, this.tempDir, null
                 , false);
         Assert.assertTrue(openApiConverterUtils.getErrors().isEmpty());
-        compareWithGeneratedFile(ballerinaFilePath, "response/float.yaml");
+        compareWithGeneratedFile(ballerinaFilePath, "response/floatMin.yaml");
     }
 
     @Test(description = "When the response has decimal return type")
     public void testResponseWithDecimalReturnType() throws IOException {
-        Path ballerinaFilePath = RES_DIR.resolve("response/decimal.bal");
+        Path ballerinaFilePath = RES_DIR.resolve("response/decimalMin.bal");
         OASContractGenerator openApiConverterUtils = new OASContractGenerator();
         openApiConverterUtils.generateOAS3DefinitionsAllService(ballerinaFilePath, this.tempDir, null
                 , false);
         Assert.assertTrue(openApiConverterUtils.getErrors().isEmpty());
-        compareWithGeneratedFile(ballerinaFilePath, "response/decimal.yaml");
+        compareWithGeneratedFile(ballerinaFilePath, "response/decimalMin.yaml");
     }
 
     @Test(description = "When the response has byte[] return type")

openapi-cli/src/test/resources/ballerina-to-openapi/constraint/decimalMax.bal

@@ -0,0 +1,19 @@
+import ballerina/http;
+import ballerina/constraint;
+
+@constraint:Number {
+    maxValueExclusive: 5.55,
+    minValue: 2.55
+}
+
+public type Marks decimal;
+
+public type School record {
+    Marks marks;
+};
+
+service /payloadV on new http:Listener(9090) {
+    resource function post pet(@http:Payload School body) returns error? {
+        return;
+    }
+}

openapi-cli/src/test/resources/ballerina-to-openapi/constraint/decimalMin.bal

@@ -0,0 +1,19 @@
+import ballerina/http;
+import ballerina/constraint;
+
+@constraint:Number {
+    minValueExclusive: 2.55,
+    maxValue: 5.55
+}
+
+public type Marks decimal;
+
+public type School record {
+    Marks marks;
+};
+
+service /payloadV on new http:Listener(9090) {
+    resource function post pet(@http:Payload School body) returns error? {
+        return;
+    }
+}

openapi-cli/src/test/resources/ballerina-to-openapi/constraint/floatMax.bal

@@ -0,0 +1,19 @@
+import ballerina/http;
+import ballerina/constraint;
+
+@constraint:Float {
+    maxValueExclusive: 10.5,
+    minValue: 2.5
+}
+
+public type Rating float;
+
+public type Hotel record {
+    Rating rate;
+};
+
+service /payloadV on new http:Listener(9090) {
+    resource function post pet(@http:Payload Hotel body) returns error? {
+        return;
+    }
+}

openapi-cli/src/test/resources/ballerina-to-openapi/constraint/floatMin.bal

@@ -0,0 +1,19 @@
+import ballerina/http;
+import ballerina/constraint;
+
+@constraint:Float {
+    minValueExclusive: 2.5,
+    maxValue: 10.5
+}
+
+public type Rating float;
+
+public type Hotel record {
+    Rating rate;
+};
+
+service /payloadV on new http:Listener(9090) {
+    resource function post pet(@http:Payload Hotel body) returns error? {
+        return;
+    }
+}

openapi-cli/src/test/resources/ballerina-to-openapi/constraint/integerMax.bal

@@ -0,0 +1,18 @@
+import ballerina/http;
+import ballerina/constraint;
+
+@constraint:Int{
+    maxValueExclusive: 100,
+    minValue: 10
+}
+public type Position int;
+
+public type Child record {
+    Position position;
+};
+
+service /payloadV on new http:Listener(9090) {
+    resource function post pet(@http:Payload Child body) returns error? {
+        return;
+    }
+}

openapi-cli/src/test/resources/ballerina-to-openapi/constraint/integerMin.bal

@@ -0,0 +1,18 @@
+import ballerina/http;
+import ballerina/constraint;
+
+@constraint:Int{
+    minValueExclusive: 0,
+    maxValue: 50
+}
+public type Position int;
+
+public type Child record {
+    Position position;
+};
+
+service /payloadV on new http:Listener(9090) {
+    resource function post pet(@http:Payload Child body) returns error? {
+        return;
+    }
+}

openapi-cli/src/test/resources/ballerina-to-openapi/expected_gen/constraint/array.yaml

@@ -57,7 +57,7 @@ components:
       type: number
       format: float
     PersonLimitItemsInteger:
-      maximum: 67.0
+      maximum: 67
       type: integer
       format: int32
     Hobby: