fix(rust-axum): preserve explicit unsigned intent in integer fallback

Author: LSX-s-Software

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustAxumServerCodegen.java

@@ -1033,13 +1033,19 @@ private String getIntegerDataType(String format,
                                       boolean explicitUnsigned) {
         boolean unsigned = explicitUnsigned || canFitIntoUnsigned(minimum, exclusiveMinimum);
 
+        if (explicitUnsigned && !canFitIntoUnsigned(minimum, exclusiveMinimum)) {
+            // Preserve explicit unsigned intent (e.g. x-unsigned) even when no lower bound is provided.
+            minimum = BigInteger.ZERO;
+            exclusiveMinimum = false;
+        }
+
         if (StringUtils.isEmpty(format)) {
             return bestFittingIntegerType(
                     minimum,
                     exclusiveMinimum,
                     maximum,
                     exclusiveMaximum,
-                    true);
+                    unsigned);
         }
 
         switch (format) {
@@ -1059,16 +1065,22 @@ private String getIntegerDataType(String format,
                         exclusiveMinimum,
                         maximum,
                         exclusiveMaximum,
-                        true);
+                        unsigned);
         }
     }
 
+    private boolean hasExplicitUnsignedExtension(Map<String, Object> extensions) {
+        return extensions != null && Boolean.TRUE.equals(extensions.get("x-unsigned"));
+    }
+
     @Override
     public String getSchemaType(Schema p) {
         if (Objects.equals(p.getType(), "integer")) {
             BigInteger minimum = Optional.ofNullable(p.getMinimum()).map(BigDecimal::toBigInteger).orElse(null);
             BigInteger maximum = Optional.ofNullable(p.getMaximum()).map(BigDecimal::toBigInteger).orElse(null);
-            boolean explicitUnsigned = ModelUtils.isUnsignedIntegerSchema(p) || ModelUtils.isUnsignedLongSchema(p);
+            boolean explicitUnsigned = ModelUtils.isUnsignedIntegerSchema(p)
+                    || ModelUtils.isUnsignedLongSchema(p)
+                    || hasExplicitUnsignedExtension(p.getExtensions());
 
             return getIntegerDataType(
                     p.getFormat(),
@@ -1174,7 +1186,9 @@ public void postProcessModelProperty(CodegenModel model, CodegenProperty propert
         if (Boolean.TRUE.equals(property.isInteger) || Boolean.TRUE.equals(property.isLong) || Objects.equals(property.baseType, "UnsignedInteger") || Objects.equals(property.baseType, "UnsignedLong")) {
             BigInteger minimum = Optional.ofNullable(property.getMinimum()).map(BigInteger::new).orElse(null);
             BigInteger maximum = Optional.ofNullable(property.getMaximum()).map(BigInteger::new).orElse(null);
-            boolean explicitUnsigned = Objects.equals(property.baseType, "UnsignedInteger") || Objects.equals(property.baseType, "UnsignedLong");
+            boolean explicitUnsigned = Objects.equals(property.baseType, "UnsignedInteger")
+                    || Objects.equals(property.baseType, "UnsignedLong")
+                    || hasExplicitUnsignedExtension(property.vendorExtensions);
             property.dataType = getIntegerDataType(
                     property.dataFormat,
                     minimum,

modules/openapi-generator/src/test/java/org/openapitools/codegen/rust/RustAxumServerCodegenTest.java

@@ -63,23 +63,35 @@ public void testIntegerSchemaTypeMapping() {
         schema.setFormat("uint32");
         Assert.assertEquals(codegen.getSchemaType(schema), "u32");
 
+        schema = new IntegerSchema();
         schema.setFormat("uint64");
         Assert.assertEquals(codegen.getSchemaType(schema), "u64");
 
+        schema = new IntegerSchema();
         schema.setFormat("int32");
         schema.setMinimum(BigDecimal.ZERO);
         Assert.assertEquals(codegen.getSchemaType(schema), "u32");
 
+        schema = new IntegerSchema();
         schema.setFormat("int64");
+        schema.setMinimum(BigDecimal.ZERO);
         Assert.assertEquals(codegen.getSchemaType(schema), "u64");
 
+        schema = new IntegerSchema();
         schema.setFormat(null);
+        schema.setMinimum(BigDecimal.ZERO);
         schema.setMaximum(BigDecimal.valueOf(255));
         Assert.assertEquals(codegen.getSchemaType(schema), "u8");
 
+        schema = new IntegerSchema();
+        schema.setExtensions(new HashMap<>());
+        schema.getExtensions().put("x-unsigned", true);
+        Assert.assertEquals(codegen.getSchemaType(schema), "u32");
+
+        schema = new IntegerSchema();
+        schema.setFormat("custom");
         schema.setExtensions(new HashMap<>());
         schema.getExtensions().put("x-unsigned", true);
-        schema.setMaximum(null);
         Assert.assertEquals(codegen.getSchemaType(schema), "u32");
     }
 
@@ -101,6 +113,7 @@ public void testGeneratedIntegerTypes() throws IOException {
         TestUtils.assertFileContains(modelsPath, "pub positive_int32: u32");
         TestUtils.assertFileContains(modelsPath, "pub positive_int64: u64");
         TestUtils.assertFileContains(modelsPath, "pub small_positive: u8");
+        TestUtils.assertFileContains(modelsPath, "pub explicit_unsigned: u32");
         TestUtils.assertFileContains(modelsPath, "pub struct GetIntegersQueryParams");
     }
 }

modules/openapi-generator/src/test/resources/3_0/rust-axum/integer-types.yaml

@@ -40,6 +40,12 @@ paths:
             type: integer
             minimum: 0
             maximum: 255
+        - name: explicit_unsigned
+          in: query
+          required: true
+          schema:
+            type: integer
+            x-unsigned: true
       responses:
         '200':
           description: OK
@@ -57,6 +63,7 @@ components:
         - positive_int32
         - positive_int64
         - small_positive
+        - explicit_unsigned
       properties:
         legacy_uint32:
           type: integer
@@ -76,3 +83,6 @@ components:
           type: integer
           minimum: 0
           maximum: 255
+        explicit_unsigned:
+          type: integer
+          x-unsigned: true