Add const attribute to Schema.

core/src/main/scala-2/sttp/tapir/internal/OneOfMacro.scala

@@ -51,7 +51,7 @@ private[tapir] object OneOfMacro {
  val discriminatorName = _root_.sttp.tapir.FieldName($name, $conf.toEncodedName($name))
  // cannot use .collect because of a bug in ScalaJS (Trying to access the this of another class ... during phase: jscode)
  val discriminatorMapping = mappingAsMap.toList.flatMap { 
- case (k, _root_.sttp.tapir.Schema(_, _root_.scala.Some(fname), _, _, _, _, _, _, _, _, _)) => _root_.scala.collection.immutable.List($asString.apply(k) -> _root_.sttp.tapir.SchemaType.SRef(fname))
+ case (k, _root_.sttp.tapir.Schema(_, _root_.scala.Some(fname), _, _, _, _, _, _, _, _, _, _)) => _root_.scala.collection.immutable.List($asString.apply(k) -> _root_.sttp.tapir.SchemaType.SRef(fname))
  case _ => _root_.scala.Nil
  }
  .toMap

core/src/main/scala-3/sttp/tapir/macros/SchemaMacros.scala

@@ -230,7 +230,7 @@ private[tapir] object SchemaCompanionMacros {
  val mappingAsMap = mappingAsList.toMap
 
  val discriminatorName = _root_.sttp.tapir.FieldName(${ Expr(functionName) }, $conf.toEncodedName(${ Expr(functionName) }))
- val discriminatorMapping = mappingAsMap.collect { case (k, sf @ Schema(_, Some(fname), _, _, _, _, _, _, _, _, _)) =>
+ val discriminatorMapping = mappingAsMap.collect { case (k, sf @ Schema(_, Some(fname), _, _, _, _, _, _, _, _, _, _)) =>
  $asString.apply(k) -> SRef(fname)
  }
 

core/src/main/scala/sttp/tapir/Schema.scala

@@ -39,26 +39,106 @@ case class Schema[T](
  deprecated: Boolean = false,
  hidden: Boolean = false,
  validator: Validator[T] = Validator.pass[T],
- attributes: AttributeMap = AttributeMap.Empty
+ attributes: AttributeMap = AttributeMap.Empty,
+ // The const value together with the value encoded to a raw format, which will then be directly rendered in the
+ // documentation. This is needed as codecs for nested types aren't available. Similar to Validator.EncodeToRaw
+ const: Option[(T, Option[Any])] = None
 ) extends SchemaMacros[T] {
 
- def map[TT](f: T => Option[TT])(g: TT => T): Schema[TT] = copy(
+ // required for binary compatibility
+ def this(
+ schemaType: SchemaType[T],
+ name: Option[SName],
+ isOptional: Boolean,
+ description: Option[String],
+ default: Option[(T, Option[Any])],
+ format: Option[String],
+ encodedExample: Option[Any],
+ deprecated: Boolean,
+ hidden: Boolean,
+ validator: Validator[T],
+ attributes: AttributeMap
+ ) =
+ this(schemaType, name, isOptional, description, default, format, encodedExample, deprecated, hidden, validator, attributes, None)
+
+// def copy(
+// schemaType: SchemaType[T] = this.schemaType,
+// name: Option[SName] = this.name,
+// isOptional: Boolean = this.isOptional,
+// description: Option[String] = this.description,
+// default: Option[(T, Option[Any])] = this.default,
+// format: Option[String] = this.format,
+// encodedExample: Option[Any] = this.encodedExample,
+// deprecated: Boolean = this.deprecated,
+// hidden: Boolean = this.hidden,
+// validator: Validator[T] = this.validator,
+// attributes: AttributeMap = this.attributes,
+// const: Option[(T, Option[Any])] = this.const
+// ): Schema[T] = new Schema(
+// schemaType,
+// name,
+// isOptional,
+// description,
+// default,
+// format,
+// encodedExample,
+// deprecated,
+// hidden,
+// validator,
+// attributes,
+// const
+// )
+
+// // required for binary compatibility
+// def copy(
+// schemaType: SchemaType[T],
+// name: Option[SName],
+// isOptional: Boolean,
+// description: Option[String],
+// default: Option[(T, Option[Any])],
+// format: Option[String],
+// encodedExample: Option[Any],
+// deprecated: Boolean,
+// hidden: Boolean,
+// validator: Validator[T],
+// attributes: AttributeMap
+// ): Schema[T] =
+// new Schema(
+// schemaType,
+// name,
+// isOptional,
+// description,
+// default,
+// format,
+// encodedExample,
+// deprecated,
+// hidden,
+// validator,
+// attributes,
+// this.const
+// )
+
+ def map[TT](f: T => Option[TT])(g: TT => T): Schema[TT] = Schema(
  schemaType = schemaType.contramap(g),
  default = default.flatMap { case (t, raw) =>
  f(t).map(tt => (tt, raw))
  },
- validator = validator.contramap(g)
+ validator = validator.contramap(g),
+ const = const.flatMap { case (t, raw) =>
+ f(t).map(tt => (tt, raw))
+ }
  )
 
  /** Adapt this schema to type `TT`. Only the meta-data is retained, except for default values and the validator (however, product
  * field/subtypes validators are retained). Run-time functionality:
  * - traversing collection elements, product fields, or coproduct subtypes
  * - validating an instance of type `TT` the top-level type is lost.
  */
- def as[TT]: Schema[TT] = copy(
+ def as[TT]: Schema[TT] = Schema(
  schemaType = schemaType.as[TT],
  default = None,
- validator = Validator.pass
+ validator = Validator.pass,
+ const = None
  )
 
  /** Returns an optional version of this schema, with `isOptional` set to true. */
@@ -257,6 +337,22 @@ case class Schema[T](
 }
 
 object Schema extends LowPrioritySchema with SchemaCompanionMacros {
+// // required for binary compatibility
+// def apply[T](
+// schemaType: SchemaType[T],
+// name: Option[SName],
+// isOptional: Boolean,
+// description: Option[String],
+// default: Option[(T, Option[Any])],
+// format: Option[String],
+// encodedExample: Option[Any],
+// deprecated: Boolean,
+// hidden: Boolean,
+// validator: Validator[T],
+// attributes: AttributeMap
+// ): Schema[T] =
+// new Schema(schemaType, name, isOptional, description, default, format, encodedExample, deprecated, hidden, validator, attributes, None)
+
  val ModifyCollectionElements = "each"
 
  /** Creates a schema for type `T`, where the low-level representation is a `String`. */
@@ -309,7 +405,7 @@ object Schema extends LowPrioritySchema with SchemaCompanionMacros {
 
  implicit def schemaForEither[A, B](implicit sa: Schema[A], sb: Schema[B]): Schema[Either[A, B]] = {
  Schema[Either[A, B]](
- SchemaType.SCoproduct(List(sa, sb), None) {
+ SchemaType.SCoproduct[Either[A, B]](List(sa, sb), None) {
  case Left(v) => Some(SchemaWithValue(sa, v))
  case Right(v) => Some(SchemaWithValue(sb, v))
  },

core/src/main/scala/sttp/tapir/SchemaType.scala

@@ -131,7 +131,7 @@ object SchemaType {
  ): SCoproduct[T] = {
  SCoproduct(
  subtypes.map {
- case s @ Schema(st: SchemaType.SProduct[Any @unchecked], _, _, _, _, _, _, _, _, _, _)
+ case s @ Schema(st: SchemaType.SProduct[Any @unchecked], _, _, _, _, _, _, _, _, _, _, _)
  if st.fields.forall(_.name != discriminatorName) =>
  s.copy(schemaType = st.copy(fields = st.fields :+ SProductField[Any, D](discriminatorName, discriminatorSchema, _ => None)))
  case s => s

docs/apispec-docs/src/main/scala/sttp/tapir/docs/apispec/schema/TSchemaToASchema.scala

@@ -4,7 +4,7 @@ import sttp.apispec.{Schema => ASchema, _}
 import sttp.tapir.Schema.{SName, Title, UniqueItems}
 import sttp.tapir.Validator.EncodeToRaw
 import sttp.tapir.docs.apispec.DocsExtensionAttribute.RichSchema
-import sttp.tapir.docs.apispec.schema.TSchemaToASchema.{tDefaultToADefault, tExampleToAExample}
+import sttp.tapir.docs.apispec.schema.TSchemaToASchema.{tConstToAConst, tDefaultToADefault, tExampleToAExample}
 import sttp.tapir.docs.apispec.{DocsExtensions, exampleValue}
 import sttp.tapir.internal._
 import sttp.tapir.{Codec, Validator, Schema => TSchema, SchemaType => TSchemaType}
@@ -43,7 +43,7 @@ private[docs] class TSchemaToASchema(
  properties = extractProperties(fields)
  )
  case TSchemaType.SArray(el) => ASchema(SchemaType.Array).copy(items = Some(apply(el, allowReference = true)))
- case opt @ TSchemaType.SOption(nested @ TSchema(_, Some(name), _, _, _, _, _, _, _, _, _)) =>
+ case opt @ TSchemaType.SOption(nested @ TSchema(_, Some(name), _, _, _, _, _, _, _, _, _, _)) =>
  // #3288: in case there are multiple different customisations of the nested schema, we need to propagate the
  // metadata to properly customise the reference. These are also propagated in ToKeyedSchemas when computing
  // the initial list of schemas.
@@ -121,6 +121,7 @@ private[docs] class TSchemaToASchema(
  oschema.copy(
  description = tschema.description.orElse(oschema.description),
  default = tDefaultToADefault(tschema).orElse(oschema.default),
+ const = tConstToAConst(tschema).orElse(oschema.const),
  examples = tExampleToAExample(tschema).map(List(_)).orElse(oschema.examples),
  format = tschema.format.orElse(oschema.format),
  deprecated = (if (tschema.deprecated) Some(true) else None).orElse(oschema.deprecated),
@@ -193,5 +194,10 @@ object TSchemaToASchema {
  def tDefaultToADefault(schema: TSchema[_]): Option[ExampleValue] = schema.default.flatMap { case (_, raw) =>
  raw.flatMap(r => exampleValue(schema, r))
  }
+
+ def tConstToAConst(schema: TSchema[_]): Option[ExampleValue] = schema.const.flatMap { case (_, raw) =>
+ raw.flatMap(r => exampleValue(schema, r))
+ }
+
  def tExampleToAExample(schema: TSchema[_]): Option[ExampleValue] = schema.encodedExample.flatMap(exampleValue(schema, _))
 }

docs/apispec-docs/src/main/scala/sttp/tapir/docs/apispec/schema/ToKeyedSchemas.scala

@@ -9,14 +9,14 @@ private[docs] object ToKeyedSchemas {
  def apply(schema: TSchema[_]): List[KeyedSchema] = {
  val thisSchema = SchemaKey(schema).map(_ -> schema).toList
  val nestedSchemas = schema match {
- case TSchema(TSchemaType.SArray(o), _, _, _, _, _, _, _, _, _, _) => apply(o)
- case t @ TSchema(o: TSchemaType.SOption[_, _], _, _, _, _, _, _, _, _, _, _) =>
+ case TSchema(TSchemaType.SArray(o), _, _, _, _, _, _, _, _, _, _, _) => apply(o)
+ case t @ TSchema(o: TSchemaType.SOption[_, _], _, _, _, _, _, _, _, _, _, _, _) =>
  // #1168: if there's an optional field which is an object, with metadata defined (such as description), this
  // needs to be propagated to the target object, so that it isn't omitted.
  apply(propagateMetadataForOption(t, o).element)
- case TSchema(st: TSchemaType.SProduct[_], _, _, _, _, _, _, _, _, _, _) => productSchemas(st)
- case TSchema(st: TSchemaType.SCoproduct[_], _, _, _, _, _, _, _, _, _, _) => coproductSchemas(st)
- case TSchema(st: TSchemaType.SOpenProduct[_, _], _, _, _, _, _, _, _, _, _, _) => apply(st.valueSchema)
+ case TSchema(st: TSchemaType.SProduct[_], _, _, _, _, _, _, _, _, _, _, _) => productSchemas(st)
+ case TSchema(st: TSchemaType.SCoproduct[_], _, _, _, _, _, _, _, _, _, _, _) => coproductSchemas(st)
+ case TSchema(st: TSchemaType.SOpenProduct[_, _], _, _, _, _, _, _, _, _, _, _, _) => apply(st.valueSchema)
  case _ => List.empty
  }
 

docs/openapi-docs/src/test/resources/example/expected_single_example_with_const.yml

@@ -0,0 +1,26 @@
+openapi: 3.1.0
+info:
+ title: Entities
+ version: '1.0'
+paths:
+ /:
+ get:
+ operationId: getRoot
+ responses:
+ '200':
+ description: ''
+ content:
+ application/json:
+ schema:
+ $ref: '#/components/schemas/FruitConst'
+components:
+ schemas:
+ FruitConst:
+ title: FruitConst
+ type: object
+ required:
+ - fruitType
+ properties:
+ fruitType:
+ type: string
+ const: Golden Delicious

docs/openapi-docs/src/test/scalajvm/sttp/tapir/docs/openapi/VerifyYamlExampleTest.scala

@@ -3,23 +3,36 @@
 import io.circe.generic.auto._
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
-import sttp.capabilities.Streams
 import sttp.apispec.openapi.Info
 import sttp.apispec.openapi.circe.yaml._
+import sttp.capabilities.Streams
 import sttp.tapir.EndpointIO.Example
 import sttp.tapir.docs.openapi.dtos.{Author, Book, Country, Genre}
 import sttp.tapir.generic.Derived
 import sttp.tapir.generic.auto._
 import sttp.tapir.json.circe._
-import sttp.tapir.tests.data.{Entity, Organization, Person}
+import sttp.tapir.tests.data.{Entity, FruitConst, Organization, Person}
 import sttp.tapir.{endpoint, _}
 
 import java.nio.ByteBuffer
 import java.time.ZoneOffset.UTC
 import java.time.ZonedDateTime
 
 class VerifyYamlExampleTest extends AnyFunSuite with Matchers {
 
+ test("support const attribute") {
+ val expectedYaml = load("example/expected_single_example_with_const.yml")
+ val actualYaml = OpenAPIDocsInterpreter()
+ .toOpenAPI(
+ endpoint.get.out(jsonBody[FruitConst]),
+ Info("Entities", "1.0")
+ )
+ .toYaml
+
+ val actualYamlNoIndent = noIndentation(actualYaml)
+ actualYamlNoIndent shouldBe expectedYaml
+ }
+
  test("support example of list and not-list types") {
  val expectedYaml = load("example/expected_examples_of_list_and_not_list_types.yml")
  val actualYaml = OpenAPIDocsInterpreter()
@@ -183,7 +196,7 @@
  val actualYaml = OpenAPIDocsInterpreter().toOpenAPI(e, Info("Examples", "1.0")).toYaml
  val actualYamlNoIndent = noIndentation(actualYaml)
 
  actualYamlNoIndent shouldBe expectedYaml
  }
 
  test("should support summary and name for single example") {

tests/src/main/scala/sttp/tapir/tests/data/FruitConst.scala

@@ -0,0 +1,11 @@
+package sttp.tapir.tests.data
+
+import sttp.tapir.Schema
+
+case class FruitConst(fruitType: String)
+
+object FruitConst {
+ implicit val schemw: Schema[FruitConst] = Schema
+ .derived[FruitConst]
+ .modifyUnsafe[String]("fruitType")(s => s.copy(const = Some(("Golden Delicious", Some("Golden Delicious")))))
+}