Revise bijection surjection

build.sbt

@@ -616,7 +616,8 @@ lazy val example = projectMatrix
       (ThisBuild / baseDirectory).value / "sampleSpecs" / "importerror.smithy",
       (ThisBuild / baseDirectory).value / "sampleSpecs" / "adtMember.smithy",
       (ThisBuild / baseDirectory).value / "sampleSpecs" / "brands.smithy",
-      (ThisBuild / baseDirectory).value / "sampleSpecs" / "brandscommon.smithy"
+      (ThisBuild / baseDirectory).value / "sampleSpecs" / "brandscommon.smithy",
+      (ThisBuild / baseDirectory).value / "sampleSpecs" / "refined.smithy"
     ),
     Compile / resourceDirectory := (ThisBuild / baseDirectory).value / "modules" / "example" / "resources",
     isCE3 := true,

modules/codegen/src/smithy4s/codegen/CollisionAvoidance.scala

@@ -23,6 +23,7 @@ import smithy4s.codegen.Hint.Native
 import smithy4s.codegen.Type.Alias
 import smithy4s.codegen.Type.PrimitiveType
 import smithy4s.codegen.TypedNode._
+import smithy4s.codegen.Type.ExternalType
 
 object CollisionAvoidance {
   def apply(compilationUnit: CompilationUnit): CompilationUnit = {
@@ -70,11 +71,12 @@ object CollisionAvoidance {
           recursive,
           hints.map(modHint)
         )
-      case TypeAlias(name, originalName, tpe, hints) =>
+      case TypeAlias(name, originalName, tpe, isUnwrapped, hints) =>
         TypeAlias(
           protect(name.capitalize),
           originalName,
           modType(tpe),
+          isUnwrapped,
           hints.map(modHint)
         )
       case Enumeration(name, originalName, values, hints) =>
@@ -97,9 +99,17 @@ object CollisionAvoidance {
       Type.Collection(collectionType, modType(member))
     case Type.Map(key, value)      => Type.Map(modType(key), modType(value))
     case Type.Ref(namespace, name) => Type.Ref(namespace, name.capitalize)
-    case Alias(namespace, name, tpe) =>
-      Alias(namespace, protect(name.capitalize), modType(tpe))
+    case Alias(namespace, name, tpe, isUnwrapped) =>
+      Alias(namespace, protect(name.capitalize), modType(tpe), isUnwrapped)
     case PrimitiveType(prim) => PrimitiveType(prim)
+    case ExternalType(name, fqn, pFqn, under, refinementHint) =>
+      ExternalType(
+        protect(name),
+        fqn,
+        pFqn,
+        modType(under),
+        modNativeHint(refinementHint)
+      )
   }
 
   private def modField(field: Field): Field = {
@@ -134,10 +144,13 @@ object CollisionAvoidance {
   private def modRef(ref: Type.Ref): Type.Ref =
     Type.Ref(ref.namespace, ref.name.capitalize)
 
+  private def modNativeHint(hint: Hint.Native): Hint.Native =
+    Native(smithy4s.recursion.preprocess(modTypedNode)(hint.typedNode))
+
   private def modHint(hint: Hint): Hint = hint match {
-    case Native(nt) => Native(smithy4s.recursion.preprocess(modTypedNode)(nt))
-    case Constraint(tr) => Constraint(modRef(tr))
-    case other          => other
+    case n: Native           => modNativeHint(n)
+    case Constraint(tr, nat) => Constraint(modRef(tr), modNativeHint(nat))
+    case other               => other
   }
 
   private def modProduct(p: Product): Product = {

modules/codegen/src/smithy4s/codegen/IR.scala

@@ -76,6 +76,7 @@ case class TypeAlias(
     name: String,
     originalName: String,
     tpe: Type,
+    isUnwrapped: Boolean,
     hints: List[Hint] = Nil
 ) extends Decl
 
@@ -150,8 +151,8 @@ object Alt {
 
 sealed trait Type {
   def dealiased: Type = this match {
-    case Type.Alias(_, _, tpe) => tpe.dealiased
-    case other                 => other
+    case Type.Alias(_, _, tpe, _) => tpe.dealiased
+    case other                    => other
   }
 
   def isResolved: Boolean = dealiased == this
@@ -190,8 +191,20 @@ object Type {
   case class Ref(namespace: String, name: String) extends Type {
     def show = namespace + "." + name
   }
-  case class Alias(namespace: String, name: String, tpe: Type) extends Type
+  case class Alias(
+      namespace: String,
+      name: String,
+      tpe: Type,
+      isUnwrapped: Boolean
+  ) extends Type
   case class PrimitiveType(prim: Primitive) extends Type
+  case class ExternalType(
+      name: String,
+      fullyQualifiedName: String,
+      providerImport: Option[String],
+      underlyingTpe: Type,
+      refinementHint: Hint.Native
+  ) extends Type
 }
 
 sealed abstract class CollectionType(val tpe: String)
@@ -209,7 +222,7 @@ object Hint {
   case object Error extends Hint
   case object PackedInputs extends Hint
   case object ErrorMessage extends Hint
-  case class Constraint(tr: Type.Ref) extends Hint
+  case class Constraint(tr: Type.Ref, native: Native) extends Hint
   case class Protocol(traits: List[Type.Ref]) extends Hint
   // traits that get rendered generically
   case class Native(typedNode: Fix[TypedNode]) extends Hint

modules/codegen/src/smithy4s/codegen/Renderer.scala

@@ -90,7 +90,7 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
       renderProduct(name, originalName, fields, recursive, hints)
     case Union(name, originalName, alts, recursive, hints) =>
       renderUnion(name, originalName, alts, recursive, hints)
-    case TypeAlias(name, originalName, tpe, hints) =>
+    case TypeAlias(name, originalName, tpe, _, hints) =>
       renderTypeAlias(name, originalName, tpe, hints)
     case Enumeration(name, originalName, values, hints) =>
       renderEnum(name, originalName, values, hints)
@@ -99,7 +99,7 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
 
   def renderPackageContents: Lines = {
     val typeAliases = compilationUnit.declarations.collect {
-      case TypeAlias(name, _, _, _) =>
+      case TypeAlias(name, _, _, _, _) =>
         s"type $name = ${compilationUnit.namespace}.${name}.Type"
     }
 
@@ -338,6 +338,7 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
       adtParent: Option[String] = None,
       additionalLines: Lines = Lines.empty
   ): Lines = {
+
     val decl = line"case class $name(${renderArgs(fields)})"
     val imports = syntaxImport
     val schemaImplicit = if (adtParent.isEmpty) "implicit " else ""
@@ -367,17 +368,16 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
         newline,
         if (fields.nonEmpty) {
           val renderedFields =
-            fields.map {
-              case Field(fieldName, realName, tpe, required, hints) =>
-                val req = if (required) "required" else "optional"
-                if (hints.isEmpty) {
-                  line"""${tpe.schemaRef}.$req[$name]("$realName", _.$fieldName)"""
-                } else {
-                  val mh = memberHints(hints)
+            fields.map { case Field(fieldName, realName, tpe, required, hints) =>
+              val req = if (required) "required" else "optional"
+              if (hints.isEmpty) {
+                line"""${tpe.schemaRef}.$req[$name]("$realName", _.$fieldName)"""
+              } else {
+                val mh = memberHints(hints)
                   // format: off
-                  line"""${tpe.schemaRef}.$req[$name]("$realName", _.$fieldName).addHints($mh)${renderFieldConstraintValidation(hints, tpe)}"""
+                  line"""${tpe.schemaRef}${renderConstraintValidation(hints)}.$req[$name]("$realName", _.$fieldName).addHints($mh)"""
                   // format: on
-                }
+              }
             }
           if (fields.size <= 22) {
             val definition = if (recursive) "recursive(struct" else "struct"
@@ -486,7 +486,7 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
             // format: off
             lines(
               line"case object $cn extends $name",
-              line"""private val ${cn}Alt = $Schema_.constant($cn).oneOf[$name]("$realName").addHints(hints)${renderConstraintValidation(altHints)}""",
+              line"""private val ${cn}Alt = $Schema_.constant($cn)${renderConstraintValidation(altHints)}.oneOf[$name]("$realName").addHints(hints)""",
               line"private val ${cn}AltWithValue = ${cn}Alt($cn)"
             )
             // format: on
@@ -619,7 +619,7 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
         renderHintsVal(hints),
         line"val underlyingSchema : $Schema_[$tpe] = ${tpe.schemaRef}$trailingCalls",
         lines(
-          s"implicit val schema : $Schema_[$name] = bijection(underlyingSchema, $name.make, (_ : $name).value)"
+          s"implicit val schema : $Schema_[$name] = bijection(underlyingSchema, asBijection)"
         )
       )
     ).addImports(imports)
@@ -665,11 +665,25 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
         line"$col(${member.schemaRef})"
       case Type.Map(key, value) =>
         line"map(${key.schemaRef}, ${value.schemaRef})"
-      case Type.Alias(ns, name, Type.PrimitiveType(_)) =>
+      case Type.Alias(
+            ns,
+            name,
+            _,
+            false
+          ) =>
         line"$name.schema".addImport(ns + "." + name)
-      case Type.Alias(ns, name, _) =>
+      case Type.Alias(ns, name, _, _) =>
         line"$name.underlyingSchema".addImport(ns + "." + name)
       case Type.Ref(ns, name) => line"$name.schema".addImport(ns + "." + name)
+      case Type.ExternalType(
+            _,
+            fqn,
+            maybeProviderImport,
+            underlyingTpe,
+            hint
+          ) =>
+        line"${underlyingTpe.schemaRef}.refined[$fqn](${renderNativeHint(hint)})"
+          .addImport(maybeProviderImport.getOrElse(""))
     }
 
     private def schemaRefP(primitive: Primitive): String = primitive match {
@@ -692,9 +706,9 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
     }
 
     def name: Option[String] = tpe match {
-      case Type.Alias(_, name, _) => Some(name)
-      case Type.Ref(_, name)      => Some(name)
-      case _                      => None
+      case Type.Alias(_, name, _, _) => Some(name)
+      case Type.Ref(_, name)         => Some(name)
+      case _                         => None
     }
   }
 
@@ -729,15 +743,17 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
       enumValueClassName(enumValue.name, enumValue.value, enumValue.ordinal)
   }
 
-  private def renderHint(hint: Hint): Option[Line] = hint match {
-    case Hint.Native(typedNode) =>
+  private def renderNativeHint(hint: Hint.Native): Line =
+    Line(
       smithy4s.recursion
-        .cata(renderTypedNode)(typedNode)
+        .cata(renderTypedNode)(hint.typedNode)
         .run(true)
         ._2
-        .some
-        .map(Line(_))
-    case _ => None
+    )
+
+  private def renderHint(hint: Hint): Option[Line] = hint match {
+    case h: Hint.Native => renderNativeHint(h).some
+    case _              => None
   }
 
   def renderId(name: String, ns: String = namespace): Line =
@@ -757,20 +773,14 @@ private[codegen] class Renderer(compilationUnit: CompilationUnit) { self =>
   }
 
   def renderConstraintValidation(hints: List[Hint]): Line = {
-    val tags = hints.collect { case Hint.Constraint(tr) => tr }
-    if (tags.isEmpty) Line.empty
-    else {
-      tags.map(t => line".validated[${t.renderFull}]").intercalate(Line.empty)
-    }
-  }
-
-  def renderFieldConstraintValidation(hints: List[Hint], tpe: Type): Line = {
-    val tags = hints.collect { case Hint.Constraint(tr) => tr }
+    val tags = hints.collect { case t: Hint.Constraint => t }
     if (tags.isEmpty) Line.empty
     else {
       tags
-        .map(t => line".validated[${t.renderFull}, $tpe]")
-        .intercalate(Line.dot)
+        .map { tag =>
+          line".validated(${renderNativeHint(tag.native)})"
+        }
+        .intercalate(Line.empty)
     }
   }