تولید سوگرها در زمان کامپایل

import com.github.eikek.sbt.openapi._

val CirceVersion = "0.14.1"
libraryDependencies ++= Seq(
  "io.circe" %% "circe-generic" % CirceVersion,
  "io.circe" %% "circe-parser"  % CirceVersion
)

openapiSpec := (Compile/resourceDirectory).value/"test.yml"
openapiTargetLanguage := Language.Scala
Compile/openapiScalaConfig := ScalaConfig()
    .withJson(ScalaJson.circeSemiauto)
    .addMapping(CustomMapping.forType({ case TypeDef("LocalDateTime", _) =>
      TypeDef("Timestamp", Imports("com.mypackage.Timestamp"))
    }))
    .addMapping(CustomMapping.forName({ case s => s + "Dto" }))

enablePlugins(OpenApiSchema)

val swagger = OpenAPIDocsInterpreter()
  .toOpenAPI(
    tapirEndpoints,
    "my app",
    "v0.0.1"
  )
  .openapi("3.0.3")
  .toYaml

writeSwaggerToFile(swagger, pathToSwaggerFile)

// MyApiEndpoints.scala
class Endpoints {
  protected val booksListingEndpoint: PublicEndpoint[(BooksQuery, Limit, AuthToken), String, List[Book], Any] = 
    endpoint
      .get
      .in(("books" / path[String]("genre") / path[Int]("year")).mapTo[BooksQuery])
      .in(query[Limit]("limit").description("Maximum number of books to retrieve"))
      .in(header[AuthToken]("X-Auth-Token"))
      .errorOut(stringBody)
      .out(jsonBody[List[Book]])

  val plainEndpoints: List[AnyEndpoint] = List(booksListingEndpoint)
}

// MyApiRoutes.scala
class Routes(api: MyApiService) extends Endpoints {
  private val booksListing =
    booksListingEndpoint
      .serverLogic { case (booksQuery, limit, authToken) =>
        api.listBooks(authToken, booksQuery, limit)
      }

  val endpoints: List[ServerEndpoint[Fs2Streams[IO], IO]] = List(
    booksListing
  )
  val routes: HttpRoutes = Http4sServerInterpreter()
    .toRoutes(endpoints)
}

import sbt.Keys.*
import sbt.*

object SpecGen extends AutoPlugin {
  object autoImport {
    val Spec = config("spec").extend(Runtime)
    val specGenMain = settingKey[String]("Main class (FQDN) to run")
    val specGenArgs = settingKey[Seq[String]]("Arguments to pass to runner")
    val specGenMake = taskKey[Unit]("run code/resource generation from config")
  }

  import autoImport.*

  override def projectSettings: Seq[Def.Settings[?]] = inConfig(Spec)(Defaults.configSettings ++ Seq(
    specGenMain := "",
    specGenArgs := Seq.empty,
    specGenMake := {
      val logger = streams.value.log
      val classPath = Attributed.data((Spec / fullClasspath).value)
      (Spec / runner).value.run(specGenMain.value, classPath, specGenArgs.value, logger).get
    }
  )) :+ (ivyConfigurations := overrideConfigs(Spec)(ivyConfigurations.value))
}

val `my-api` = (project in file("application/my-api"))
  .settings(...)
  .enablePlugins(SpecGen)
  .settings(
    Spec / specGenMain := "org.myapi.GenerateSwagger"
  )

// we need a project to be able to `publish` the swagger.
// GenerateSwagger would write to the /src/resources/swagger.yaml
val `my-api-swagger` = project in file("modules/my-api-swagger")

// build.sbt
object Dependencies {
  lazy val swagger = "com.example" % "my-api-swagger_2.13" % "1.0.0"
  lazy val circe = Seq(
    "io.circe" % "circe-core",
    "io.circe" % "circe-generics",
    "io.circe" % "circe-generic-extras"
  ).map(_ %% "0.14.1")
}

lazy val `my-api-generated` = (project in file("modules/my-api-generated"))
  .enablePlugins(OpenApiSchema)
  .enablePlugins(SwaggerinatorSbt)
  .settings(swaggerinatorDependency := Dependencies.swagger)
  .settings(swaggerinatorPackage := Pkg("com.example.my-api.generated"))
  .settings(libraryDependencies ++= Dependencies.circe)

lazy val infrastructure = (project in file("modules/infrastructure"))
  // ...
  .dependsOn(`my-api-generated` % "compile->compile")