Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 4 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,10 @@ When adding entries, please treat them as if they could end up in a release any

Thank you!

# 0.18.60

* dynamic: Add `DynamicSchemaIndex.loadModel(model, applySchemaRefinements: Boolean)` overload. When `applySchemaRefinements = true`, constraint traits (`@length`, `@range`, `@pattern`, ...) are reified into schema refinements instead of being kept just as hints, matching the behaviour of codegen-produced schemas. Backport of [#1991](https://github.com/disneystreaming/smithy4s/pull/1991).

# 0.18.59

* Update Smithy to 1.74.0. Smithy 1.74.0 added members to two prelude traits that smithy4s generates — `@idempotent` gained `exists`/`notFound` and `@unstable` gained `featureId`. To preserve binary compatibility of the already-published `smithy.api.Idempotent` and `smithy.api.Unstable` types, smithy4s intentionally does not surface these new (niche) fields.
Expand Down
9 changes: 9 additions & 0 deletions modules/core/src/smithy4s/RefinementProvider.scala
Original file line number Diff line number Diff line change
Expand Up @@ -53,6 +53,15 @@ object RefinementProvider extends LowPriorityImplicits {
def patternConstraint[A](getValue: A => String): Simple[Pattern, A] =
new PatternConstraint[A](getValue)

def void[C, A](
underlying: RefinementProvider[C, A, ?]
): RefinementProvider.Simple[C, A] =
Refinement
.drivenBy[C]
.contextual[A, A](c =>
Surjection(v => underlying.make(c).apply(v).map(_ => v), identity)
)(underlying.tag)

implicit val stringLengthConstraint: Simple[Length, String] =
lengthConstraint[String](_.length)

Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -27,14 +27,28 @@ private[dynamic] trait DynamicSchemaIndexCompanionPlatform {
*/
def loadModel(
model: software.amazon.smithy.model.Model
): DynamicSchemaIndex = loadModel(model, applySchemaRefinements = false)

/**
* Loads a dynamic schema index model from a smithy model.
*
* @param applySchemaRefinements when true, constraint traits (`@length`, `@range`,
* `@pattern` etc) are reified into Schema objects that get enforced upon
* decoding, instead of being kept as inert hints (which is the default dynamic
* behaviour), mirroring the fact that codegen-produced schemas enforce these
* constraints but dynamically-loaded do not).
*/
def loadModel(
model: software.amazon.smithy.model.Model,
applySchemaRefinements: Boolean
): DynamicSchemaIndex = {
val flattenedModel =
ModelTransformer.create().flattenAndRemoveMixins(model);
val node = ModelSerializer.builder().build.serialize(flattenedModel)
val document = NodeToDocument(node)
smithy4s.Document
.decode[smithy4s.dynamic.model.Model](document)
.map(load(_)) match {
.map(load(_, applySchemaRefinements)) match {
case Left(error) => throw error
case Right(value) => value
}
Expand Down
18 changes: 17 additions & 1 deletion modules/dynamic/src/smithy4s/dynamic/DynamicSchemaIndex.scala
Original file line number Diff line number Diff line change
Expand Up @@ -45,7 +45,23 @@ object DynamicSchemaIndex extends DynamicSchemaIndexCompanionPlatform {
def load(
model: dynamic.model.Model
): DynamicSchemaIndex =
internals.Compiler.compile(model)
load(model, applySchemaRefinements = false)

/**
* Loads the model from a dynamic representation of smithy models
* (typically json blobs). This representation is modelled in smithy itself,
* and code generated by smithy4s.
*
* @param model
* @param applySchemaRefinements when true, constraint traits (`@length`, `@range`,
* `@pattern` etc) are reified into `Schema` objects that get enforced upon
* decoding, instead of being kept as inert hints.
*/
def load(
model: dynamic.model.Model,
applySchemaRefinements: Boolean
): DynamicSchemaIndex =
internals.Compiler.compile(model, applySchemaRefinements)

/**
* A construct that hides the types a service instance works,
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,122 @@
/*
* Copyright 2021-2026 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.dynamic.internals

import smithy4s.RefinementProvider
import smithy4s.schema.Primitive._
import smithy4s.schema.Schema
import smithy4s.schema.Schema._
import smithy4s.~>

/**
* Dynamically-loaded schemas only carry constraint traits (`@length`, `@range`,
* `@pattern` etc) as hints: `DynamicModelCompiler` only attaches them via `addHints`/
* `addMemberHints`, unlike smithy4s codegen, which reifies such traits into
* `RefinementSchema` wrappers that get enforced upon decoding.
*
* This is a single-node (non-recursive) transform: it only inspects the hints already
* present on the schema it's given. `DynamicModelCompiler` applies it locally, at each
* point a schema's hints have just finished being merged (a shape's own top-level hints,
* or a member/field's merged hints) and are about to be handed to a consumer — composition
* across nesting levels then falls out for free, since a nested schema is already reified
* by the time its parent embeds it.
*/
private[dynamic] object ConstraintReification extends (Schema ~> Schema) {

private implicit class SchemaOps[A](schema: Schema[A]) {
def reifyHint[B](rp: RefinementProvider[B, A, ?]): Schema[A] =
schema.hints
.get(rp.tag)
.fold(schema)(schema.validated(_)(RefinementProvider.void(rp)))
}

private def collection[C[_], B](
schema: Schema.CollectionSchema[C, B]
): Schema[C[B]] =
schema.reifyHint(
RefinementProvider.lengthConstraint[C[B]](schema.tag.iterator(_).size)
)

def apply[A](schema: Schema[A]): Schema[A] =
schema match {
case t @ PrimitiveSchema(_, _, tag) =>
tag match {
case PString =>
t.reifyHint(RefinementProvider.stringLengthConstraint)
.reifyHint(RefinementProvider.stringPatternConstraints)
.reifyHint(RefinementProvider.idRefRefinement)
case PByte =>
schema.reifyHint(RefinementProvider.numericRangeConstraints[Byte])
case PShort =>
schema.reifyHint(RefinementProvider.numericRangeConstraints[Short])
case PInt =>
schema.reifyHint(RefinementProvider.numericRangeConstraints[Int])
case PLong =>
schema.reifyHint(RefinementProvider.numericRangeConstraints[Long])
case PFloat =>
schema.reifyHint(RefinementProvider.numericRangeConstraints[Float])
case PDouble =>
schema.reifyHint(
RefinementProvider.numericRangeConstraints[Double]
)
case PBigInt =>
schema.reifyHint(
RefinementProvider.numericRangeConstraints[BigInt]
)
case PBigDecimal =>
schema.reifyHint(
RefinementProvider.numericRangeConstraints[BigDecimal]
)
case PBlob =>
schema.reifyHint(RefinementProvider.blobLengthConstraint)
case PTimestamp | PDocument | PBoolean | PUUID =>
schema
}
case e: EnumerationSchema[_] =>
val byValue = e.values.map(v => v.value -> v).toMap
schema
.reifyHint(
RefinementProvider.lengthConstraint[A](
byValue(_).stringValue.length
)
)
.reifyHint(
RefinementProvider.rangeConstraint[A, Int](byValue(_).intValue)
)
.reifyHint(
RefinementProvider.patternConstraint[A](byValue(_).stringValue)
)
case c: CollectionSchema[c, b] => collection[c, b](c)
case m: MapSchema[k, v] =>
m.reifyHint(
RefinementProvider.lengthConstraint[Map[k, v]](_.size)
)
// We need to unpack the underlying schema and apply all the hints turning them into refinements.
// This is because, for example in the container context we might have member level hints.
// For example, if we have a list that targets constrained type and adds another constraint on member level
// if we just retrieved a target member it would miss the member level constraint needed for the container case.
case r: RefinementSchema[_, _] =>
// Only used in dynamic context, A is fixed to DynData = Any
apply(r.underlying).asInstanceOf[Schema[A]]
case b: BijectionSchema[_, _] => b
case s: StructSchema[_] => s
case l: LazySchema[_] => l
case u: UnionSchema[_] => u
case n: OptionSchema[_] => n
}

}
Original file line number Diff line number Diff line change
Expand Up @@ -60,10 +60,13 @@ private[dynamic] object Compiler {
Hints.Binding.DynamicBinding(id, tr)

/**
* @param knownHints hints supported by the caller.
* @param applySchemaRefinements when true, constraint traits (`@length`, `@range`,
* `@pattern` etc) are reified into `Schema` objects that get enforced upon
* decoding, instead of being kept as inert hints.
*/
protected[dynamic] def compile(
model: Model
model: Model,
applySchemaRefinements: Boolean
): DynamicSchemaIndex = {
val schemaMap = MMap.empty[ShapeId, Eval[Schema[DynData]]]
// val endpointMap = MMap.empty[ShapeId, Eval[DynamicEndpoint]]
Expand All @@ -74,7 +77,8 @@ private[dynamic] object Compiler {
model,
schemaMap,
// endpointMap,
serviceMap
serviceMap,
applySchemaRefinements
)

// Loosely inspired by
Expand Down Expand Up @@ -109,15 +113,16 @@ private[dynamic] object Compiler {
}
new DynamicSchemaIndexImpl(
model.metadata,
serviceMap.toMap.fmap(_.value),
schemaMap.toMap.fmap(_.value)
visitor.exportServices,
visitor.exportSchemas
)
}

private class CompileVisitor(
model: Model,
schemaMap: MMap[ShapeId, Eval[Schema[DynData]]],
serviceMap: MMap[ShapeId, Eval[DynamicService]]
serviceMap: MMap[ShapeId, Eval[DynamicService]],
applySchemaRefinements: Boolean
) extends ShapeVisitor.Default[Unit] {

private val closureMap: Map[ShapeId, Set[ShapeId]] = model.shapes.collect {
Expand All @@ -137,8 +142,19 @@ private[dynamic] object Compiler {
)
}

private def resolve(schema: Schema[DynData]): Schema[DynData] =
if (applySchemaRefinements) ConstraintReification(schema) else schema

def exportSchemas: Map[ShapeId, Schema[DynData]] =
schemaMap.toMap.fmap(_.value)

def exportServices: Map[ShapeId, DynamicService] =
serviceMap.toMap.fmap(_.value)

private def memberSchema(member: MemberShape): Eval[Schema[DynData]] =
schema(member.target).map(_.addMemberHints(allHints(member.traits)))
schema(member.target)
.map(_.addMemberHints(allHints(member.traits)))
.map(resolve)

private def allHints(traits: Map[IdRef, Document]): Hints = {
val ignoredHints = List(IdRef("smithy.api#enumValue"))
Expand All @@ -156,10 +172,12 @@ private[dynamic] object Compiler {
lSchema: Eval[Schema[A]]
): Unit = {
schemaMap += (shapeId -> lSchema.map { sch =>
sch
.withId(shapeId)
.addHints(allHints(traits))
.asInstanceOf[Schema[DynData]]
resolve(
sch
.withId(shapeId)
.addHints(allHints(traits))
.asInstanceOf[Schema[DynData]]
)
})
}

Expand Down Expand Up @@ -358,7 +376,7 @@ private[dynamic] object Compiler {
}

override def setShape(id: ShapeId, shape: SetShape): Unit =
update(id, shape.traits, schema(shape.member.target).map(s => set(s)))
update(id, shape.traits, memberSchema(shape.member).map(s => set(s)))

override def mapShape(id: ShapeId, shape: MapShape): Unit =
update(
Expand All @@ -382,7 +400,7 @@ private[dynamic] object Compiler {
shape: OperationShape
): Eval[DynamicEndpoint] = {
def getSchemaFromId(shapeId: ShapeId): Eval[Schema[DynData]] =
Eval.defer(schemaMap(shapeId))
Eval.defer(schemaMap(shapeId)).map(resolve)

def getSchema(maybeShapeId: Option[IdRef]): Eval[Schema[DynData]] =
maybeShapeId
Expand Down Expand Up @@ -503,7 +521,9 @@ private[dynamic] object Compiler {
index: Int
): Eval[Field[DynStruct, DynData]] = {
val (label, mShape) = labelledShape
val field = schema(mShape.target)
schema(mShape.target)
.map(_.addMemberHints(allHints(mShape.traits)))
.map(resolve)
.map { sch =>
if (mShape.traits.contains(IdRef("alloy#nullable")))
sch.nullable.asInstanceOf[Schema[DynData]]
Expand All @@ -518,8 +538,6 @@ private[dynamic] object Compiler {
.optional[DynStruct](label, OptionalAccessor(index))
.asInstanceOf[Field[DynStruct, DynData]]
}
val memberHints = allHints(mShape.traits)
field.map(_.addHints(memberHints.all.toSeq: _*))
}
update(
id,
Expand Down
Loading
Loading