Sync series/0.18 into series/0.19 - Oct2025 (#1854)

lewisjkl · yisraelU · kubukoz · web-flow · commit 0d807bc5cea0 · 2025-11-03T15:58:17.000-07:00
* add in scripted test for refinement usage * add headers * Update test file to include run command * Update alloy-core, alloy-openapi, ... to 0.3.33 * Avoid throwing MatchError when surfacing unknown errors (#1846) * remove usage of alloy to test refinements * config-based dynamic hint enable (#1848) * config-based dynamic hint enable * update changelog * use namespace patterns --------- Co-authored-by: yisraelu <ysrlunion@gmail.com> Co-authored-by: Scala Steward <kubukoz@gmail.com>
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -69,6 +69,12 @@ The behavior of `@default(null)` has changed to better align with Smithy semanti
 
 ## `Bijection` does no longer extends `Function` in [#1794](https://github.com/disneystreaming/smithy4s/pull/1794)
 Prevents using it as an implicit conversion in Scala 2
+
+# 0.18.44
+
+* Avoid an issue in which `SurfaceError` transformations would throw a `MatchError` upon being called for an operation that doesn't declare errors in [#1846](https://github.com/disneystreaming/smithy4s/pull/1846).
+* Add option to configure Dynamic Hint Bindings via Smithy metadata in [#1848](https://github.com/disneystreaming/smithy4s/pull/1848)
+
 # 0.18.43
 
 * Add support for generating dynamic hint bindings in [#1816](https://github.com/disneystreaming/smithy4s/pull/1816)
diff --git a/modules/bootstrapped/src/generated/smithy4s/example/ShouldHaveDynamicBinding.scala b/modules/bootstrapped/src/generated/smithy4s/example/ShouldHaveDynamicBinding.scala
@@ -15,6 +15,7 @@ object ShouldHaveDynamicBinding extends ShapeTag.Companion[ShouldHaveDynamicBind
   val hints: Hints = Hints(
     smithy.api.Since("1"),
     Hints.dynamic(ShapeId("smithy4s.example", "testDynamicBinding"), smithy4s.Document.obj("str" -> smithy4s.Document.fromString("test"))),
+    Hints.dynamic(ShapeId("smithy4s.example.dynamic_traits", "thisWillBeDynamic"), smithy4s.Document.obj("test" -> smithy4s.Document.fromDouble(101.0d))),
   ).lazily
 
   // constructor using the original order from the spec
diff --git a/modules/bootstrapped/test/src/smithy4s/TransformationSpec.scala b/modules/bootstrapped/test/src/smithy4s/TransformationSpec.scala
@@ -17,6 +17,7 @@
 package smithy4s
 
 import smithy4s.example._
+import smithy4s.example.greet._
 import smithy4s.kinds.PolyFunction
 import munit._
 import scala.util.{Failure, Success, Try}
@@ -109,4 +110,39 @@ class TransformationSpec() extends FunSuite {
 
   }
 
+  test(
+    "surfacing unhandled errors on an operation without errors doesn't throw"
+  ) {
+    val e = new Exception("Expected, but unexpected error")
+
+    val impl: GreetService[Try] =
+      new GreetService.Default[Try](Failure(e))
+
+    type Result[E, A] = Either[Either[Throwable, E], A]
+
+    // If you hit this, you should make sure either that Greet has no errors
+    // or switch to another operation that matches this assumption.
+    // Otherwise, this test is useless.
+    require(
+      GreetServiceOperation.Greet.error.isEmpty,
+      "The issue we're testing against can only be reproduced with error-unaware operations."
+    )
+
+    val result = impl
+      .transform(new Transformation.SurfaceError[Try, Result] {
+        def apply[E, A](fa: Try[A], projectError: Throwable => Option[E])
+            : Result[E, A] =
+          fa match {
+            case Success(value) => Right(value)
+            case Failure(exception) =>
+              projectError(exception).fold[Result[E, A]](Left(Left(exception)))(
+                e => Left(Right(e))
+              )
+          }
+      })
+      .greet("hello")
+
+    expect.same(result, Left(Left(e)))
+  }
+
 }
diff --git a/modules/codegen-plugin/src/sbt-test/codegen-plugin/refinements/src/main/scala/refinements/Refinements.scala b/modules/codegen-plugin/src/sbt-test/codegen-plugin/refinements/src/main/scala/refinements/Refinements.scala
@@ -22,6 +22,7 @@ import java.time.LocalDate
 import scala.util.Try
 import smithy4s.{Refinement, RefinementProvider}
 
+
 object Refinements {
   object dateFormat {
     private def newDate(value: String): Either[String, LocalDate] =
diff --git a/modules/codegen-plugin/src/sbt-test/codegen-plugin/refinements/test b/modules/codegen-plugin/src/sbt-test/codegen-plugin/refinements/test
@@ -1 +1 @@
-> run
+> run
diff --git a/modules/codegen/src/smithy4s/codegen/internals/SmithyToIR.scala b/modules/codegen/src/smithy4s/codegen/internals/SmithyToIR.scala
@@ -122,6 +122,17 @@ private[codegen] class SmithyToIR(
       .flatMap(f => DefaultRenderMode.fromString(f.getValue))
       .getOrElse(DefaultRenderMode.Full)
 
+  private val smithy4sRenderDynamicHintNamespacePatterns
+      : Set[NamespacePattern] =
+    model
+      .getMetadata()
+      .asScala
+      .get("smithy4sRenderDynamicHintNamespacePatterns")
+      .toSet
+      .flatMap((n: Node) => n.asArrayNode().asScala)
+      .flatMap(_.getElements().asScala)
+      .flatMap(_.asStringNode().asScala.map(n => NamespacePattern(n.getValue)))
+
   private def fieldModifier(member: MemberShape): Field.Modifier = {
     val hasRequired = member.hasTrait(classOf[RequiredTrait])
     val hasNullable = member.hasTrait(classOf[alloy.NullableTrait])
@@ -1360,7 +1371,11 @@ private[codegen] class SmithyToIR(
   private def unfoldTraitNonConstraint(tr: Trait): Hint = {
     val renderDynamic = model
       .expectShape(tr.toShapeId)
-      .hasTrait(classOf[smithy4s.meta.RenderAsDynamicBindingTrait])
+      .hasTrait(
+        classOf[smithy4s.meta.RenderAsDynamicBindingTrait]
+      ) || smithy4sRenderDynamicHintNamespacePatterns.exists(
+      _.matches(tr.toShapeId().namespace)
+    )
     if (renderDynamic) Hint.DynamicBinding(tr.toShapeId, tr.toNode)
     else
       Hint.Native(
diff --git a/modules/codegen/test/src/smithy4s/codegen/internals/DynamicHintRenderingSpec.scala b/modules/codegen/test/src/smithy4s/codegen/internals/DynamicHintRenderingSpec.scala
@@ -41,7 +41,71 @@ final class DynamicHintRenderingSpec extends munit.FunSuite {
          |
          |""".stripMargin
 
-    runTest(smithySpec)
+    runTest(smithySpec)()
+  }
+
+  test("dynamic hint rendering mode - config based - exact match namespace") {
+    val smithySpec1 =
+      """|$version: "2.0"
+         |
+         |metadata smithy4sRenderDynamicHintNamespacePatterns = ["test"]
+         |
+         |namespace test
+         |
+         |@trait
+         |structure someTrait {
+         |  @required
+         |  int: Integer
+         |}
+         |""".stripMargin
+
+    val smithySpec2 =
+      """|$version: "2.0"
+         |
+         |namespace foo
+         |
+         |use test#someTrait
+         |
+         |@someTrait(int: 1)
+         |structure Test {
+         | @someTrait(int: 2)
+         | one: String
+         |}
+         |""".stripMargin
+
+    runTest(smithySpec1, smithySpec2)()
+  }
+
+  test("dynamic hint rendering mode - config based - starts with namespace") {
+    val smithySpec1 =
+      """|$version: "2.0"
+         |
+         |metadata smithy4sRenderDynamicHintNamespacePatterns = ["test.*"]
+         |
+         |namespace test.secondary
+         |
+         |@trait
+         |structure someTrait {
+         |  @required
+         |  int: Integer
+         |}
+         |""".stripMargin
+
+    val smithySpec2 =
+      """|$version: "2.0"
+         |
+         |namespace foo
+         |
+         |use test.secondary#someTrait
+         |
+         |@someTrait(int: 1)
+         |structure Test {
+         | @someTrait(int: 2)
+         | one: String
+         |}
+         |""".stripMargin
+
+    runTest(smithySpec1, smithySpec2)(ns = "test.secondary")
   }
 
   test("dynamic hint rendering mode - enum") {
@@ -64,7 +128,7 @@ final class DynamicHintRenderingSpec extends munit.FunSuite {
                         |
                         |""".stripMargin
 
-    runTest(smithySpec)
+    runTest(smithySpec)()
   }
 
   test("dynamic hint rendering mode - union") {
@@ -88,7 +152,7 @@ final class DynamicHintRenderingSpec extends munit.FunSuite {
                         |
                         |""".stripMargin
 
-    runTest(smithySpec)
+    runTest(smithySpec)()
   }
 
   test("dynamic hint rendering mode - primitive") {
@@ -110,7 +174,7 @@ final class DynamicHintRenderingSpec extends munit.FunSuite {
                         |integer Other
                         |""".stripMargin
 
-    runTest(smithySpec)
+    runTest(smithySpec)()
   }
 
   test("dynamic hint rendering mode - service") {
@@ -135,16 +199,18 @@ final class DynamicHintRenderingSpec extends munit.FunSuite {
                         |
                         |""".stripMargin
 
-    runTest(smithySpec)
+    runTest(smithySpec)()
   }
 
-  private def runTest(smithySpec: String)(implicit loc: Location): Unit = {
+  private def runTest(
+      smithySpecs: String*
+  )(ns: String = "test")(implicit loc: Location): Unit = {
     val expect = List(
-      """Hints.dynamic(ShapeId("test", "someTrait"), smithy4s.Document.obj("int" -> smithy4s.Document.fromDouble(1.0d)))""",
-      """Hints.dynamic(ShapeId("test", "someTrait"), smithy4s.Document.obj("int" -> smithy4s.Document.fromDouble(2.0d)))"""
+      s"""Hints.dynamic(ShapeId("$ns", "someTrait"), smithy4s.Document.obj("int" -> smithy4s.Document.fromDouble(1.0d)))""",
+      s"""Hints.dynamic(ShapeId("$ns", "someTrait"), smithy4s.Document.obj("int" -> smithy4s.Document.fromDouble(2.0d)))"""
     )
 
-    val result = TestUtils.generateScalaCode(smithySpec).values.toList
+    val result = TestUtils.generateScalaCode(smithySpecs: _*).values.toList
 
     TestUtils.assertContainsSection(
       files = result,
diff --git a/modules/codegen/test/src/smithy4s/codegen/internals/TestUtils.scala b/modules/codegen/test/src/smithy4s/codegen/internals/TestUtils.scala
@@ -23,11 +23,14 @@ import software.amazon.smithy.model.Model
 object TestUtils {
 
   /** Key is the name (like my.package.name.SomeFile) and the value is the contents of that file */
-  def generateScalaCode(smithySpec: String): Map[String, String] = {
-    val model = Model
+  def generateScalaCode(smithySpecs: String*): Map[String, String] = {
+    val modelA = Model
       .assembler()
       .discoverModels()
-      .addUnparsedModel("foo.smithy", smithySpec)
+    smithySpecs.zipWithIndex.foreach { case (smithySpec, i) =>
+      modelA.addUnparsedModel(s"foo$i.smithy", smithySpec)
+    }
+    val model = modelA
       .assemble()
       .unwrap()
     generateScalaCode(model)
diff --git a/modules/core/src/smithy4s/Transformation.scala b/modules/core/src/smithy4s/Transformation.scala
@@ -88,7 +88,7 @@ object Transformation {
           def apply[I, E, O, SI, SO](op: service.Operation[I, E, O, SI, SO]): G[E,O] = {
             val endpoint = service.endpoint(op)
             val catcher: Throwable => Option[E] = endpoint.error match {
-              case None => PartialFunction.empty[Throwable, Option[E]]
+              case None => Function.const(None)
               case Some(value) => value.liftError(_)
             }
             func.apply(polyFunction(op), catcher)
diff --git a/modules/core/src/smithy4s/schema/Schema.scala b/modules/core/src/smithy4s/schema/Schema.scala
@@ -154,10 +154,15 @@ sealed trait Schema[A]{
   final def isUnit: Boolean = this.shapeId == ShapeId("smithy.api", "Unit")
 
   /**
-    * Turns this schema into an error schema.
+    * Turns this schema into an error schema, using a partial function.
     */
   final def error(unlift: A => Throwable)(lift: PartialFunction[Throwable, A]) : ErrorSchema[A] = ErrorSchema(this, lift.lift, unlift)
 
+  /**
+    * Turns this schema into an error schema.
+    */
+  final def error(unlift: A => Throwable)(lift: Throwable => Option[A]) : ErrorSchema[A] = ErrorSchema(this, lift, unlift)
+
 }
 
 object Schema {
diff --git a/modules/docs/resources/markdown/04-codegen/01-customisation/17-hint-bindings.md b/modules/docs/resources/markdown/04-codegen/01-customisation/17-hint-bindings.md
@@ -6,6 +6,8 @@ title: Hint Bindings
 
 ## Configuration
 
+### Trait Based
+
 If you wish to render dynamic hint bindings, you can do so with a Smithy Trait called `smithy4s.meta#renderAsDynamicBinding`.
 
 ```smithy
@@ -27,6 +29,20 @@ With the above example, any shape using `test#myTrait`, such as `test#Test`, wil
 
 __Note, it is likely that you will want to use the [smithy apply syntax](https://smithy.io/2.0/spec/model.html#applying-traits-externally) to apply this trait rather than putting it directly on the trait. You may also want to use a smithy-level transformation to automatically apply the trait to trait definitions from certain namespaces.__
 
+### Metadata Based
+
+If you want to enable dynamic hint bindings for an entire namespace, you can do so with the `smithy4sRenderDynamicHintNamespacePatterns` metadata key. For example, if we want to render all instances of traits from `foo` namespace as dynamic, we'd set the following:
+
+```smithy
+metadata smithy4sRenderDynamicHintNamespacePatterns = ["foo.*"]
+```
+
+Note that this will set any namespaces under `foo` as dynamic as well. So `foo.bar`, for example, would also be rendered as dynamic, but `food` would not. You can use other patterns, consider the following examples:
+
+- `a.b.c` - exact match, will match only `a.b.c`
+- `a.b.*` - will match `a.b` followed with some segments.
+- `a.b*` - like above, but will also match `a.b` or `a.bc`
+
 ## Justification
 
 The reason for this option is that static hint bindings can cause incompatibility issues when upstream Smithy models (Smithy Prelude, Alloy) change. These issues can pop up because of the fact that Smithy4s code-generates Scala code for these Smithy shapes and packages them as part of Smithy4s Core as opposed to code-generating them at the same time it generates code for the end-user Smithy shapes. This is necessary because the modules of Smithy4s use these shapes to drive their functionality. They need to "know" about these shapes/traits ahead of time in order to build interpreters that work using them. However, when using static hint bindings, there is room for divergence between what was generated by Smithy4s and published in `smithy4s-core` and what the end user application is generating. 
diff --git a/sampleSpecs/dynamic_hint_bindings.smithy b/sampleSpecs/dynamic_hint_bindings.smithy
@@ -3,6 +3,7 @@ $version: "2.0"
 namespace smithy4s.example
 
 use smithy4s.meta#renderAsDynamicBinding
+use smithy4s.example.dynamic_traits#thisWillBeDynamic
 
 @trait
 @renderAsDynamicBinding
@@ -12,6 +13,7 @@ structure testDynamicBinding {
 }
 
 @testDynamicBinding(str: "test")
+@thisWillBeDynamic(test: 101)
 @since("1")
 structure ShouldHaveDynamicBinding {
     @testDynamicBinding(str: "test2", int: 1234)
diff --git a/sampleSpecs/dynamic_traits.smithy b/sampleSpecs/dynamic_traits.smithy
@@ -0,0 +1,10 @@
+$version: "2"
+
+metadata smithy4sRenderDynamicHintNamespacePatterns = ["smithy4s.example.dynamic_traits"]
+
+namespace smithy4s.example.dynamic_traits
+
+@trait
+structure thisWillBeDynamic {
+  test: Integer
+}

Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ object Transformation {`
`88`	`88`	`def apply[I, E, O, SI, SO](op: service.Operation[I, E, O, SI, SO]): G[E,O] = {`
`89`	`89`	`val endpoint = service.endpoint(op)`
`90`	`90`	`val catcher: Throwable => Option[E] = endpoint.error match {`
`91`		`- case None => PartialFunction.empty[Throwable, Option[E]]`
	`91`	`+ case None => Function.const(None)`
`92`	`92`	`case Some(value) => value.liftError(_)`
`93`	`93`	`}`
`94`	`94`	`func.apply(polyFunction(op), catcher)`