UrlForm decoding support

build.sbt

@@ -63,7 +63,7 @@ lazy val allModules = Seq(
   decline,
   codegenPlugin,
   benchmark,
-  sandbox,
+  `aws-sandbox`,
   protocol,
   protocolTests,
   `aws-kernel`,
@@ -910,8 +910,8 @@ lazy val benchmark = projectMatrix
   .jvmPlatform(List(Scala213), jvmDimSettings)
   .settings(Smithy4sBuildPlugin.doNotPublishArtifact)
 
-lazy val sandbox = projectMatrix
-  .in(file("modules/sandbox"))
+lazy val `aws-sandbox` = projectMatrix
+  .in(file("modules/aws-sandbox"))
   .dependsOn(`aws-http4s`)
   .settings(
     Compile / allowedNamespaces := Seq(
@@ -922,14 +922,14 @@ lazy val sandbox = projectMatrix
     // Ignore deprecation warnings here - it's all generated code, anyway.
     scalacOptions ++= Seq(
       "-Wconf:cat=deprecation:silent"
-    ) ++ scala3MigrationOption(scalaVersion.value),
+    ),
     smithy4sDependencies ++= Seq(
       "com.disneystreaming.smithy" % "aws-cloudwatch-spec" % "2023.02.10",
       "com.disneystreaming.smithy" % "aws-ec2-spec" % "2023.02.10"
     ),
     libraryDependencies ++= Seq(
       Dependencies.Http4s.emberClient.value,
-      Dependencies.slf4jNop
+      Dependencies.Slf4jSimple % Runtime
     ),
     run / fork := true
   )

modules/aws-http4s/src/smithy4s/aws/internals/AwsEc2QueryCodecs.scala

@@ -23,9 +23,10 @@ import cats.effect.Concurrent
 import cats.syntax.all._
 import fs2.compression.Compression
 import smithy.api.XmlName
-import smithy4s.Endpoint
+import smithy4s._
 import smithy4s.http._
 import smithy4s.http4s.kernel._
+import smithy4s.xml.internals.XmlStartingPath
 
 private[aws] object AwsEcsQueryCodecs {
 
@@ -41,13 +42,8 @@ private[aws] object AwsEcsQueryCodecs {
             // These are set to fulfil the requirements of
             // https://smithy.io/2.0/aws/protocols/aws-ec2-query-protocol.html?highlight=ec2%20query%20protocol#query-key-resolution.
             // without UrlFormDataEncoderSchemaVisitor having to be more aware
-            // than necessary of these protocol quirks (having it be aware of
-            // XmlName and XmlFlattened already feels like too much - perhaps in
-            // a future change UrlFormDataEncoderSchemaVisitor can work with
-            // better-named hints, and we can use this same transformation
-            // approach in AwsQueryCodecs to translate the AWS XML hints to
-            // those new hints).
-            ignoreXmlFlattened = true,
+            // than necessary of these protocol quirks.
+            ignoreUrlFormFlattened = true,
             capitalizeStructAndUnionMemberNames = true,
             action = endpoint.id.name,
             version = version
@@ -56,22 +52,16 @@ private[aws] object AwsEcsQueryCodecs {
             // This pre-processing works in collaboration with the passing of
             // the capitalizeStructAndUnionMemberNames flags to
             // UrlFormDataEncoderSchemaVisitor.
-            smithy4s.schema.Schema.transformHintsTransitivelyK(hints =>
+            Schema.transformHintsTransitivelyK(hints =>
               hints.memberHints.get(Ec2QueryName) match {
                 case Some(ec2QueryName) =>
-                  hints.addMemberHints(
-                    XmlName(ec2QueryName.value)
-                  )
+                  hints.addMemberHints(XmlName(ec2QueryName.value))
 
                 case None =>
                   hints.memberHints.get(XmlName) match {
                     case Some(xmlName) =>
-                      hints.addMemberHints(
-                        XmlName(xmlName.value.capitalize)
-                      )
-
-                    case None =>
-                      hints
+                      hints.addMemberHints(XmlName(xmlName.value.capitalize))
+                    case None => hints
                   }
               }
             )
@@ -91,23 +81,15 @@ private[aws] object AwsEcsQueryCodecs {
           AwsXmlCodecs
             .responseDecoderCompilers[F]
             .contramapSchema(
-              smithy4s.schema.Schema.transformHintsLocallyK(
-                _ ++ smithy4s.Hints(
-                  smithy4s.xml.internals.XmlStartingPath(
-                    List(responseTag)
-                  )
-                )
+              Schema.transformHintsLocallyK(
+                _ ++ Hints(XmlStartingPath(List(responseTag)))
               )
             )
         val errorDecoderCompilers = AwsXmlCodecs
           .responseDecoderCompilers[F]
           .contramapSchema(
-            smithy4s.schema.Schema.transformHintsLocallyK(
-              _ ++ smithy4s.Hints(
-                smithy4s.xml.internals.XmlStartingPath(
-                  List("Response", "Errors", "Error")
-                )
-              )
+            Schema.transformHintsLocallyK(
+              _ ++ Hints(XmlStartingPath(List("Response", "Errors", "Error")))
             )
           )
 
@@ -122,14 +104,15 @@ private[aws] object AwsEcsQueryCodecs {
               val shapeName = alt.schema.shapeId.name
               alt.hints.get(AwsQueryError).map(_.code).map(_ -> shapeName)
             }.toMap
-            (errorCode: String) => mapping.getOrElse(errorCode, errorCode)
+            errorCode => mapping.getOrElse(errorCode, errorCode)
         }
         val errorDiscriminator = AwsErrorTypeDecoder
           .fromResponse(errorDecoderCompilers)
           .andThen(_.map(_.map {
             case HttpDiscriminator.NameOnly(name) =>
               HttpDiscriminator.NameOnly(errorNameMapping(name))
-            case other => other
+            case other =>
+              other
           }))
 
         val make = UnaryClientCodecs.Make[F](

modules/aws-http4s/src/smithy4s/aws/internals/AwsQueryCodecs.scala

@@ -18,18 +18,21 @@ package smithy4s.aws
 package internals
 
 import _root_.aws.protocols.AwsQueryError
+import alloy.UrlFormFlattened
+import alloy.UrlFormName
 import cats.effect.Concurrent
 import cats.syntax.all._
 import fs2.compression.Compression
 import org.http4s.EntityEncoder
-import smithy4s.Endpoint
+import smithy.api.XmlFlattened
+import smithy.api.XmlName
+import smithy4s._
 import smithy4s.codecs.PayloadPath
-import smithy4s.http.Metadata
 import smithy4s.http._
 import smithy4s.http4s.kernel._
 import smithy4s.kinds.PolyFunction
 import smithy4s.schema.CachedSchemaCompiler
-import smithy4s.Blob
+import smithy4s.xml.internals.XmlStartingPath
 
 private[aws] object AwsQueryCodecs {
 
@@ -48,7 +51,7 @@ private[aws] object AwsQueryCodecs {
         )
         val requestEncoderCompilersWithCompression = transformEncoders(
           requestEncoderCompilers[F](
-            ignoreXmlFlattened = false,
+            ignoreUrlFormFlattened = false,
             capitalizeStructAndUnionMemberNames = false,
             action = endpoint.id.name,
             version = version
@@ -61,23 +64,15 @@ private[aws] object AwsQueryCodecs {
           AwsXmlCodecs
             .responseDecoderCompilers[F]
             .contramapSchema(
-              smithy4s.schema.Schema.transformHintsLocallyK(
-                _ ++ smithy4s.Hints(
-                  smithy4s.xml.internals.XmlStartingPath(
-                    List(responseTag, resultTag)
-                  )
-                )
+              Schema.transformHintsLocallyK(
+                _ ++ Hints(XmlStartingPath(List(responseTag, resultTag)))
               )
             )
         val errorDecoderCompilers = AwsXmlCodecs
           .responseDecoderCompilers[F]
           .contramapSchema(
-            smithy4s.schema.Schema.transformHintsLocallyK(
-              _ ++ smithy4s.Hints(
-                smithy4s.xml.internals.XmlStartingPath(
-                  List("ErrorResponse", "Error")
-                )
-              )
+            Schema.transformHintsLocallyK(
+              _ ++ Hints(XmlStartingPath(List("ErrorResponse", "Error")))
             )
           )
         // Takes the `@awsQueryError` trait into consideration to decide how to
@@ -91,14 +86,15 @@ private[aws] object AwsQueryCodecs {
               val shapeName = alt.schema.shapeId.name
               alt.hints.get(AwsQueryError).map(_.code).map(_ -> shapeName)
             }.toMap
-            (errorCode: String) => mapping.getOrElse(errorCode, errorCode)
+            errorCode => mapping.getOrElse(errorCode, errorCode)
         }
         val errorDiscriminator = AwsErrorTypeDecoder
           .fromResponse(errorDecoderCompilers)
           .andThen(_.map(_.map {
             case HttpDiscriminator.NameOnly(name) =>
               HttpDiscriminator.NameOnly(errorNameMapping(name))
-            case other => other
+            case other =>
+              other
           }))
 
         val make = UnaryClientCodecs.Make[F](
@@ -112,43 +108,63 @@ private[aws] object AwsQueryCodecs {
     }
 
   def requestEncoderCompilers[F[_]: Concurrent](
-      ignoreXmlFlattened: Boolean,
+      ignoreUrlFormFlattened: Boolean,
       capitalizeStructAndUnionMemberNames: Boolean,
       action: String,
       version: String
   ): CachedSchemaCompiler[RequestEncoder[F, *]] = {
     val urlFormEntityEncoderCompilers = UrlForm
       .Encoder(
-        ignoreXmlFlattened = ignoreXmlFlattened,
+        ignoreUrlFormFlattened = ignoreUrlFormFlattened,
         capitalizeStructAndUnionMemberNames =
           capitalizeStructAndUnionMemberNames
       )
       .mapK(
         new PolyFunction[UrlForm.Encoder, EntityEncoder[F, *]] {
           def apply[A](fa: UrlForm.Encoder[A]): EntityEncoder[F, A] =
-            urlFormEntityEncoder[F].contramap((a: A) =>
+            urlFormEntityEncoder[F].contramap(a =>
               UrlForm(
-                formData = UrlForm.FormData.MultipleValues(
-                  values = Vector(
-                    UrlForm.FormData.PathedValue(PayloadPath("Action"), action),
-                    UrlForm.FormData
-                      .PathedValue(PayloadPath("Version"), version)
-                  ) ++ fa.encode(a).formData.values
-                )
+                List(
+                  UrlForm.FormData(PayloadPath("Action"), Some(action)),
+                  UrlForm.FormData(PayloadPath("Version"), Some(version))
+                ) ++ fa.encode(a).values
               )
             )
         }
       )
-    RequestEncoder.restSchemaCompiler[F](
-      metadataEncoderCompiler = Metadata.AwsEncoder,
-      entityEncoderCompiler = urlFormEntityEncoderCompilers,
-      // We have to set this so that a body is produced even in the case where a
-      // top-level struct input is empty. If it wasn't then the contramap above
-      // wouldn't have the required effect because there would be no UrlForm to
-      // add Action and Version to (literally no UrlForm value - not just an
-      // empty one).
-      writeEmptyStructs = true
-    )
+    RequestEncoder
+      .restSchemaCompiler[F](
+        metadataEncoderCompiler = Metadata.AwsEncoder,
+        entityEncoderCompiler = urlFormEntityEncoderCompilers,
+        // We have to set this so that a body is produced even in the case where
+        // a top-level struct input is empty. If it wasn't then the contramap
+        // above wouldn't have the required effect because there would be no
+        // UrlForm to add Action and Version to (literally no UrlForm value -
+        // not just an empty one).
+        writeEmptyStructs = true
+      )
+      .contramapSchema(
+        // The AWS protocol works in terms of XmlFlattened and XmlName hints,
+        // even for the input side, which is most definitely _not_ XML. Partly
+        // because that seems odd, but mostly so that the URL form support can
+        // be completely agnostic of AWS protocol details, they work with their
+        // own more appropriately named hints - which is what necessitates the
+        // translation here.
+        Schema.transformHintsTransitivelyK { hints =>
+          def translateFlattened(hints: Hints): Hints =
+            hints.memberHints.get(XmlFlattened) match {
+              case Some(_) => hints.addMemberHints(UrlFormFlattened())
+              case None    => hints
+            }
+          def translateName(hints: Hints): Hints =
+            hints.memberHints.get(XmlName) match {
+              case Some(XmlName(name)) =>
+                hints.addMemberHints(UrlFormName(name))
+              case None => hints
+            }
+          (translateFlattened _ andThen translateName _)(hints)
+        }
+      )
   }
 
   private def urlFormEntityEncoder[F[_]]: EntityEncoder[F, UrlForm] =

modules/sandbox/src/Sandbox.scala → modules/aws-sandbox/src/smithy4s/sandbox/aws/Main.scala

@@ -14,10 +14,14 @@
  *  limitations under the License.
  */
 
+package smithy4s
+package sandbox
+package aws
+
 import cats.effect._
 import com.amazonaws.cloudwatch
 import com.amazonaws.ec2
-import org.http4s.client.middleware._
+import org.http4s.client.middleware.RequestLogger
 import org.http4s.ember.client.EmberClientBuilder
 import smithy4s.aws._
 
@@ -72,8 +76,7 @@ object Main extends IOApp.Simple {
         .map(
           RequestLogger.colored(
             logHeaders = true,
-            logBody = true,
-            logAction = Some(IO.println _)
+            logBody = true
           )
         )
       awsCredentialsProvider = new AwsCredentialsProvider[IO]

modules/bootstrapped/test/src/smithy4s/BlobSpec.scala

@@ -29,6 +29,12 @@ class BlobSpec() extends FunSuite {
 
   test("equals depends on underlying data structure") {
     assert(Blob("foo") != Blob(ByteBuffer.wrap("foo".getBytes)))
+    assert(Blob("foo") == Blob("foo"))
+    assert(
+      Blob(ByteBuffer.wrap("foo".getBytes)) == Blob(
+        ByteBuffer.wrap("foo".getBytes)
+      )
+    )
   }
 
   test("ByteBufferBlob.toArray is idempotent, instantiation-wise") {