Dynamic: support open enums

CHANGELOG.md

@@ -1,4 +1,10 @@
-# 0.18.0 (in progress)
+# 0.18.1
+
+## Open enum support in Dynamic module
+
+In 0.18.0, support was added for [open enums](https://disneystreaming.github.io/smithy4s/docs/codegen/customisation/open-enums) in smithy4s-generated code. This release extends that support to runtime (dynamic) schemas.
+
+# 0.18.0
 
 ## Behavioural changes
 

modules/core/src/smithy4s/schema/EnumValue.scala

@@ -24,6 +24,9 @@ case class EnumValue[E](
     name: String,
     hints: Hints
 ) {
+  def map[A](f: E => A): EnumValue[A] =
+    copy(value = f(value))
+
   def transformHints(f: Hints => Hints): EnumValue[E] =
     copy(hints = f(hints))
 }

modules/dynamic/src/smithy4s/dynamic/internals/DynamicModelCompiler.scala

@@ -168,18 +168,11 @@ private[dynamic] object Compiler {
         shapeId: ShapeId,
         traits: Map[IdRef, Document],
         lSchema: Eval[Schema[A]]
-    ): Unit =
-      updateWithHints(shapeId, allHints(traits), lSchema)
-
-    private def updateWithHints[A](
-        shapeId: ShapeId,
-        hints: Hints,
-        lSchema: Eval[Schema[A]]
     ): Unit = {
       schemaMap += (shapeId -> lSchema.map { sch =>
         sch
           .withId(shapeId)
-          .addHints(hints)
+          .addHints(allHints(traits))
           .asInstanceOf[Schema[DynData]]
       })
     }
@@ -190,12 +183,6 @@ private[dynamic] object Compiler {
         schema: Schema[A]
     ): Unit = update(shapeId, traits, Eval.now(schema))
 
-    private def updateWithHints[A](
-        shapeId: ShapeId,
-        hints: Hints,
-        lSchema: Schema[A]
-    ): Unit = updateWithHints(shapeId, hints, Eval.now(lSchema))
-
     def default: Unit = ()
 
     override def integerShape(id: ShapeId, shape: IntegerShape): Unit =
@@ -256,9 +243,36 @@ private[dynamic] object Compiler {
             )
           }
 
-      val theEnum = stringEnumeration(values, values)
+      update(id, shape.traits, makeStringEnum(id, values, shape.traits))
+    }
+
+    private def makeStringEnum(
+        id: ShapeId,
+        values: List[EnumValue[Int]],
+        traits: Map[IdRef, Document]
+    ) = {
+      if (traits.contains(IdRef("alloy#openEnum"))) {
+        // the runtime representation of normal enums is Int, but for open enums it's String to support arbitrary unknown values.
+        val mappedValues = values.map(_.map(_.asLeft[String]))
+
+        enumeration[Either[Int, String]](
+          _.fold(
+            mappedValues,
+            unknownValueString =>
+              EnumValue(
+                stringValue = unknownValueString,
+                intValue = -1,
+                value = unknownValueString.asRight[Int],
+                name = "$Unknown",
+                hints = Hints.empty
+              )
+          ),
+          EnumTag.OpenStringEnum(_.asRight[Int]),
+          mappedValues
+        )
+      } else
+        stringEnumeration(values, values)
 
-      update(id, shape.traits, theEnum)
     }
 
     override def intEnumShape(id: ShapeId, shape: IntEnumShape): Unit = {
@@ -289,14 +303,31 @@ private[dynamic] object Compiler {
 
       val valueList = values.map(_._2).toList.sortBy(_.intValue)
 
-      val theEnum = intEnumeration(values.apply, valueList)
+      if (shape.traits.contains(IdRef("alloy#openEnum"))) {
+        val theEnum = enumeration[Int](
+          v =>
+            values.getOrElse(
+              v,
+              EnumValue(
+                stringValue = v.toString,
+                intValue = v,
+                value = v,
+                name = "$Unknown",
+                hints = Hints.empty
+              )
+            ),
+          EnumTag.OpenIntEnum(identity),
+          valueList
+        )
 
-      updateWithHints(
-        id, {
-          allHints(shape.traits)
-        },
-        theEnum
-      )
+        update(id, shape.traits, theEnum)
+      } else {
+        update(
+          id,
+          shape.traits,
+          intEnumeration(values, valueList)
+        )
+      }
     }
 
     override def booleanShape(id: ShapeId, shape: BooleanShape): Unit =
@@ -325,11 +356,10 @@ private[dynamic] object Compiler {
                 hints = Hints.empty
               )
           }
-          val fromOrdinal = values(_: Int)
           update(
             id,
             shape.traits,
-            enumeration(fromOrdinal, EnumTag.ClosedStringEnum, values)
+            makeStringEnum(id, values, shape.traits)
           )
         }
         case _ => update(id, shape.traits, string)

modules/dynamic/test/src-jvm/smithy4s/dynamic/EnumSpec.scala

@@ -16,7 +16,6 @@
 
 package smithy4s.dynamic
 
-import munit.FunSuite
 import smithy4s.ShapeId
 import smithy4s.schema.Schema.EnumerationSchema
 import munit.Location
@@ -25,7 +24,7 @@ import smithy4s.Hints
 import smithy4s.Document
 import smithy4s.schema.Schema
 
-class EnumSpec extends FunSuite {
+class EnumSpec extends DummyIO.Suite {
   val model = """
     $version: "2"
     namespace example
@@ -61,6 +60,25 @@ class EnumSpec extends FunSuite {
       @deprecated ICE,
       FIRE
     }
+
+    @alloy#openEnum
+    enum OpenStringEnum {
+      ICE,
+      FIRE
+    }
+
+    @alloy#openEnum
+    intEnum OpenIntEnum {
+      ICE = 42,
+      FIRE = 10
+    }
+
+    @enum([
+      { value: "Vanilla" },
+      { value: "Ice" }
+    ])
+    @alloy#openEnum
+    string Open10Enum
   """
 
   val compiled = Utils.compile(model)
@@ -230,4 +248,46 @@ class EnumSpec extends FunSuite {
       )
     )
   }
+
+  test("Smithy 2.0 open string enums can be decoded to UNKNOWN") {
+    compiled.map { index =>
+      val schema = index
+        .getSchema(ShapeId("example", "OpenStringEnum"))
+        .getOrElse(fail("Error: shape missing"))
+
+      decodeEncodeCheck(schema)(Document.fromString("not a known value"))
+    }
+  }
+
+  test("Smithy 2.0 open int enums can be decoded to UNKNOWN") {
+    compiled.map { index =>
+      val schema = index
+        .getSchema(ShapeId("example", "OpenIntEnum"))
+        .getOrElse(fail("Error: shape missing"))
+
+      decodeEncodeCheck(schema)(Document.fromInt(52))
+    }
+  }
+
+  test("Smithy 1.0 open string enums can be decoded to UNKNOWN") {
+    compiled.map { index =>
+      val schema = index
+        .getSchema(ShapeId("example", "Open10Enum"))
+        .getOrElse(fail("Error: shape missing"))
+
+      decodeEncodeCheck(schema)(Document.fromString("not a known value"))
+    }
+  }
+
+  private def decodeEncodeCheck[A](schema: Schema[A])(input: Document) = {
+    val decoded = Document.Decoder
+      .fromSchema(schema)
+      .decode(input)
+      .toTry
+      .get
+
+    val encoded = Document.Encoder.fromSchema(schema).encode(decoded)
+
+    assertEquals(encoded, input)
+  }
 }

modules/dynamic/test/src-jvm/smithy4s/dynamic/PlatformUtils.scala

@@ -34,6 +34,10 @@ private[dynamic] trait PlatformUtils { self: Utils.type =>
       SModel
         .assembler()
         .addUnparsedModel("dynamic.smithy", string)
+        .addImport(
+          // Alloy open enums
+          getClass().getClassLoader.getResource("META-INF/smithy/enums.smithy")
+        )
         .assemble()
         .unwrap()
     )