Upgrade iron 3.2.0 (#12)

* chore: upgrade Iron from 3.0.1 to 3.2.0

- Update Iron dependency to 3.2.0 to get RefinedSubtype support
- RefinedSubtype enables implicit conversion to base types
- This allows refined types like NetworkId, AccountId, Address to be used directly where String is expected

* chore: migrate from RefinedType to RefinedSubtype

- Change all RefinedType to RefinedSubtype to work with Iron 3.2.0
- RefinedSubtype provides implicit conversion to base types
- This allows refined types to be used directly where base type is expected

Note: db-skunk module has pre-existing compilation issues with
Typer.Strategy that are unrelated to Iron upgrade

* fix: update Typer.Strategy to TypingStrategy for Skunk 1.0.0-M11

- Skunk 1.0.0-M11 renamed Typer.Strategy to TypingStrategy
- Move from Typer.Strategy.BuiltinsOnly to TypingStrategy.BuiltinsOnly
- Move from Typer.Strategy.SearchPath to TypingStrategy.SearchPath

* chore: run scalafmt

* chore: add sbt-scalafmt plugin

- Add sbt-scalafmt 2.5.5 plugin to project/plugins.sbt
- Enables scalafmtCheckAll and scalafmtAll commands in sbt

Author: ahoy-jon

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

@@ -42,7 +42,7 @@ object Logging:
     private type BufferSizeConstraint = Positive `DescribedAs` "Buffer size should be positive"
     type BufferSize                   = BufferSize.T
 
-    object BufferSize extends RefinedType[Int, BufferSizeConstraint]
+    object BufferSize extends RefinedSubtype[Int, BufferSizeConstraint]
 
     enum Format:
         case Json

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

@@ -107,7 +107,7 @@ object Observability:
 
     private type ServiceNameConstraint = Not[Blank]
     type ServiceName                   = ServiceName.T
-    object ServiceName extends RefinedType[String, ServiceNameConstraint]
+    object ServiceName extends RefinedSubtype[String, ServiceNameConstraint]
 
     extension [A <: String](value: A)
         def toAttribute(name: String): Attribute[String] = Attribute(name, value)

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

@@ -62,15 +62,15 @@ object PillarsError:
     private type CodeConstraint = (Not[Empty] & LettersUpperCase) `DescribedAs` "Code cannot be empty"
     type Code                   = Code.T
 
-    object Code extends RefinedType[String, CodeConstraint]
+    object Code extends RefinedSubtype[String, CodeConstraint]
 
     private type MessageConstraint = Not[Empty] `DescribedAs` "Message cannot be empty"
     type Message                   = Message.T
 
-    object Message extends RefinedType[String, MessageConstraint]
+    object Message extends RefinedSubtype[String, MessageConstraint]
 
     private type ErrorNumberConstraint = Positive `DescribedAs` "Number must be strictly positive"
     type ErrorNumber                   = ErrorNumber.T
 
-    object ErrorNumber extends RefinedType[Int, ErrorNumberConstraint]
+    object ErrorNumber extends RefinedSubtype[Int, ErrorNumberConstraint]
 end PillarsError

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

@@ -41,15 +41,15 @@ abstract class IOApp(override val modules: ModuleSupport*) extends App(modules*)
 object App:
     private type NameConstraint = Not[Blank]
     type Name                   = Name.T
-    object Name extends RefinedType[String, NameConstraint]
+    object Name extends RefinedSubtype[String, NameConstraint]
 
     private type VersionConstraint = SemanticVersion
     type Version                   = Version.T
-    object Version extends RefinedType[String, VersionConstraint]
+    object Version extends RefinedSubtype[String, VersionConstraint]
 
     private type DescriptionConstraint = Not[Blank]
     type Description                   = Description.T
-    object Description extends RefinedType[String, DescriptionConstraint]
+    object Description extends RefinedSubtype[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]

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

@@ -32,7 +32,7 @@ object probes:
     object Component:
         private type NameConstraint = Not[Blank] & Not[Contain[":"]]
         type Name                   = Name.T
-        object Name extends RefinedType[String, NameConstraint]
+        object Name extends RefinedSubtype[String, NameConstraint]
 
         enum Type:
             case System, Datastore, Component

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

@@ -116,28 +116,28 @@ end StatementCacheConfig
 private type SizeConstraint = Positive0 `DescribedAs` "Size must be positive or zero"
 type Size                   = Size.T
 
-object Size extends RefinedType[Int, SizeConstraint]
+object Size extends RefinedSubtype[Int, SizeConstraint]
 
 private type JdbcUrlConstraint =
     Match["jdbc\\:[^:]+\\:.*"] `DescribedAs` "Driver class name must in jdbc:<subprotocol>:<subname> format"
 type JdbcUrl                   = JdbcUrl.T
 
-object JdbcUrl extends RefinedType[String, JdbcUrlConstraint]
+object JdbcUrl extends RefinedSubtype[String, JdbcUrlConstraint]
 
 private type DriverClassNameConstraint = Not[Blank] `DescribedAs` "Driver class name must not be blank"
 type DriverClassName                   = DriverClassName.T
 
-object DriverClassName extends RefinedType[String, DriverClassNameConstraint]
+object DriverClassName extends RefinedSubtype[String, DriverClassNameConstraint]
 
 private type DatabaseNameConstraint = Not[Blank] `DescribedAs` "Database name must not be blank"
 type DatabaseName                   = DatabaseName.T
 
-object DatabaseName extends RefinedType[String, DatabaseNameConstraint]
+object DatabaseName extends RefinedSubtype[String, DatabaseNameConstraint]
 
 private type DatabaseSchemaConstraint = Not[Blank] `DescribedAs` "Database schema must not be blank"
 type DatabaseSchema                   = DatabaseSchema.T
 
-object DatabaseSchema extends RefinedType[String, DatabaseSchemaConstraint]:
+object DatabaseSchema extends RefinedSubtype[String, DatabaseSchemaConstraint]:
     val public: DatabaseSchema  = DatabaseSchema("public")
     val pillars: DatabaseSchema = DatabaseSchema("pillars")
 
@@ -148,25 +148,25 @@ private type DatabaseTableConstraint =
     ]
 type DatabaseTable                   = DatabaseTable.T
 
-object DatabaseTable extends RefinedType[String, DatabaseTableConstraint]
+object DatabaseTable extends RefinedSubtype[String, DatabaseTableConstraint]
 
 private type DatabaseUserConstraint = Not[Blank] `DescribedAs` "Database user must not be blank"
 type DatabaseUser                   = DatabaseUser.T
 
-object DatabaseUser extends RefinedType[String, DatabaseUserConstraint]
+object DatabaseUser extends RefinedSubtype[String, DatabaseUserConstraint]
 
 private type DatabasePasswordConstraint = Not[Blank] `DescribedAs` "Database password must not be blank"
 type DatabasePassword                   = DatabasePassword.T
 
-object DatabasePassword extends RefinedType[String, DatabasePasswordConstraint]
+object DatabasePassword extends RefinedSubtype[String, DatabasePasswordConstraint]
 
 private type PoolSizeConstraint = GreaterEqual[1] `DescribedAs` "Pool size must be greater or equal to 1"
 type PoolSize                   = PoolSize.T
 
-object PoolSize extends RefinedType[Int, PoolSizeConstraint]
+object PoolSize extends RefinedSubtype[Int, PoolSizeConstraint]
 
 private type VersionConstraint =
     Not[Blank] & Match["^(\\d+\\.\\d+\\.\\d+)$"] `DescribedAs` "Schema version must be in the form of X.Y.Z"
 type SchemaVersion             = SchemaVersion.T
 
-object SchemaVersion extends RefinedType[String, Not[Blank] & Match["^(\\d+\\.\\d+\\.\\d+)$"]]
+object SchemaVersion extends RefinedSubtype[String, Not[Blank] & Match["^(\\d+\\.\\d+\\.\\d+)$"]]

modules/db-migration/src/main/scala/pillars/db/migrations/migrations.scala

@@ -103,17 +103,17 @@ private type JdbcUrlConstraint =
     Match["jdbc\\:[^:]+\\:.*"] `DescribedAs` "JDBC URL must be in jdbc:<subprotocol>:<subname> format"
 type JdbcUrl                   = JdbcUrl.T
 
-object JdbcUrl extends RefinedType[String, JdbcUrlConstraint]
+object JdbcUrl extends RefinedSubtype[String, JdbcUrlConstraint]
 
 private type DatabaseNameConstraint = Not[Blank] `DescribedAs` "Database name must not be blank"
 type DatabaseName                   = DatabaseName.T
 
-object DatabaseName extends RefinedType[String, DatabaseNameConstraint]
+object DatabaseName extends RefinedSubtype[String, DatabaseNameConstraint]
 
 private type DatabaseSchemaConstraint = Not[Blank] `DescribedAs` "Database schema must not be blank"
 type DatabaseSchema                   = DatabaseSchema.T
 
-object DatabaseSchema extends RefinedType[String, DatabaseSchemaConstraint]:
+object DatabaseSchema extends RefinedSubtype[String, DatabaseSchemaConstraint]:
     val public: DatabaseSchema  = DatabaseSchema("public")
     val pillars: DatabaseSchema = DatabaseSchema("pillars")
 
@@ -122,14 +122,14 @@ private type DatabaseTableConstraint =
 
 type DatabaseTable = DatabaseTable.T
 
-object DatabaseTable extends RefinedType[String, DatabaseTableConstraint]
+object DatabaseTable extends RefinedSubtype[String, DatabaseTableConstraint]
 
 private type DatabaseUserConstraint = Not[Blank] `DescribedAs` "Database user must not be blank"
 type DatabaseUser                   = DatabaseUser.T
 
-object DatabaseUser extends RefinedType[String, DatabaseUserConstraint]
+object DatabaseUser extends RefinedSubtype[String, DatabaseUserConstraint]
 
 private type DatabasePasswordConstraint = Not[Blank] `DescribedAs` "Database password must not be blank"
 type DatabasePassword                   = DatabasePassword.T
 
-object DatabasePassword extends RefinedType[String, DatabasePasswordConstraint]
+object DatabasePassword extends RefinedSubtype[String, DatabasePasswordConstraint]

modules/db-skunk/src/main/scala/pillars/db/db.scala

@@ -104,7 +104,7 @@ final case class DatabaseConfig(
     probe: ProbeConfig = ProbeConfig(),
     logging: LoggingConfig = LoggingConfig(),
     tracing: Boolean = false,
-    typerStrategy: Typer.Strategy = Typer.Strategy.BuiltinsOnly,
+    typerStrategy: TypingStrategy = TypingStrategy.BuiltinsOnly,
     extraParameters: Map[String, String] = Map.empty,
     commandCache: Int = 1024,
     queryCache: Int = 1024,
@@ -119,12 +119,12 @@ object DatabaseConfig:
     import pillars.Logging.Config.given
     given Codec[LoggingConfig]  = Codec.AsObject.derivedConfigured
 
-    given CirceEncoder[Typer.Strategy] = CirceEncoder.encodeString.contramap:
-        case Typer.Strategy.BuiltinsOnly => "BuiltinsOnly"
-        case Typer.Strategy.SearchPath   => "SearchPath"
-    given CirceDecoder[Typer.Strategy] = CirceDecoder.decodeString.map(_.toLowerCase).emap:
-        case "builtinsonly" => Right(Typer.Strategy.BuiltinsOnly)
-        case "searchpath"   => Right(Typer.Strategy.SearchPath)
+    given CirceEncoder[TypingStrategy] = CirceEncoder.encodeString.contramap:
+        case TypingStrategy.BuiltinsOnly => "BuiltinsOnly"
+        case TypingStrategy.SearchPath   => "SearchPath"
+    given CirceDecoder[TypingStrategy] = CirceDecoder.decodeString.map(_.toLowerCase).emap:
+        case "builtinsonly" => Right(TypingStrategy.BuiltinsOnly)
+        case "searchpath"   => Right(TypingStrategy.SearchPath)
         case other          => Left(s"Invalid Typer strategy: $other")
 
     given CirceDecoder[SSL] = CirceDecoder.decodeString.map(_.toLowerCase).emap:
@@ -159,12 +159,12 @@ final case class LoggingConfig(
 private type DatabaseNameConstraint = Not[Blank] `DescribedAs` "Database name must not be blank"
 type DatabaseName                   = DatabaseName.T
 
-object DatabaseName extends RefinedType[String, DatabaseNameConstraint]
+object DatabaseName extends RefinedSubtype[String, DatabaseNameConstraint]
 
 private type DatabaseSchemaConstraint = Not[Blank] `DescribedAs` "Database schema must not be blank"
 type DatabaseSchema                   = DatabaseSchema.T
 
-object DatabaseSchema extends RefinedType[String, DatabaseSchemaConstraint]:
+object DatabaseSchema extends RefinedSubtype[String, DatabaseSchemaConstraint]:
     val public: DatabaseSchema  = DatabaseSchema("public")
     val pillars: DatabaseSchema = DatabaseSchema("pillars")
 
@@ -175,25 +175,25 @@ private type DatabaseTableConstraint =
     ]
 type DatabaseTable                   = DatabaseTable.T
 
-object DatabaseTable extends RefinedType[String, DatabaseTableConstraint]
+object DatabaseTable extends RefinedSubtype[String, DatabaseTableConstraint]
 
 private type DatabaseUserConstraint = Not[Blank] `DescribedAs` "Database user must not be blank"
-type DatabaseUser                   = DatabaseUser.T
 
-object DatabaseUser extends RefinedType[String, DatabaseUserConstraint]
+type DatabaseUser = DatabaseUser.T
+object DatabaseUser extends RefinedSubtype[String, DatabaseUserConstraint]
 
 private type DatabasePasswordConstraint = Not[Blank] `DescribedAs` "Database password must not be blank"
-type DatabasePassword                   = DatabasePassword.T
 
-object DatabasePassword extends RefinedType[String, DatabasePasswordConstraint]
+type DatabasePassword = DatabasePassword.T
+object DatabasePassword extends RefinedSubtype[String, DatabasePasswordConstraint]
 
 private type PoolSizeConstraint = GreaterEqual[1] `DescribedAs` "Pool size must be greater or equal to 1"
-type PoolSize                   = PoolSize.T
 
-object PoolSize extends RefinedType[Int, PoolSizeConstraint]
+type PoolSize = PoolSize.T
+object PoolSize extends RefinedSubtype[Int, PoolSizeConstraint]
 
 private type VersionConstraint =
     Not[Blank] & Match["^(\\d+\\.\\d+\\.\\d+)$"] `DescribedAs` "Schema version must be in the form of X.Y.Z"
 type SchemaVersion             = SchemaVersion.T
 
-object SchemaVersion extends RefinedType[String, Not[Blank] & Match["^(\\d+\\.\\d+\\.\\d+)$"]]
+object SchemaVersion extends RefinedSubtype[String, Not[Blank] & Match["^(\\d+\\.\\d+\\.\\d+)$"]]

modules/example/src/main/scala/example/model.scala

@@ -9,31 +9,31 @@ import io.github.iltotore.iron.constraint.all.*
 
 type UsernameConstraint = (MinLength[3] & MaxLength[20]) `DescribedAs` "Must be between 3 and 20 characters"
 type Username           = Username.T
-object Username extends RefinedType[String, UsernameConstraint]
+object Username extends RefinedSubtype[String, UsernameConstraint]
 
 type AgeConstraint = (Positive & Less[150]) `DescribedAs` "Must be a positive number less than 150"
 type Age           = Age.T
-object Age extends RefinedType[Int, AgeConstraint]
+object Age extends RefinedSubtype[Int, AgeConstraint]
 
 type FirstNameConstraint = Not[Blank] `DescribedAs` "First name must not be blank"
 type FirstName           = FirstName.T
-object FirstName extends RefinedType[String, FirstNameConstraint]
+object FirstName extends RefinedSubtype[String, FirstNameConstraint]
 
 type LastNameConstraint = Not[Blank] `DescribedAs` "Last name must not be blank"
 type LastName           = LastName.T
-object LastName extends RefinedType[String, LastNameConstraint]
+object LastName extends RefinedSubtype[String, LastNameConstraint]
 
 type EmailConstraint = Match[".*@.*\\..*"] `DescribedAs` "Must be a valid e-mail"
 type Email           = Email.T
-object Email extends RefinedType[String, EmailConstraint]
+object Email extends RefinedSubtype[String, EmailConstraint]
 
 type CountryNameConstraint = Not[Blank] `DescribedAs` "Country name must not be blank"
 type CountryName           = CountryName.T
-object CountryName extends RefinedType[String, CountryNameConstraint]
+object CountryName extends RefinedSubtype[String, CountryNameConstraint]
 
 type CountryCodeConstraint = (FixedLength[2] & LettersUpperCase) `DescribedAs` "Country name must not be blank"
 type CountryCode           = CountryCode.T
-object CountryCode extends RefinedType[String, CountryCodeConstraint]
+object CountryCode extends RefinedSubtype[String, CountryCodeConstraint]
 
 case class Country(code: CountryCode, name: CountryName, niceName: String)
 

modules/flags/src/main/scala/pillars/flags/model.scala

@@ -13,7 +13,7 @@ final case class FeatureFlag(name: Flag, status: Status):
 private type FlagConstraint = Not[Blank] `DescribedAs` "Name must not be blank"
 type Flag                   = Flag.T
 
-object Flag extends RefinedType[String, FlagConstraint]
+object Flag extends RefinedSubtype[String, FlagConstraint]
 
 enum Status:
     case Enabled, Disabled