Merge pull request #4 from LedgerHQ/update/multiple_libraries

update scala, circe-yaml, tapir and iron.

Author: jnicoulaud-ledger

.g8/module/modules/$moduleFolder$/src/main/scala/pillars/$package$/$Prefix$Loader.scala

@@ -38,7 +38,7 @@ final case class $Prefix$(client: $Prefix$Client) extends Module:
         val probe = new Probe:
             override def component: Component =
                 Component(Component.Name("$lowerCaseModuleName$"), Component.Type.Datastore)
-            override def check: IO[Boolean]    = true.pure[IO]
+            override def check: IO[Boolean]   = true.pure[IO]
         probe.pure[List]
     end probes
 end $Prefix$
@@ -83,10 +83,10 @@ object $Prefix$Config:
     given Codec[$Prefix$Config] = Codec.AsObject.derivedConfigured
 end $Prefix$Config
 
-private type $Prefix$UserConstraint = Not[Blank] DescribedAs "$Prefix$ user must not be blank"
-opaque type $Prefix$User <: String  = String :| $Prefix$UserConstraint
-object $Prefix$User extends RefinedTypeOps[String, $Prefix$UserConstraint, $Prefix$User]
+private type $Prefix$UserConstraint = Not[Blank] `DescribedAs` "$Prefix$ user must not be blank"
+type $Prefix$User                   = $Prefix$User.T
+object $Prefix$User extends RefinedType[String, $Prefix$UserConstraint]
 
-private type $Prefix$PasswordConstraint = Not[Blank] DescribedAs "$Prefix$ password must not be blank"
-opaque type $Prefix$Password <: String  = String :| $Prefix$PasswordConstraint
-object $Prefix$Password extends RefinedTypeOps[String, $Prefix$PasswordConstraint, $Prefix$Password]
+private type $Prefix$PasswordConstraint = Not[Blank] `DescribedAs` "$Prefix$ password must not be blank"
+type $Prefix$Password                   = $Prefix$Password.T
+object $Prefix$Password extends RefinedType[String, $Prefix$PasswordConstraint]

modules/core/src/main/scala/pillars/Config.scala

@@ -101,8 +101,9 @@ object Config:
         case ParsingError(cause: Throwable)           extends ConfigError(ErrorNumber(2))
 
         override def message: Message = this match
-            case ConfigError.MissingEnvironmentVariable(name) => Message(s"Missing environment variable $name".assume)
+            case ConfigError.MissingEnvironmentVariable(name) =>
+                Message.assume(s"Missing environment variable $name")
             case ConfigError.ParsingError(cause)              =>
-                Message(s"Failed to parse configuration: ${cause.getMessage}".assume)
+                Message.assume(s"Failed to parse configuration: ${cause.getMessage}")
     end ConfigError
 end Config

modules/core/src/main/scala/pillars/HttpServer.scala

@@ -85,7 +85,9 @@ object HttpServer:
                 yamlName = openApi.yamlName,
                 contextPath = openApi.contextPath,
                 useRelativePaths = openApi.useRelativePaths,
-                showExtensions = openApi.showExtensions
+                showExtensions = openApi.showExtensions,
+                initializerOptions = openApi.initializerOptions,
+                oAuthInitOptions = openApi.oAuthInitOptions
               )
             ).fromServerEndpoints(endpoints, name, infos.version)
         else Nil
@@ -137,7 +139,9 @@ object HttpServer:
             yamlName: String = "pillars.yaml",
             contextPath: List[String] = Nil,
             useRelativePaths: Boolean = true,
-            showExtensions: Boolean = false
+            showExtensions: Boolean = false,
+            initializerOptions: Option[Map[String, String]] = None,
+            oAuthInitOptions: Option[Map[String, String]] = None
         )
     end Config
 end HttpServer

modules/core/src/main/scala/pillars/Logging.scala

@@ -39,10 +39,10 @@ object Logging:
             case Format.Json => ScribeCirceJsonSupport.writer(config.output.writer)
             case _           => config.output.writer
 
-    private type BufferSizeConstraint = Positive DescribedAs "Buffer size should be positive"
-    opaque type BufferSize <: Int     = Int :| BufferSizeConstraint
+    private type BufferSizeConstraint = Positive `DescribedAs` "Buffer size should be positive"
+    type BufferSize                   = BufferSize.T
 
-    object BufferSize extends RefinedTypeOps[Int, BufferSizeConstraint, BufferSize]
+    object BufferSize extends RefinedType[Int, BufferSizeConstraint]
 
     enum Format:
         case Json

modules/core/src/main/scala/pillars/Observability.scala

@@ -106,8 +106,8 @@ object Observability:
     end Config
 
     private type ServiceNameConstraint = Not[Blank]
-    opaque type ServiceName <: String  = String :| ServiceNameConstraint
-    private object ServiceName extends RefinedTypeOps[String, ServiceNameConstraint, ServiceName]
+    type ServiceName                   = ServiceName.T
+    object ServiceName extends RefinedType[String, ServiceNameConstraint]
 
     extension [A <: String](value: A)
         def toAttribute(name: String): Attribute[String] = Attribute(name, value)

modules/core/src/main/scala/pillars/PillarsError.scala

@@ -54,23 +54,23 @@ object PillarsError:
     private[pillars] final case class PayloadTooLarge(maxLength: Long) extends PillarsError:
         override def code: Code              = Code("ERR")
         override def number: ErrorNumber     = ErrorNumber(Int.MaxValue)
-        override def message: Message        = Message(s"Payload limit ($maxLength) exceeded".refineUnsafe)
+        override def message: Message        = Message.assume(s"Payload limit ($maxLength) exceeded")
         override def status: StatusCode      = StatusCode.PayloadTooLarge
         override def details: Option[String] = Some(s"Payload limit ($maxLength) exceeded")
     end PayloadTooLarge
 
-    private type CodeConstraint = (Not[Empty] & LettersUpperCase) DescribedAs "Code cannot be empty"
-    opaque type Code <: String  = String :| CodeConstraint
+    private type CodeConstraint = (Not[Empty] & LettersUpperCase) `DescribedAs` "Code cannot be empty"
+    type Code                   = Code.T
 
-    object Code extends RefinedTypeOps[String, CodeConstraint, Code]
+    object Code extends RefinedType[String, CodeConstraint]
 
-    private type MessageConstraint = Not[Empty] DescribedAs "Message cannot be empty"
-    opaque type Message <: String  = String :| MessageConstraint
+    private type MessageConstraint = Not[Empty] `DescribedAs` "Message cannot be empty"
+    type Message                   = Message.T
 
-    object Message extends RefinedTypeOps[String, MessageConstraint, Message]
+    object Message extends RefinedType[String, MessageConstraint]
 
-    private type ErrorNumberConstraint = Positive DescribedAs "Number must be strictly positive"
-    opaque type ErrorNumber <: Int     = Int :| ErrorNumberConstraint
+    private type ErrorNumberConstraint = Positive `DescribedAs` "Number must be strictly positive"
+    type ErrorNumber                   = ErrorNumber.T
 
-    object ErrorNumber extends RefinedTypeOps[Int, ErrorNumberConstraint, ErrorNumber]
+    object ErrorNumber extends RefinedType[Int, ErrorNumberConstraint]
 end PillarsError

modules/core/src/main/scala/pillars/app.scala

@@ -40,22 +40,25 @@ abstract class IOApp(override val modules: ModuleSupport*) extends App(modules*)
 
 object App:
     private type NameConstraint = Not[Blank]
-    opaque type Name <: String  = String :| NameConstraint
-    object Name extends RefinedTypeOps[String, NameConstraint, Name]
+    type Name                   = Name.T
+    object Name extends RefinedType[String, NameConstraint]
 
     private type VersionConstraint = SemanticVersion
-    opaque type Version <: String  = String :| VersionConstraint
-    object Version extends RefinedTypeOps[String, VersionConstraint, Version]
+    type Version                   = Version.T
+    object Version extends RefinedType[String, VersionConstraint]
 
     private type DescriptionConstraint = Not[Blank]
-    opaque type Description <: String  = String :| DescriptionConstraint
-    object Description extends RefinedTypeOps[String, DescriptionConstraint, Description]
+    type Description                   = Description.T
+    object Description extends RefinedType[String, DescriptionConstraint]
+    def apply(value: String): Description         = value.asInstanceOf[Description]
+    def unapply(description: Description): String = description.asInstanceOf[String]
+    def assume(description: Description): String  = description.asInstanceOf[String]
 end App
 
 case class AppInfo(name: App.Name, version: App.Version, description: App.Description)
 trait BuildInfo:
     def name: String
     def version: String
     def description: String
-    def toAppInfo: AppInfo = AppInfo(Name(name.assume), Version(version.assume), Description(description.assume))
+    def toAppInfo: AppInfo = AppInfo(Name.assume(name), Version.assume(version), Description.assume(description))
 end BuildInfo

modules/core/src/main/scala/pillars/graph.scala

@@ -51,7 +51,7 @@ object graph:
         override def message: Message = this match
             case GraphError.CyclicDependencyError      => Message("Cyclic dependency found")
             case GraphError.MissingDependency(missing) =>
-                if missing.size == 1 then Message(s"Missing dependency: ${missing.head}".assume)
-                else Message(s"${missing.size} missing dependencies: ${missing.mkString(", ")}".assume)
+                if missing.size == 1 then Message.assume(s"Missing dependency: ${missing.head}")
+                else Message.assume(s"${missing.size} missing dependencies: ${missing.mkString(", ")}")
     end GraphError
 end graph

modules/core/src/main/scala/pillars/probes.scala

@@ -31,8 +31,8 @@ object probes:
 
     object Component:
         private type NameConstraint = Not[Blank] & Not[Contain[":"]]
-        opaque type Name <: String  = String :| NameConstraint
-        object Name extends RefinedTypeOps[String, NameConstraint, Name]
+        type Name                   = Name.T
+        object Name extends RefinedType[String, NameConstraint]
 
         enum Type:
             case System, Datastore, Component

modules/db-doobie-tests/src/main/scala/pillars/db_doobie/tests/DB.scala

@@ -25,10 +25,10 @@ case class DB(container: JdbcDatabaseContainer) extends ModuleSupport:
 
     private def dbConfig: DatabaseConfig =
         DatabaseConfig(
-          driverClassName = DriverClassName(container.driverClassName.assume),
-          url = JdbcUrl(container.jdbcUrl.assume),
-          username = DatabaseUser(container.username.assume),
-          password = Secret(DatabasePassword(container.password.assume)),
+          driverClassName = DriverClassName.assume(container.driverClassName),
+          url = JdbcUrl.assume(container.jdbcUrl),
+          username = DatabaseUser.assume(container.username),
+          password = Secret(DatabasePassword.assume(container.password)),
           probe = ProbeConfig()
         )
 end DB