Add ConfigValueReader(s) for PulumiEnum(s)

- add stringEnumReader,
booleanEnumReader,
intEnumReader, doubleEnumReader to ConfigValueReader

codegen/src/CodeGen.scala

@@ -127,7 +127,10 @@ class CodeGen(implicit
     pulumiPackage.parsedTypes.flatMap { case (coordinates, typeDefinition) =>
       typeDefinition match {
         case enumDef: EnumTypeDefinition =>
-          sourceFilesForEnum(typeCoordinates = coordinates, enumDefinition = enumDef)
+          sourceFilesForEnum(
+            typeCoordinates = coordinates,
+            enumDefinition = enumDef
+          )
         case objectDef: ObjectTypeDefinition =>
           sourceFilesForObjectType(
             typeCoordinates = coordinates,
@@ -144,7 +147,7 @@ class CodeGen(implicit
   ): Seq[SourceFile] = {
     val classCoordinates = typeCoordinates.asEnumClass
 
-    val enumClassName = classCoordinates.definitionTermName.getOrElse(
+    val enumClassName = classCoordinates.definitionTypeName.getOrElse(
       throw GeneralCodegenException(
         s"Class name for ${classCoordinates.typeRef} could not be found"
       )
@@ -191,6 +194,7 @@ class CodeGen(implicit
           |  override val allInstances: Seq[${enumClassName}] = Seq(
           |${instances.map(instance => s"    ${instance._2.syntax}").mkString(",\n")}
           |  )
+          |  given besom.types.EnumCompanion[${valueType}, ${enumClassName}] = this
           |""".stripMargin.parse[Source].get
 
     Seq(

codegen/src/CodeGen.test.scala

@@ -379,6 +379,7 @@ class CodeGenTest extends munit.FunSuite {
              |    SupplementalServicing,
              |    PremiumAssurance
              |  )
+             |  given besom.types.EnumCompanion[String, SupportType] = this
              |""".stripMargin,
         "src/windowsesu/MultipleActivationKeyArgs.scala" ->
           """|package besom.api.azurenative.windowsesu
@@ -459,6 +460,7 @@ class CodeGenTest extends munit.FunSuite {
              |    NotRequired,
              |    Required
              |  )
+             |  given besom.types.EnumCompanion[String, UserConfirmation] = this
              |""".stripMargin,
         "src/hybriddata/JobDefinitionArgs.scala" ->
           """|package besom.api.azurenative.hybriddata

core/src/main/scala/besom/internal/ConfigValueReader.scala

@@ -1,5 +1,6 @@
 package besom.internal
 
+import besom.types.{BooleanEnum, EnumCompanion, IntegerEnum, NumberEnum, StringEnum}
 import spray.json.*
 
 import scala.util.Try
@@ -23,6 +24,14 @@ object ConfigValueReader:
   given jsonReader: ConfigValueReader[JsValue] with
     override def read(key: String, rawValue: String): Either[Exception, JsValue] =
       Try(rawValue.parseJson).toEither.left.map(e => ConfigError(s"Config value '$key' is not a valid JSON: $rawValue", e))
+  given stringEnumReader[E <: StringEnum, C <: EnumCompanion[String, E]](using ec: C): ConfigValueReader[E] with
+    override def read(key: String, rawValue: String): Either[Exception, E] = ec.fromValue(rawValue)
+  given booleanEnumReader[E <: BooleanEnum, C <: EnumCompanion[Boolean, E]](using ec: C): ConfigValueReader[E] with
+    override def read(key: String, rawValue: String): Either[Exception, E] = ec.fromValue(rawValue.toBoolean)
+  given intEnumReader[E <: IntegerEnum, C <: EnumCompanion[Int, E]](using ec: C): ConfigValueReader[E] with
+    override def read(key: String, rawValue: String): Either[Exception, E] = ec.fromValue(rawValue.toInt)
+  given doubleEnumReader[E <: NumberEnum, C <: EnumCompanion[Double, E]](using ec: C): ConfigValueReader[E] with
+    override def read(key: String, rawValue: String): Either[Exception, E] = ec.fromValue(rawValue.toDouble)
   given objectReader[A: JsonReader]: ConfigValueReader[A] with
     override def read(key: String, rawValue: String): Either[Exception, A] =
       Try(rawValue.parseJson.convertTo[A]).toEither.left.map(e =>

core/src/main/scala/besom/types.scala

@@ -1,13 +1,14 @@
 package besom
 
+import besom.internal.*
+import besom.internal.ProtobufUtil.*
+import besom.util.*
+import com.google.protobuf.struct.*
+
 import scala.compiletime.*
 import scala.compiletime.ops.string.*
 import scala.language.implicitConversions
 import scala.util.Try
-import com.google.protobuf.struct.*
-import besom.internal.ProtobufUtil.*
-import besom.util.*
-import besom.internal.*
 
 object types:
   // TODO: replace these stubs with proper implementations
@@ -328,7 +329,11 @@ object types:
 
   trait EnumCompanion[V, E <: PulumiEnum[V]](enumName: String):
     def allInstances: Seq[E]
-    private lazy val valuesToInstances: Map[Any, E] = allInstances.map(instance => instance.value -> instance).toMap
+    def fromValue(value: V): Either[Exception, E] = valuesToInstances.get(value).toRight(
+      left = Exception(s"`${value}` is not a valid value of `${enumName}`")
+    )
+
+    private lazy val valuesToInstances: Map[V, E] = allInstances.map(instance => instance.value -> instance).toMap
 
     extension [A](a: A)
       def asValueAny: Value = a match

core/src/test/scala/besom/internal/ConfigTest.scala

@@ -154,8 +154,59 @@ class ConfigTest extends munit.FunSuite {
     assertEquals(actual, expected)
   }
 
+  sealed abstract class Region(val name: String, val value: String) extends besom.types.StringEnum
+  object Region extends EnumCompanion[String, Region]("Region"):
+    object AFSouth1 extends Region("AFSouth1", "af-south-1")
+    object APEast1 extends Region("APEast1", "ap-east-1")
+    object APNortheast1 extends Region("APNortheast1", "ap-northeast-1")
+    object APNortheast2 extends Region("APNortheast2", "ap-northeast-2")
+    override val allInstances: Seq[Region] = Seq(
+      AFSouth1,
+      APEast1,
+      APNortheast1,
+      APNortheast2
+    )
+    given EnumCompanion[String, Region] = this
+
+  testConfig("get StringEnum")(
+    configMap = Map("prov:region" -> "ap-northeast-1"),
+    configSecretKeys = Set.empty,
+    tested = Codegen.config[Region]("prov")(
+      key = "region",
+      isSecret = false,
+      environment = Nil,
+      default = None
+    )
+  ) { actual =>
+    val expected = OutputData(Some(Region.APNortheast1))
+    assertEquals(actual, expected)
+  }
+
+
+  sealed abstract class Switch(val name: String, val value: Boolean) extends besom.types.BooleanEnum
+  object Switch extends EnumCompanion[Boolean, Switch]("Switch"):
+    object On extends Switch("On", true)
+    object Off extends Switch("Off", false)
+    override val allInstances: Seq[Switch] = Seq(On, Off)
+    given EnumCompanion[Boolean, Switch] = this
+
+  testConfig("get BooleanEnum")(
+    configMap = Map("prov:switch" -> "false"),
+    configSecretKeys = Set.empty,
+    tested = Codegen.config[Switch]("prov")(
+      key = "switch",
+      isSecret = false,
+      environment = Nil,
+      default = None
+    )
+  ) { actual =>
+    val expected = OutputData(Some(Switch.Off))
+    assertEquals(actual, expected)
+  }
+
   case class Foo(a: Int, b: Int)
-  given JsonFormat[Foo] = jsonFormat2(Foo.apply)
+  object Foo:
+    given JsonFormat[Foo] = jsonFormat2(Foo.apply)
   testConfig("get case class Foo")(
     configMap = Map("foo" -> """{"a":1,"b":2}"""),
     configSecretKeys = Set("foo"),
@@ -170,7 +221,7 @@ class ConfigTest extends munit.FunSuite {
   case class Bar(a: Int, b: Int)
   testConfig("get case class Bar compile error")(
     configMap = Map("bar" -> """{"a":1,"b":2}"""),
-    configSecretKeys = Set.empty,
+    configSecretKeys = Set.empty
   ) {
     assertNoDiff(
       compileErrors("""config.getObject[Bar]("bar")"""),
@@ -190,7 +241,7 @@ class ConfigTest extends munit.FunSuite {
 
   testConfig("require case Bar class compile error")(
     configMap = Map("bar" -> """{"a":1,"b":2}"""),
-    configSecretKeys = Set.empty,
+    configSecretKeys = Set.empty
   ) {
     assertNoDiff(
       compileErrors("""config.requireObject[Bar]("bar")"""),
@@ -262,7 +313,7 @@ class ConfigTest extends munit.FunSuite {
     assertEquals(outputData2, OutputData(Some("bar")))
   }
 
-  testConfig("Codegen.config") (
+  testConfig("Codegen.config - List")(
     configMap = Map("prov:names" -> """["a","b","c","super secret name"]"""),
     configSecretKeys = Set.empty,
     tested = Codegen.config[List[String]]("prov")(
@@ -272,7 +323,7 @@ class ConfigTest extends munit.FunSuite {
       default = None
     )
   ) { actual =>
-      val expected     = OutputData(Some(List("a", "b", "c", "super secret name")), isSecret = true)
-      assertEquals(actual, expected)
+    val expected = OutputData(Some(List("a", "b", "c", "super secret name")), isSecret = true)
+    assertEquals(actual, expected)
   }
 }