sttp.apispec.validation.SchemaCompatibilityIssue.scala Maven / Gradle / Ivy
The newest version!
package sttp.apispec.validation
import sttp.apispec.{ExampleValue, Pattern, Schema, SchemaType}
sealed abstract class SchemaCompatibilityIssue {
def description: String
override def toString: String = description
protected def pluralize(what: String, coll: Seq[Any]): String =
if (coll.lengthCompare(1) == 0) s"$what ${coll.head}"
else s"${what}s ${coll.mkString(", ")}"
protected def form(coll: Seq[Any], singular: String, plural: String): String =
if (coll.size == 1) singular else plural
protected def issuesRepr(issues: List[SchemaCompatibilityIssue]): String =
issues.iterator
.map(i => s"- ${i.description.replace("\n", "\n ")}") // indent
.mkString("\n")
}
/**
* A [[SchemaCompatibilityIssue]] used when the schemas are different but the comparator was unable
* to determine compatibility. Thus, the schemas may or may not be compatible.
*/
case class GeneralSchemaMismatch(
writerSchema: Schema,
readerSchema: Schema
) extends SchemaCompatibilityIssue {
def description: String =
"schemas differ, but it was not possible to determine their compatibility"
}
case class NoValuesAllowed(
writerSchema: Schema
) extends SchemaCompatibilityIssue {
def description: String = "target schema does not allow any values"
}
case class TypeMismatch(
incompatibleWriterTypes: List[SchemaType],
readerTypes: List[SchemaType]
) extends SchemaCompatibilityIssue {
def description: String = {
val wt = incompatibleWriterTypes
val writerTypesRepr =
s"${pluralize("type", wt)} ${form(wt, "is", "are")} incompatible with ${form(readerTypes, "it", "them")}"
s"target schema is restricted to ${pluralize("type", readerTypes)}, $writerTypesRepr"
}
}
case class EnumMismatch(
// None indicates that the writer schema has no enum values
incompatibleWriterValues: Option[List[ExampleValue]],
readerValues: List[ExampleValue]
) extends SchemaCompatibilityIssue {
def description: String = {
val writerValuesRepr =
incompatibleWriterValues.fold("")(values =>
s", ${pluralize("value", values)} ${form(values, "is", "are")} incompatible with ${form(readerValues, "it", "them")}"
)
s"target schema is restricted to ${pluralize("value", readerValues)}$writerValuesRepr"
}
}
case class FormatMismatch(
writerFormat: Option[String],
readerFormat: String
) extends SchemaCompatibilityIssue {
def description: String = {
val writerFormatRepr = writerFormat.fold("")(wf => s" with which $wf is not compatible")
s"target schema is restricted to format $readerFormat$writerFormatRepr"
}
}
case class MultipleOfMismatch(
writerMultiplier: Option[BigDecimal],
readerMultiplier: BigDecimal
) extends SchemaCompatibilityIssue {
def description: String = {
val writerMultiplierRepr = writerMultiplier.fold("")(wm => s", as opposed to $wm")
s"target schema accepts multiples of $readerMultiplier$writerMultiplierRepr"
}
}
case class NumericBoundsMismatch(
writerBounds: Bounds[BigDecimal],
readerBounds: Bounds[BigDecimal]
) extends SchemaCompatibilityIssue {
def description: String =
s"target value bounds $readerBounds are stricter than $writerBounds"
}
case class StringLengthBoundsMismatch(
writerBounds: Bounds[Int],
readerBounds: Bounds[Int]
) extends SchemaCompatibilityIssue {
def description: String =
s"target string length bounds $readerBounds are stricter than $writerBounds"
}
case class PatternMismatch(
writerPattern: Option[Pattern],
readerPattern: Pattern
) extends SchemaCompatibilityIssue {
def description: String = {
val writerPatternRepr = writerPattern.fold("")(wp => s", as opposed to $wp")
s"target schema is restricted to pattern $readerPattern$writerPatternRepr"
}
}
case object UniqueItemsRequired extends SchemaCompatibilityIssue {
def description: String = "target schema requires unique items"
}
case class ArrayLengthBoundsMismatch(
writerBounds: Bounds[Int],
readerBounds: Bounds[Int]
) extends SchemaCompatibilityIssue {
def description: String =
s"target array length (minItems/maxItems) bounds $readerBounds are stricter than $writerBounds"
}
case class ObjectSizeBoundsMismatch(
writerBounds: Bounds[Int],
readerBounds: Bounds[Int]
) extends SchemaCompatibilityIssue {
def description: String =
s"target object size (minProperties/maxProperties) $readerBounds is stricter than $writerBounds"
}
case class MissingRequiredProperties(
newRequiredProperties: Set[String]
) extends SchemaCompatibilityIssue {
def description: String = s"target schema requires properties: ${newRequiredProperties.mkString(", ")}"
}
case class MissingDependentRequiredProperties(
property: String,
newRequiredProperties: Set[String]
) extends SchemaCompatibilityIssue {
def description: String =
s"target schema introduced new required dependent properties for property $property: ${newRequiredProperties.mkString(", ")}"
}
case class DiscriminatorPropertyMismatch(
writerDiscriminator: String,
readerDiscriminator: String
) extends SchemaCompatibilityIssue {
def description: String =
s"target schema discriminator property $readerDiscriminator, as opposed to $writerDiscriminator"
}
case class UnsupportedDiscriminatorValues(
unsupportedValues: List[String]
) extends SchemaCompatibilityIssue {
def description: String =
s"target schema does not accept discriminator values: ${unsupportedValues.mkString(", ")}"
}
/** Base class for compatibility issues which aggregate issues from a subschema. A _subschema_ is a schema used within a
* structure of another schema, e.g. a schema for an array item, a property, etc.
*/
sealed abstract class SubschemaCompatibilityIssue extends SchemaCompatibilityIssue {
def subschemaIssues: List[SchemaCompatibilityIssue]
}
case class IncompatibleProperty(
property: String,
subschemaIssues: List[SchemaCompatibilityIssue]
) extends SubschemaCompatibilityIssue {
def description: String =
s"incompatible schema for property $property:\n${issuesRepr(subschemaIssues)}"
}
case class IncompatibleDiscriminatorCase(
discriminatorValue: String,
subschemaIssues: List[SchemaCompatibilityIssue]
) extends SubschemaCompatibilityIssue {
def description: String =
s"incompatible schema for discriminator value $discriminatorValue:\n${issuesRepr(subschemaIssues)}"
}
case class IncompatibleAdditionalProperties(
subschemaIssues: List[SchemaCompatibilityIssue]
) extends SubschemaCompatibilityIssue {
def description: String =
s"incompatible schema for additional properties:\n${issuesRepr(subschemaIssues)}"
}
case class IncompatiblePropertyNames(
subschemaIssues: List[SchemaCompatibilityIssue]
) extends SubschemaCompatibilityIssue {
override def description: String =
s"incompatible schema for property names:\n${issuesRepr(subschemaIssues)}"
}
case class IncompatibleItems(
subschemaIssues: List[SchemaCompatibilityIssue]
) extends SubschemaCompatibilityIssue {
def description: String =
s"incompatible schema for items:\n${issuesRepr(subschemaIssues)}"
}
case class IncompatiblePrefixItem(
index: Int,
subschemaIssues: List[SchemaCompatibilityIssue]
) extends SubschemaCompatibilityIssue {
def description: String =
s"incompatible schema for prefix item at index $index:\n${issuesRepr(subschemaIssues)}"
}
case class IncompatibleUnionVariant(
index: Int,
subschemaIssues: List[SchemaCompatibilityIssue]
) extends SubschemaCompatibilityIssue {
def description: String =
s"incompatible anyOf/oneOf variant at index $index:\n${issuesRepr(subschemaIssues)}"
}
/**
* An issue raised when a schema is not compatible with any of the alternatives in a target union schema.
*
* @param alternatives a list of non-empty lists of issues, where each list corresponds to one of the alternatives
*/
case class AlternativeIssues(
alternatives: List[List[SchemaCompatibilityIssue]]
) extends SchemaCompatibilityIssue {
override def description: String = {
val alternativesReprs = alternatives.zipWithIndex.map {
case (issues, idx) =>
s"for alternative $idx:\n${issuesRepr(issues)}"
}
s"schema is not compatible with any of the alternatives in oneOf/anyOf:\n${alternativesReprs.mkString("\n")}"
}
}