Validated newtypes

modules/bootstrapped/src/generated/smithy4s/example/NonValidatedString.scala

@@ -0,0 +1,15 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Newtype
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.schema.Schema.bijection
+import smithy4s.schema.Schema.string
+
+object NonValidatedString extends Newtype[String] {
+  val id: ShapeId = ShapeId("smithy4s.example", "NonValidatedString")
+  val hints: Hints = Hints.empty
+  val underlyingSchema: Schema[String] = string.withId(id).addHints(hints).validated(smithy.api.Length(min = Some(1L), max = None)).validated(smithy.api.Pattern("[a-zA-Z0-9]+"))
+  implicit val schema: Schema[NonValidatedString] = bijection(underlyingSchema, asBijection)
+}

modules/bootstrapped/src/generated/smithy4s/example/ValidatedFoo.scala

@@ -0,0 +1,21 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.ShapeTag
+import smithy4s.schema.Schema.struct
+
+final case class ValidatedFoo(name: ValidatedString = smithy4s.example.ValidatedString.unsafeApply("abc"))
+
+object ValidatedFoo extends ShapeTag.Companion[ValidatedFoo] {
+  val id: ShapeId = ShapeId("smithy4s.example", "ValidatedFoo")
+
+  val hints: Hints = Hints.empty
+
+  implicit val schema: Schema[ValidatedFoo] = struct(
+    ValidatedString.schema.field[ValidatedFoo]("name", _.name).addHints(smithy.api.Default(smithy4s.Document.fromString("abc"))),
+  ){
+    ValidatedFoo.apply
+  }.withId(id).addHints(hints)
+}

modules/bootstrapped/src/generated/smithy4s/example/ValidatedString.scala

@@ -0,0 +1,18 @@
+package smithy4s.example
+
+import smithy4s.Hints
+import smithy4s.NewtypeValidated
+import smithy4s.Schema
+import smithy4s.ShapeId
+import smithy4s.Validator
+import smithy4s.schema.Schema.bijection
+import smithy4s.schema.Schema.string
+
+object ValidatedString extends NewtypeValidated[String] {
+  val id: ShapeId = ShapeId("smithy4s.example", "ValidatedString")
+  val hints: Hints = Hints.empty
+  val underlyingSchema: Schema[String] = string.withId(id).addHints(hints).validated(smithy.api.Length(min = Some(1L), max = None)).validated(smithy.api.Pattern("[a-zA-Z0-9]+"))
+  implicit val schema: Schema[ValidatedString] = bijection(underlyingSchema, asBijectionUnsafe)
+  val validator: Validator[String, ValidatedString] = Validator.of[String, ValidatedString].validating(smithy.api.Length(min = Some(1L), max = None)).validating(smithy.api.Pattern("[a-zA-Z0-9]+")).build
+  @inline def apply(a: String): Either[String, ValidatedString] = validator.validate(a)
+}

modules/bootstrapped/src/generated/smithy4s/example/package.scala

@@ -60,6 +60,7 @@ package object example {
   type MapWithMemberHints = smithy4s.example.MapWithMemberHints.Type
   type TestIdRefList = smithy4s.example.TestIdRefList.Type
   type CitySummaries = smithy4s.example.CitySummaries.Type
+  type ValidatedString = smithy4s.example.ValidatedString.Type
   /** This is a simple example of a "quoted string" */
   type AString = smithy4s.example.AString.Type
   type NonEmptyMapNumbers = smithy4s.example.NonEmptyMapNumbers.Type
@@ -91,6 +92,7 @@ package object example {
   type TestStructurePattern = smithy4s.example.TestStructurePattern.Type
   type UnicodeRegexString = smithy4s.example.UnicodeRegexString.Type
   type UVIndex = smithy4s.example.UVIndex.Type
+  type NonValidatedString = smithy4s.example.NonValidatedString.Type
   @deprecated(message = "N/A", since = "N/A")
   type Strings = smithy4s.example.Strings.Type
   type NonEmptyCandies = smithy4s.example.NonEmptyCandies.Type

modules/bootstrapped/test/src/smithy4s/ValidatedNewtypesSpec.scala

@@ -0,0 +1,96 @@
+/*
+ *  Copyright 2021-2023 Disney Streaming
+ *
+ *  Licensed under the Tomorrow Open Source Technology License, Version 1.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     https://disneystreaming.github.io/TOST-1.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package smithy4s
+
+import smithy4s.schema.Schema.bijection
+import smithy4s.schema.Schema.string
+
+class ValidatedNewtypesSpec() extends munit.FunSuite {
+  val id1 = "id-1"
+  val id2 = "id-2"
+
+  test("Validated newtypes are consistent") {
+    expect.same(AccountId.unsafeApply(id1).value, id1)
+    expect.different(
+      AccountId.unsafeApply(id1).value,
+      AccountId.unsafeApply(id2).value
+    )
+    expect.different(
+      implicitly[ShapeTag[AccountId]],
+      implicitly[ShapeTag[DeviceId]]
+    )
+    expect.same(AccountId.unapply(AccountId.unsafeApply(id1)), Some(id1))
+  }
+
+  test("Newtypes have well defined unapply") {
+    val aid = AccountId.unsafeApply(id1)
+    aid match {
+      case AccountId(id) => expect(id == id1)
+    }
+  }
+
+  type DeviceId = DeviceId.Type
+  object DeviceId extends NewtypeValidated[String] {
+
+    val id: ShapeId = ShapeId("foo", "DeviceId")
+    val hints: Hints = Hints.empty
+
+    val underlyingSchema: Schema[String] = string
+      .withId(id)
+      .addHints(hints)
+      .validated(smithy.api.Length(min = Some(1L), max = None))
+
+    implicit val schema: Schema[DeviceId] =
+      bijection(underlyingSchema, asBijectionUnsafe)
+
+    val validator: Validator[String, DeviceId] = Validator
+      .of[String, DeviceId]
+      .validating(smithy.api.Length(min = Some(1L), max = None))
+      .build
+
+    @inline def apply(a: String): Either[String, DeviceId] =
+      validator.validate(a)
+
+  }
+
+  type AccountId = AccountId.Type
+
+  object AccountId extends NewtypeValidated[String] {
+    def id: smithy4s.ShapeId = ShapeId("foo", "AccountId")
+    val hints: Hints = Hints.empty
+
+    val underlyingSchema: Schema[String] = string
+      .withId(id)
+      .addHints(hints)
+      .validated(smithy.api.Length(min = Some(1L), max = None))
+      .validated(smithy.api.Pattern("[a-zA-Z0-9]+"))
+
+    implicit val schema: Schema[AccountId] =
+      bijection(underlyingSchema, asBijectionUnsafe)
+
+    val validator: Validator[String, AccountId] = Validator
+      .of[String, AccountId]
+      .validating(smithy.api.Length(min = Some(1L), max = None))
+      .validating(smithy.api.Pattern("[a-zA-Z0-9]+"))
+      .build
+
+    @inline def apply(a: String): Either[String, AccountId] =
+      validator.validate(a)
+
+  }
+
+}

modules/codegen-plugin/src/sbt-test/codegen-plugin/render-validated-newtypes/build.sbt

@@ -0,0 +1,11 @@
+lazy val root = (project in file("."))
+  .enablePlugins(Smithy4sCodegenPlugin)
+  .settings(
+    scalaVersion := "2.13.10",
+    Compile / smithy4sRenderValidatedNewtypes := true,
+    libraryDependencies ++= Seq(
+      "com.disneystreaming.smithy4s" %% "smithy4s-core" % smithy4sVersion.value,
+      "com.disneystreaming.smithy4s" %% "smithy4s-dynamic" % smithy4sVersion.value,
+      "com.disneystreaming.alloy" % "alloy-core" % "0.3.4",
+    )
+  )

modules/codegen-plugin/src/sbt-test/codegen-plugin/render-validated-newtypes/project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.8.3

modules/codegen-plugin/src/sbt-test/codegen-plugin/render-validated-newtypes/project/plugins.sbt

@@ -0,0 +1,9 @@
+sys.props.get("plugin.version") match {
+  case Some(x) =>
+    addSbtPlugin("com.disneystreaming.smithy4s" % "smithy4s-sbt-codegen" % x)
+  case _ =>
+    sys.error(
+      """|The system property 'plugin.version' is not defined.
+         |Specify this property using the scriptedLaunchOpts -D.""".stripMargin
+    )
+}

modules/codegen-plugin/src/sbt-test/codegen-plugin/render-validated-newtypes/src/main/scala/Main.scala

@@ -0,0 +1,38 @@
+/*
+ *  Copyright 2021-2024 Disney Streaming
+ *
+ *  Licensed under the Tomorrow Open Source Technology License, Version 1.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     https://disneystreaming.github.io/TOST-1.0.txt
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package newtypes.validated
+
+import newtypes.validated._
+
+object Main extends App {
+  try {
+    val cityOrError: Either[String, ValidatedCity] = ValidatedCity("test-city")
+    val nameOrError: Either[String, ValidatedName] = ValidatedName("test-name")
+    val country: String = "test-country"
+
+    println(
+      (nameOrError, cityOrError) match {
+        case (Right(name), Right(city)) => s"Success: ${Person(name, Some(city), Some(country))}"
+        case _ => s"Error"
+      }
+    )
+  } catch {
+    case _: java.lang.ExceptionInInitializerError =>
+      println("failed")
+      sys.exit(1)
+  }
+}

modules/codegen-plugin/src/sbt-test/codegen-plugin/render-validated-newtypes/src/main/smithy/validated-newtypes.smithy

@@ -0,0 +1,26 @@
+namespace newtypes.validated
+
+use smithy4s.meta#unwrap
+use alloy#simpleRestJson
+
+@length(min: 1, max: 10)
+string ValidatedCity
+
+@length(min: 1, max: 10)
+string ValidatedName
+
+@unwrap
+@length(min: 1, max: 10)
+string ValidatedCountry
+
+structure Person {
+  @httpLabel
+  @required
+  name: ValidatedName
+
+  @httpQuery("town")
+  town: ValidatedCity
+
+  @httpQuery("country")
+  country: ValidatedCountry
+}

modules/codegen-plugin/src/sbt-test/codegen-plugin/render-validated-newtypes/test

@@ -0,0 +1,2 @@
+# check if smithy4sCodegen works and everything compiles
+> compile

modules/codegen-plugin/src/smithy4s/codegen/GenerateSmithyBuild.scala

@@ -16,8 +16,9 @@
 
 package smithy4s.codegen
 
-import sbt._
 import sbt.Keys._
+import sbt._
+
 import Smithy4sCodegenPlugin.autoImport._
 
 private final case class SmithyBuildData(

modules/codegen-plugin/src/smithy4s/codegen/Smithy4sCodegenPlugin.scala

@@ -19,7 +19,10 @@ package smithy4s.codegen
 import sbt.Keys._
 import sbt.util.CacheImplicits._
 import sbt.{fileJsonFormatter => _, _}
-import scala.util.{Success, Try}
+
+import scala.util.Success
+import scala.util.Try
+
 import JsonConverters._
 
 object Smithy4sCodegenPlugin extends AutoPlugin {
@@ -138,6 +141,11 @@ object Smithy4sCodegenPlugin extends AutoPlugin {
         "Boolean value to indicate whether or not to generate optics"
       )
 
+    val smithy4sRenderValidatedNewtypes =
+      taskKey[Boolean](
+        "Boolean value to indicate whether or not to generate validated newtypes"
+      )
+
     val smithy4sGeneratedSmithyFiles =
       taskKey[Seq[File]](
         "Generated smithy files"
@@ -252,36 +260,51 @@ object Smithy4sCodegenPlugin extends AutoPlugin {
       }
     },
     config / smithy4sRenderOptics := false,
+    config / smithy4sRenderValidatedNewtypes := false,
     config / smithy4sGeneratedSmithyMetadataFile := {
       (config / sourceManaged).value / "smithy" / "generated-metadata.smithy"
     },
     config / smithy4sGeneratedSmithyFiles := {
       val cacheFactory = (config / streams).value.cacheStoreFactory
-      val cached = Tracked.inputChanged[(String, Boolean), Seq[File]](
-        cacheFactory.make("smithy4sGeneratedSmithyFilesInput")
-      ) { case (changed, (wildcardArg, shouldGenerateOptics)) =>
-        val lastOutput = Tracked.lastOutput[Boolean, Seq[File]](
-          cacheFactory.make("smithy4sGeneratedSmithyFilesOutput")
-        ) { case (changed, prevResult) =>
-          if (changed || prevResult.isEmpty) {
-            val file = (config / smithy4sGeneratedSmithyMetadataFile).value
-            IO.write(
-              file,
-              s"""$$version: "2"
-                 |metadata smithy4sWildcardArgument = "$wildcardArg"
-                 |metadata smithy4sRenderOptics = $shouldGenerateOptics
-                 |""".stripMargin
-            )
-            Seq(file)
-          } else {
-            prevResult.get
+      val cached =
+        Tracked
+          .inputChanged[(String, Boolean, Boolean), Seq[File]](
+            cacheFactory.make("smithy4sGeneratedSmithyFilesInput")
+          ) {
+            case (
+                  changed,
+                  (
+                    wildcardArg,
+                    shouldGenerateOptics,
+                    shouldRenderValidatedNewtypes
+                  )
+                ) =>
+              val lastOutput = Tracked.lastOutput[Boolean, Seq[File]](
+                cacheFactory.make("smithy4sGeneratedSmithyFilesOutput")
+              ) { case (changed, prevResult) =>
+                if (changed || prevResult.isEmpty) {
+                  val file =
+                    (config / smithy4sGeneratedSmithyMetadataFile).value
+                  IO.write(
+                    file,
+                    s"""$$version: "2"
+                       |metadata smithy4sWildcardArgument = "$wildcardArg"
+                       |metadata smithy4sRenderOptics = $shouldGenerateOptics
+                       |metadata smithy4sRenderValidatedNewtypes = $shouldRenderValidatedNewtypes
+                       |""".stripMargin
+                  )
+                  Seq(file)
+                } else {
+                  prevResult.get
+                }
+              }
+              lastOutput(changed)
           }
-        }
-        lastOutput(changed)
-      }
       val wildcardArg = (config / smithy4sWildcardArgument).value
       val generateOptics = (config / smithy4sRenderOptics).value
-      cached((wildcardArg, generateOptics))
+      val renderValidatedNewtypes =
+        (config / smithy4sRenderValidatedNewtypes).value
+      cached((wildcardArg, generateOptics, renderValidatedNewtypes))
     },
     config / sourceGenerators += (config / smithy4sCodegen).map(
       _.filter(_.ext == "scala")

modules/codegen/resources/META-INF/services/software.amazon.smithy.build.ProjectionTransformer

@@ -1,3 +1,4 @@
 smithy4s.codegen.transformers.AwsStandardTypesTransformer
 smithy4s.codegen.transformers.AwsConstraintsRemover
 smithy4s.codegen.transformers.OpenEnumTransformer
+smithy4s.codegen.transformers.ValidatedNewtypesTransformer