Add support for Smithy bigInteger and bigDecimal types as string wrappers in aws-smithy-types, allowing users to parse with their preferred big number library.

Author: Amit Kulkarni

.changelog/1763738215.md

@@ -0,0 +1,13 @@
+---
+applies_to:
+- client
+- aws-sdk-rust
+authors:
+- AmitKulkarni23
+references:
+- smithy-rs#312
+breaking: false
+new_feature: true
+bug_fix: false
+---
+Add support for Smithy bigInteger and bigDecimal types as string wrappers in aws-smithy-types, allowing users to parse with their preferred big number library.

codegen-client-test/build.gradle.kts

@@ -62,6 +62,7 @@ data class ClientTest(
 
 val allCodegenTests = listOf(
     ClientTest("com.amazonaws.simple#SimpleService", "simple", dependsOn = listOf("simple.smithy")),
+    ClientTest("com.amazonaws.bignumbers#BigNumberService", "big_numbers", dependsOn = listOf("big-numbers.smithy")),
     ClientTest("com.amazonaws.dynamodb#DynamoDB_20120810", "dynamo"),
     ClientTest("com.amazonaws.ebs#Ebs", "ebs", dependsOn = listOf("ebs.json")),
     ClientTest("aws.protocoltests.json10#JsonRpc10", "json_rpc10"),

codegen-core/common-test-models/big-numbers.smithy

@@ -0,0 +1,143 @@
+$version: "2.0"
+
+namespace com.amazonaws.bignumbers
+
+use aws.protocols#restJson1
+use smithy.test#httpRequestTests
+use smithy.test#httpResponseTests
+
+@restJson1
+service BigNumberService {
+    version: "2023-01-01"
+    operations: [ProcessBigNumbers]
+}
+
+@http(uri: "/process", method: "POST")
+@httpRequestTests([
+    {
+        id: "BigNumbersInJsonRequest",
+        protocol: restJson1,
+        method: "POST",
+        uri: "/process",
+        body: "{\"bigInt\":123456789,\"bigDec\":123.456789}",
+        bodyMediaType: "application/json",
+        headers: {"Content-Type": "application/json"},
+        params: {
+            bigInt: 123456789,
+            bigDec: 123.456789
+        }
+    },
+    {
+        id: "NegativeBigNumbersInJsonRequest",
+        protocol: restJson1,
+        method: "POST",
+        uri: "/process",
+        body: "{\"bigInt\":-987654321,\"bigDec\":-0.000000001}",
+        bodyMediaType: "application/json",
+        headers: {"Content-Type": "application/json"},
+        params: {
+            bigInt: -987654321,
+            bigDec: -0.000000001
+        }
+    },
+    {
+        id: "ZeroBigNumbersInJsonRequest",
+        protocol: restJson1,
+        method: "POST",
+        uri: "/process",
+        body: "{\"bigInt\":0,\"bigDec\":0.0}",
+        bodyMediaType: "application/json",
+        headers: {"Content-Type": "application/json"},
+        params: {
+            bigInt: 0,
+            bigDec: 0.0
+        }
+    },
+    {
+        id: "VeryLargeBigNumbersInJsonRequest",
+        protocol: restJson1,
+        method: "POST",
+        uri: "/process",
+        body: "{\"bigInt\":9007199254740991,\"bigDec\":123456.789}",
+        bodyMediaType: "application/json",
+        headers: {"Content-Type": "application/json"},
+        params: {
+            bigInt: 9007199254740991,
+            bigDec: 123456.789
+        }
+    }
+])
+@httpResponseTests([
+    {
+        id: "BigNumbersInJsonResponse",
+        protocol: restJson1,
+        code: 200,
+        body: "{\"result\":999999999,\"ratio\":0.123456789}",
+        bodyMediaType: "application/json",
+        headers: {"Content-Type": "application/json"},
+        params: {
+            result: 999999999,
+            ratio: 0.123456789
+        }
+    },
+    {
+        id: "NegativeBigNumbersInJsonResponse",
+        protocol: restJson1,
+        code: 200,
+        body: "{\"result\":-123456789,\"ratio\":-999.999}",
+        bodyMediaType: "application/json",
+        headers: {"Content-Type": "application/json"},
+        params: {
+            result: -123456789,
+            ratio: -999.999
+        }
+    },
+    {
+        id: "VeryLargeBigNumbersInJsonResponse",
+        protocol: restJson1,
+        code: 200,
+        body: "{\"result\":9007199254740991,\"ratio\":123456.789}",
+        bodyMediaType: "application/json",
+        headers: {"Content-Type": "application/json"},
+        params: {
+            result: 9007199254740991,
+            ratio: 123456.789
+        }
+    },
+    {
+        id: "ZeroBigNumbersInJsonResponse",
+        protocol: restJson1,
+        code: 200,
+        body: "{\"result\":0,\"ratio\":0.0}",
+        bodyMediaType: "application/json",
+        headers: {"Content-Type": "application/json"},
+        params: {
+            result: 0,
+            ratio: 0.0
+        }
+    },
+    {
+        id: "NullBigNumbersInJsonResponse",
+        protocol: restJson1,
+        code: 200,
+        body: "{\"result\":null,\"ratio\":null}",
+        bodyMediaType: "application/json",
+        headers: {"Content-Type": "application/json"},
+        params: {}
+    }
+])
+
+operation ProcessBigNumbers {
+    input: BigNumberInput
+    output: BigNumberOutput
+}
+
+structure BigNumberInput {
+    bigInt: BigInteger
+    bigDec: BigDecimal
+}
+
+structure BigNumberOutput {
+    result: BigInteger
+    ratio: BigDecimal
+}

codegen-core/common-test-models/misc.smithy

@@ -95,12 +95,11 @@ structure InnermostShape {
     @required
     aDouble: Double,
 
-    // TODO(https://github.com/smithy-lang/smithy-rs/issues/312)
-    // @required
-    // aBigInteger: BigInteger,
+     @required
+     aBigInteger: BigInteger,
 
-    // @required
-    // aBigDecimal: BigDecimal,
+     @required
+     aBigDecimal: BigDecimal,
 
     @required
     aTimestamp: Timestamp,

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/RuntimeType.kt

@@ -425,6 +425,10 @@ data class RuntimeType(val path: String, val dependency: RustDependency? = null)
 
         fun dateTime(runtimeConfig: RuntimeConfig) = smithyTypes(runtimeConfig).resolve("DateTime")
 
+        fun bigInteger(runtimeConfig: RuntimeConfig) = smithyTypes(runtimeConfig).resolve("BigInteger")
+
+        fun bigDecimal(runtimeConfig: RuntimeConfig) = smithyTypes(runtimeConfig).resolve("BigDecimal")
+
         fun document(runtimeConfig: RuntimeConfig): RuntimeType = smithyTypes(runtimeConfig).resolve("Document")
 
         fun format(runtimeConfig: RuntimeConfig) = smithyTypes(runtimeConfig).resolve("date_time::Format")

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/SymbolVisitor.kt

@@ -245,11 +245,11 @@ open class SymbolVisitor(
     }
 
     override fun bigIntegerShape(shape: BigIntegerShape?): Symbol {
-        TODO("Not yet implemented: https://github.com/smithy-lang/smithy-rs/issues/312")
+        return RuntimeType.bigInteger(config.runtimeConfig).toSymbol()
     }
 
     override fun bigDecimalShape(shape: BigDecimalShape?): Symbol {
-        TODO("Not yet implemented: https://github.com/smithy-lang/smithy-rs/issues/312")
+        return RuntimeType.bigDecimal(config.runtimeConfig).toSymbol()
     }
 
     override fun operationShape(shape: OperationShape): Symbol {

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/generators/Instantiator.kt

@@ -14,6 +14,8 @@ import software.amazon.smithy.model.node.NullNode
 import software.amazon.smithy.model.node.NumberNode
 import software.amazon.smithy.model.node.ObjectNode
 import software.amazon.smithy.model.node.StringNode
+import software.amazon.smithy.model.shapes.BigDecimalShape
+import software.amazon.smithy.model.shapes.BigIntegerShape
 import software.amazon.smithy.model.shapes.BlobShape
 import software.amazon.smithy.model.shapes.BooleanShape
 import software.amazon.smithy.model.shapes.CollectionShape
@@ -544,6 +546,20 @@ class PrimitiveInstantiator(
                     }
 
                 is StringShape -> renderString(shape, data as StringNode)(this)
+                is BigIntegerShape -> {
+                    val value = data.toString()
+                    rustTemplate(
+                        "<#{BigInteger} as ::std::str::FromStr>::from_str(${value.dq()}).unwrap()",
+                        "BigInteger" to RuntimeType.bigInteger(runtimeConfig),
+                    )
+                }
+                is BigDecimalShape -> {
+                    val value = data.toString()
+                    rustTemplate(
+                        "<#{BigDecimal} as ::std::str::FromStr>::from_str(${value.dq()}).unwrap()",
+                        "BigDecimal" to RuntimeType.bigDecimal(runtimeConfig),
+                    )
+                }
                 is NumberShape ->
                     when (data) {
                         is StringNode -> {

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/parse/CborParserGenerator.kt

@@ -5,7 +5,10 @@
 
 package software.amazon.smithy.rust.codegen.core.smithy.protocols.parse
 
+import software.amazon.smithy.codegen.core.CodegenException
 import software.amazon.smithy.codegen.core.Symbol
+import software.amazon.smithy.model.shapes.BigDecimalShape
+import software.amazon.smithy.model.shapes.BigIntegerShape
 import software.amazon.smithy.model.shapes.BlobShape
 import software.amazon.smithy.model.shapes.BooleanShape
 import software.amazon.smithy.model.shapes.ByteShape
@@ -579,6 +582,18 @@ class CborParserGenerator(
 
                 is TimestampShape -> rust("decoder.timestamp()")
 
+                // BigInteger/BigDecimal are not supported with CBOR.
+                // The Smithy RPC v2 CBOR spec requires these to be encoded using CBOR tags 2/3/4
+                // (binary bignum representation), but aws-smithy-cbor doesn't implement these tags yet.
+                is BigIntegerShape ->
+                    throw CodegenException(
+                        "BigInteger is not supported with Concise Binary Object Representation (CBOR) protocol",
+                    )
+                is BigDecimalShape ->
+                    throw CodegenException(
+                        "BigDecimal is not supported with Concise Binary Object Representation (CBOR) protocol",
+                    )
+
                 // Aggregate shapes: https://smithy.io/2.0/spec/aggregate-types.html
                 is StructureShape -> deserializeStruct(target)
                 is CollectionShape -> deserializeCollection(target)

codegen-core/src/main/kotlin/software/amazon/smithy/rust/codegen/core/smithy/protocols/parse/JsonParserGenerator.kt

@@ -6,6 +6,8 @@
 package software.amazon.smithy.rust.codegen.core.smithy.protocols.parse
 
 import software.amazon.smithy.codegen.core.Symbol
+import software.amazon.smithy.model.shapes.BigDecimalShape
+import software.amazon.smithy.model.shapes.BigIntegerShape
 import software.amazon.smithy.model.shapes.BlobShape
 import software.amazon.smithy.model.shapes.BooleanShape
 import software.amazon.smithy.model.shapes.CollectionShape
@@ -296,6 +298,8 @@ class JsonParserGenerator(
         when (val target = model.expectShape(memberShape.target)) {
             is StringShape -> deserializeString(target)
             is BooleanShape -> rustTemplate("#{expect_bool_or_null}(tokens.next())?", *codegenScope)
+            is BigIntegerShape -> deserializeBigInteger()
+            is BigDecimalShape -> deserializeBigDecimal()
             is NumberShape -> deserializeNumber(target)
             is BlobShape -> deserializeBlob(memberShape)
             is TimestampShape -> deserializeTimestamp(memberShape)
@@ -374,6 +378,63 @@ class JsonParserGenerator(
         }
     }
 
+    private fun RustWriter.deserializeBigInteger() {
+        // Match on Number enum to:
+        // 1. Validate only integers are accepted (reject floats)
+        // 2. Extract inner value and convert to string
+
+        rustTemplate(
+            """
+            #{expect_number_or_null}(tokens.next())?
+                .map(|v| {
+                    let s = match v {
+                        #{Number}::PosInt(n) => n.to_string(),
+                        #{Number}::NegInt(n) => n.to_string(),
+                        #{Number}::Float(_) => return Err(#{Error}::custom("expected integer, found float")),
+                    };
+                    Ok(<#{BigInteger} as ::std::str::FromStr>::from_str(&s).expect("infallible"))
+                })
+                .transpose()?
+            """,
+            "BigInteger" to RuntimeType.bigInteger(codegenContext.runtimeConfig),
+            "Number" to RuntimeType.smithyTypes(codegenContext.runtimeConfig).resolve("Number"),
+            *codegenScope,
+        )
+    }
+
+    private fun RustWriter.deserializeBigDecimal() {
+        // Match on Number enum to extract inner value and convert to string
+        // (Number doesn't implement Display, so we must match each variant)
+        // For floats, preserve decimal notation that f64::to_string() drops for whole numbers
+
+        rustTemplate(
+            """
+            #{expect_number_or_null}(tokens.next())?
+                .map(|v| {
+                    let s = match v {
+                        #{Number}::PosInt(n) => n.to_string(),
+                        #{Number}::NegInt(n) => n.to_string(),
+                        #{Number}::Float(f) => {
+                            // Use format! to avoid scientific notation and preserve precision
+                            let s = format!("{f}");
+                            // f64 formatting drops ".0" for whole numbers (0.0 -> "0")
+                            // Restore it to preserve that the original JSON had decimal notation
+                            if !s.contains('.') && !s.contains('e') && !s.contains('E') {
+                                format!("{s}.0")
+                            } else {
+                                s
+                            }
+                        },
+                    };
+                    <#{BigDecimal} as ::std::str::FromStr>::from_str(&s).expect("infallible")
+                })
+            """,
+            "BigDecimal" to RuntimeType.bigDecimal(codegenContext.runtimeConfig),
+            "Number" to RuntimeType.smithyTypes(codegenContext.runtimeConfig).resolve("Number"),
+            *codegenScope,
+        )
+    }
+
     private fun RustWriter.deserializeTimestamp(member: MemberShape) {
         val timestampFormat =
             httpBindingResolver.timestampFormat(