softwaremill/tapir
63.2
Adequate · 14 November 2026
57k
lines of production code
Scala
primary language
5
measurements over time
What this system is
Features
Add Akka HTTP WebSocket client support
New files have been added to the sttp-client module to enable WebSocket support for Akka HTTP. This includes a trait to expose the WebSocket capability, a package object for easy access, and a concrete implementation of the WebSocket pipe that handles request encoding, response decoding, and specific frame behaviors like ping/pong and close handling for Akka Streams.
client/sttp-client/src/main/scalajvm-2 · high confidence
Add Akka gRPC server implementation
The server/akka-grpc-server module now provides a concrete implementation for serving gRPC endpoints using Akka gRPC. This includes request body parsing (AkkaGrpcRequestBody), response body serialization (AkkaGrpcToResponseBody), and the server interpreter (AkkaGrpcServerInterpreter) that wires these components together, enabling users to run Tapir-defined gRPC services on an Akka gRPC backend.
server/akka-grpc-server · high confidence
Add FS2-based WebSocket client implementation
The sttp client backend now supports WebSocket communication using FS2 streams. This change introduces a new implementation that converts WebSocket frames into FS2 streams, allowing users to send and receive data via functional stream operations. The implementation handles text and binary frames, including basic accumulation for fragmented messages, and manages standard WebSocket control frames like ping/pong and close.
client/sttp-client/src/main/scalajvm/sttp/tapir/client/sttp/ws/fs2 · high confidence
Add Helidon Nima server interpreter
Introduces a new server interpreter for the Helidon Nima web server, allowing users to run Tapir endpoints on this runtime. The implementation includes request and response body handling (supporting strings, byte arrays, and file uploads, but explicitly excluding multipart and streaming bodies), request mapping, and interceptor support via NimaServerOptions. A test suite is provided to validate basic server functionality.
server/nima-server · high confidence
Add JDK HTTP server interpreter
Introduces a new server interpreter for the JDK built-in HTTP server (com.sun.net.httpserver), allowing users to run Tapir endpoints using the standard library instead of external dependencies. The implementation includes support for multipart uploads with configurable file-thresholds, SSL termination via HttpsConfigurator, and configurable request executors (including support for JDK 19+ virtual threads). It also provides options for setting base paths, TCP backlog sizes, and custom interceptors.
server/jdkhttp-server · high confidence
Add JSON body and query parameter support for json4s
The json4s integration now provides \jsonBody\, \jsonBodyWithRaw\, and \jsonQuery\ methods, allowing users to define endpoints that serialize/deserialize JSON using the json4s library and handle JSON data in query parameters. This includes support for raw JSON strings alongside parsed objects and a schema definition for arbitrary JSON values.
json/json4s/src/main · high confidence
Add JVM-specific file handling extensions and codecs
The core module now includes platform-specific extensions for Java Virtual Machine (JVM) environments to support file-based operations. This change introduces \CodecExtensions\ to provide an implicit codec for mapping \Path\ objects to \FileRange\ using octet-stream encoding, and \TapirExtensions\ to define the \TapirFile\ type alias (pointing to \java.io.File\) and a \pathBody\ endpoint input. Additionally, \Defaults\ are updated to include JVM-specific implementations for creating and deleting temporary files, enabling file handling capabilities that were previously unavailable or abstracted differently in the core API.
core/src/main/scalajvm/sttp/tapir · high confidence
Add Netty example for fixed, dynamic, and conditional status codes
A new example demonstrates three ways to control HTTP status codes in a Netty server: returning a fixed code (308), computing a code dynamically from input, and mapping error types to specific codes (404, 401, 400) using oneOf variants.
_examples/src/main/scala/sttp/tapir/examples/status\code · high confidence
Add OpenTelemetry metrics support via otel4s
A new \otel4s-metrics\ module has been added, providing a \MetricsRequestInterceptor\ that integrates with the otel4s library to expose standard HTTP server metrics. This allows users to collect \http.server.active\_requests\, \http.server.requests.total\, and \http.server.request.duration\ metrics, automatically attaching OpenTelemetry semantic conventions such as HTTP method, URL scheme, route, and response status code to the data points.
metrics/otel4s-metrics · high confidence
Add OpenTelemetry otel4s server tracing interceptor
Introduces a new \Otel4sTracing\ interceptor for the \tracing/otel4s-tracing\ module, enabling server-side request tracing via the otel4s library. The implementation creates server spans with names derived from HTTP methods and route templates, and attaches standard OpenTelemetry semantic attributes (such as HTTP method, URL path, scheme, and server address) to requests. It supports context propagation from incoming headers and allows configuration of span naming and attribute extraction through \Otel4sTracingConfig\. Tests verify correct span creation, attribute population, and trace context extraction.
tracing/otel4s-tracing · high confidence
Add OpenTelemetry tracing integration for server requests
This change introduces a new OpenTelemetry tracing interceptor for the Tapir server interpreter, allowing users to instrument HTTP requests with distributed traces. The implementation creates server spans that capture request and response attributes (such as HTTP method, path, status code, and server address) and propagates tracing context from incoming headers to support distributed tracing chains. Users can enable this by prepending the \OpenTelemetryTracing\ interceptor to their server options, with configurable span naming and attribute extraction following OpenTelemetry semantic conventions.
tracing/opentelemetry-tracing · high confidence
Add Pekko HTTP server interpreter
Introduces a new server interpreter for Apache Pekko HTTP, enabling users to run Tapir endpoints on the Pekko HTTP runtime. This implementation provides support for Pekko Streams, WebSockets, and Server-Sent Events (SSE), and includes specific handling for request body parsing, response body serialization, and connection information extraction.
server/pekko-http-server · high confidence
Add Pekko gRPC server support
This change introduces a new server implementation for Pekko gRPC, allowing users to serve gRPC endpoints using the Apache Pekko framework. The implementation includes request body handling (PekkoGrpcRequestBody) to decode incoming gRPC frames into raw types like byte arrays, and response body handling (PekkoGrpcToResponseBody) to encode responses back into gRPC frames with appropriate content types. It also provides a server interpreter (PekkoGrpcServerInterpreter) that integrates these components to route requests to Tapir-defined server endpoints.
metrics/prometheus-simpleclient-metrics, server/pekko-grpc-server · high confidence
Add Play 2.9 server support
This change introduces a new server module for Play 2.9, enabling users to run Tapir endpoints on the Play 2.9 framework. The implementation includes request and response body handling (supporting streams, files, and multipart data), WebSocket support, and CORS preflight handling. It also provides configuration options for body size limits and interceptors, along with a test suite to verify compatibility.
server/play29-server · high confidence
Add Play JSON integration for Tapir
This change introduces the Play JSON library integration into the Tapir framework. It provides new methods to define JSON request and response bodies (\jsonBody\, \jsonBodyWithRaw\) and JSON query parameters (\jsonQuery\) using Play's \Reads\ and \Writes\ typeclasses. The implementation includes a custom codec that maps Play JSON parsing errors to Tapir's \JsonDecodeException\, preserving detailed error paths and messages for better debugging. Additionally, it registers implicit schemas for Play's \JsValue\ and \JsObject\ types, allowing them to be used directly in endpoint definitions.
json/playjson/src/main · high confidence
Add Refined integration for schema and codec validation
The Refined integration now provides automatic schema generation and codec validation for types refined with predicates. This includes support for string constraints (NonEmpty, MinSize, MaxSize, MatchesRegex, Uuid), iterable constraints (NonEmpty, MinSize, MaxSize), numeric comparisons (Less, LessEqual, Greater, GreaterEqual), and logical combinations (And, Or). Fields with NonEmpty or MinSize(\>0) are treated as required in the generated schema, and validation errors are mapped to Tapir's ValidationError structure.
integrations/refined/src/main · high confidence
Add Scala Native support for sttp client extensions
This change introduces Scala Native support for the sttp client integration by adding platform-specific extension files. It defines \EndpointToSttpClientExtensions\ to handle WebSocket success status codes specifically for Native (and JS), addressing platform differences in accessing the 101 status code. Additionally, it provides \SttpClientInterpreterExtensions\ that expose synchronous client methods (\toQuickClient\, \toQuickSecureClient\, etc.) using the \CurlBackend\, enabling users to make synchronous HTTP requests from Scala Native applications.
client/sttp-client/src/main/scalanative · high confidence
Add Scala Native-specific extension traits and utilities
New extension traits and utility objects have been added to the Scala Native core module to support platform-specific functionality. This includes CodecExtensions for handling file paths, TapirExtensions defining TapirFile as java.io.File and providing pathBody support, Defaults for temporary file creation and deletion, TapirStaticContentEndpoints for static content handling, and UrlencodedData for URL encoding and decoding operations.
core/src/main/scalanative · high confidence
Add Scala.js support for file handling in Tapir
This change introduces Scala.js compatibility for file-related operations by adding platform-specific abstractions. It defines \TapirFile\ as an alias for \org.scalajs.dom.File\ and provides \CodecExtensions\ and \Defaults\ to support file input/output in JavaScript environments, enabling endpoints to handle file data on the client side.
core/src/main/scalajs/sttp/tapir · high confidence
Add URL encoding utilities for Scala.js targets
A new \UrlencodedData\ utility object has been added to the Scala.js internal module, providing implementations for encoding and decoding URL components. This includes methods for handling query parameters (using \URIUtils\ from Scala.js) and path segments (using \Rfc3986\), ensuring consistent URL encoding behavior across Scala.js environments.
core/src/main/scalajs/sttp/tapir/internal · high confidence
Add WebSocket support for FS2 and ZIO streams on Scala.js
This change introduces WebSocket client integration for Scala.js users leveraging functional effect systems. Specifically, it adds new implementation files for FS2 (via \TapirSttpClientFs2WebSockets\ and \WebSocketToFs2Pipe\) and ZIO (via \TapirSttpClientZioWebSockets\ and \WebSocketToZioPipe\), enabling the use of WebSocket body outputs with \Fs2Streams\ and \ZioStreams\ capabilities respectively. This allows developers to stream WebSocket messages using FS2 Streams or ZIO Streams within the Scala.js environment.
client/sttp-client/src/main/scalajs/sttp/tapir/client/sttp/ws · high confidence
Add WebSocket support for Pekko HTTP in the sttp client
The sttp client interpreter now supports WebSockets when using the Pekko HTTP backend. This change introduces new implementation files (TapirSttpClientPekkoHttpWebSockets.scala, WebSocketToPekkoPipe.scala, and package.scala) that provide the necessary WebSocketToPipe conversion for Pekko Streams, enabling users to handle WebSocket frames (including close, ping/pong, and data frames) via the Pekko HTTP client.
client/sttp-client/src/main/scalajvm/sttp/tapir/client/sttp/ws/pekkohttp · high confidence
Add ZIO OpenTelemetry tracing interceptor for server requests
The observability/zio-opentelemetry module now includes a new ZIO OpenTelemetry tracing interceptor that automatically creates and manages OpenTelemetry spans for incoming server requests. This interceptor integrates with the ZIO HTTP server by prepending to the interceptor chain, capturing request details, span names based on HTTP method and route, and response attributes. It properly handles streamed responses by finalizing spans only after the response body has been fully sent, and correctly marks spans as errored for server errors (5xx) or exceptions while respecting OpenTelemetry semantic conventions for client errors (4xx). The implementation includes configurable options for propagators, request/response attributes, and error handling, with sensible defaults following OpenTelemetry HTTP semantic conventions.
observability/zio-opentelemetry · high confidence
Add ZIO integration for the Armeria server interpreter
Users can now run Tapir servers on Armeria using ZIO effects. This change introduces the \ArmeriaZioServerInterpreter\ and supporting classes (\TapirZioService\, \RIOMonadAsyncError\) which bridge Tapir's server endpoints to Armeria's HTTP service model using ZIO's \RIO\ monad and \ZioStreams\ for streaming. The implementation includes specific handling for request body reading, response mapping, and stream conversion, along with a test suite to verify basic, streaming, and multipart functionality.
server/armeria-server/zio · high confidence
Add ZIO support for WebSocket client connections
Users can now use the sttp WebSocket client with ZIO effects. This change introduces new implementation files in the \sttp.tapir.client.sttp.ws.zio\ package, including \TapirSttpClientZioWebSockets\ and \WebSocketToZioPipe\, which provide the necessary type classes and logic to handle WebSocket frame encoding, decoding, and streaming using ZIO's \Task\ and \ZStream\ capabilities.
client/sttp-client/src/main/scalajvm/sttp/tapir/client/sttp/ws/zio · high confidence
Add automatic schema derivation for Scala 3
Introduces automatic schema derivation for Scala 3 case classes and sealed traits in the \sttp.tapir.generic.auto\ package. This new capability allows users to automatically generate \Schema\ instances for their types without manual definition, supporting features like field encoding, annotations (e.g., \encodedName\, \title\, \description\), and discriminator fields for sealed traits.
core/src/main/scala-3/sttp/tapir/generic · high confidence
Add derevo integration for automatic Schema derivation
Users can now use the derevo library to automatically derive sttp tapir Schema instances for case classes, sealed traits, and newtypes. This integration allows annotating types with @derive(schema) to generate schemas equivalent to Schema.derived, including support for custom descriptions and newtype wrappers.
integrations/derevo · high confidence
Add direct-style server interpreters and handlers for AWS Lambda with Cats Effect and ZIO
This change introduces new direct-style server interpreters and handlers for running Tapir endpoints on AWS Lambda, supporting both Cats Effect and ZIO effect types. For Cats Effect, it adds \AwsCatsEffectServerInterpreter\ and \LambdaHandler\ to bridge Tapir routes with the AWS Lambda \RequestStreamHandler\ interface, along with \AwsCatsEffectServerOptions\ for configuring interceptors and response encoding. It also provides \AwsLambdaRuntime\ for JVM-based Lambda runtimes and \AwsJsRouteHandler\ for Scala.js environments. Similarly, for ZIO, it adds \AwsZioServerInterpreter\, \ZioLambdaHandler\, and \AwsZioServerOptions\ to enable ZIO-based Lambda functions. These components allow users to deploy Tapir-defined APIs to AWS Lambda using their preferred functional programming library.
serverless/aws/lambda-cats-effect · high confidence
Add end-to-end performance testing infrastructure for multiple server backends
The perf-tests/perf-tests-e2e module now includes a complete suite for benchmarking Tapir against various server implementations, including http4s (Ember), Netty (Cats and Future), Pekko HTTP, Play, Nima, and Vert.x (Future and Cats). This change introduces the necessary Scala source files to define server runners, endpoint generators, and WebSocket handling for each backend, along with Gatling simulation scripts to execute load tests and HdrHistogram utilities to record and print latency metrics. A sample 64KB JSON resource and a Logback configuration are also added to support these performance tests.
perf-tests/perf-tests-e2e · high confidence
Add integration with scala-newtype for schema and codec derivation
Users can now automatically derive Tapir schemas and codecs for types defined using the scala-newtype library (including newtype and newsubtype). This integration allows newtype wrappers to be used seamlessly in API endpoints, where they inherit the schema and codec behavior of their underlying base types without requiring manual definitions.
integrations/newtype · high confidence
Add simple books example gRPC service definition
The grpc/pekko-examples module now includes a protobuf definition for a 'Library' service that allows adding books. This new file, simple\_books\_example.proto, defines the AddBook RPC method along with the SimpleBook and AddBookMsg message structures, providing a concrete example of how to structure gRPC services using Pekko gRPC.
grpc/pekko-examples · high confidence
Add sttp-client 4 support for Tapir client interpretation
This change introduces a new module that enables Tapir endpoints to be interpreted as clients using the sttp-client 4 library. It provides interpreters for standard HTTP requests, streaming endpoints, and WebSocket connections, allowing users to generate sttp 4 requests and execute them against any compatible backend.
client/sttp-client4/src/main · high confidence
Add support for Enumeratum enums and value enums
This change introduces the \tapir-enumeratum\ integration, providing automatic schema generation and plain-text codecs for Enumeratum enums. Users can now seamlessly integrate Enumeratum \EnumEntry\ types (including standard, Int, Long, Short, String, Byte, and Char value enums) into their API definitions, with support for case-insensitive decoding and proper schema validation.
integrations/enumeratum/src/main · high confidence
Add support for Monix NewType in Tapir codecs
This change introduces a new integration module that allows Tapir to automatically derive Schema and Codec instances for Monix NewType and Newsubtype types. By mixing in the TapirCodecMonixNewType trait, users can seamlessly use these newtypes in their API definitions, where they are treated as their underlying base types (e.g., a String-based newtype behaves like a standard String schema/codec).
integrations/monix-newtype · high confidence
Add support for Spray JSON integration
Added the \tapir-spray-json\ module, providing codecs and schema support for serializing and deserializing JSON using the Spray JSON library. This enables users to define endpoints with JSON bodies and query parameters that automatically convert to and from Spray JSON types, including specific handling for raw JSON values and error decoding.
json/sprayjson/src/main · high confidence
Add support for ZIO Prelude Newtypes and Subtypes
The ZIO Prelude integration now supports Tapir codecs and schemas for ZIO Prelude Newtypes, Subtypes, and NewtypeCustom types. Users can automatically derive Tapir schema and codec instances for their custom newtypes, ensuring that validation rules defined in the newtype are respected during deserialization. This support is provided for both Scala 2 (via \Newtype\ and \Subtype\) and Scala 3 (via \NewtypeCustom\), allowing seamless integration of these types into API endpoints.
integrations/zio-prelude · high confidence
Add support for jsoniter-scala
Users can now use the jsoniter-scala library for JSON serialization and deserialization in Tapir. This change introduces new \jsonBody\, \jsonBodyWithRaw\, and \jsonQuery\ methods that integrate with jsoniter-scala's \JsonValueCodec\, allowing endpoints to encode/decode JSON using this library instead of the default one. It also provides a \TapirJsonJsoniter\ trait and package object for easy inclusion.
json/jsoniter/src/main · high confidence
Add uPickle JSON integration for Tapir
Introduces a new module providing uPickle-based JSON codecs for Tapir. This adds support for parsing and serializing JSON bodies (including raw body access) and query parameters using uPickle's ReadWriter typeclass, with decode errors wrapped in JsonDecodeException for better error reporting.
json/upickle/src/main · high confidence
Add zio-json integration for JSON body and query parameters
Introduces a new integration module for zio-json, enabling users to define JSON endpoints using zio's JsonEncoder and JsonDecoder. This includes support for JSON request/response bodies (including raw body variants) and JSON query parameters, along with schema definitions for zio's Json AST types.
json/zio/src/main · high confidence
Added example resources for logging and web interface
The examples module now includes a logback configuration file that sets up console logging with an INFO level root logger, and a basic HTML page for the webapp that displays the current request path and a logo image.
examples/src/main/resources · high confidence
Added generated boilerplate for tuple arity and conversion operations
The build now includes auto-generated source files in the \core/src/main/boilerplate-gen\ directory, specifically \ParamsToSeq\, \SeqToParams\, \TupleArity\, and \TupleOps\. These files provide compile-time type-level utilities for determining tuple arity (up to 21 elements) and converting between sequences and tuples, which are required for the library's internal type-level programming infrastructure.
core/src/main/boilerplate-gen · high confidence
Added performance testing infrastructure and documentation
The perf-tests area now includes comprehensive documentation for running end-to-end performance simulations using Gatling, including setup instructions for JDK 21+ and Loom, configuration of user counts and durations, and profiling guidance with async-profiler. Additionally, a new micro-benchmarking script (run-benchmarks.sh) has been added to automate JMH benchmarks with async-profiler integration for generating flame graphs, and historical performance test results have been committed to provide baseline metrics for comparison.
perf-tests · high confidence
Initial AWS SAM template generation support
This change introduces the core implementation for generating AWS SAM (Serverless Application Model) CloudFormation templates from Tapir endpoints within the \serverless/aws/sam\ module. It adds the \AwsSamInterpreter\ to convert endpoints into SAM resources, \EndpointsToSamTemplate\ to handle the mapping logic (including support for code and image-based Lambda functions, HTTP API configuration, CORS, and Lambda authorizers), and \AwsSamTemplateEncoders\ to serialize the result to YAML. The feature also includes \AwsSamOptionsParameterized\ to allow users to define input parameters that can be referenced in the generated template, enabling dynamic configuration of runtime, code URIs, and roles.
serverless/aws/sam · high confidence
Initial support for generating .proto files from Tapir endpoints
This change introduces a new capability in the \grpc/protobuf\ module to automatically generate Protocol Buffer (\.proto\) schema files from Tapir gRPC endpoints. It adds a set of new Scala classes—including \EndpointToProtobufMessage\, \EndpointToProtobufService\, \ProtobufInterpreter\, and \ProtoRenderer\—that interpret Tapir endpoint definitions (handling inputs, outputs, products, coproducts, and scalar types) and render them into valid proto3 syntax. A \ProtoSchemaGenerator\ utility is also provided to write the generated content to a file, allowing users to export their API contracts as protobuf definitions.
grpc/protobuf/src/main · high confidence
Introduce AWS CDK module for deploying Tapir endpoints to AWS Lambda
This change adds a new \serverless/aws/cdk\ module that allows users to generate AWS CDK TypeScript stacks from Tapir server endpoints. The module provides an \AwsCdkInterpreter\ and \AwsCdkOptions\ to configure Lambda runtime, timeout, memory, and handler details, then generates a complete CDK application template (including \cdk.json\, \tsconfig.json\, and stack definitions) that provisions an API Gateway and Lambda function. It includes internal logic to parse Tapir endpoints into a request tree and render the corresponding TypeScript CDK code, along with tests to verify the template generation and endpoint parsing.
serverless/aws/cdk · high confidence
Introduce AWS Terraform module for generating infrastructure code
Adds a new \serverless/aws/terraform\ module that allows users to generate Terraform configuration files for deploying Tapir endpoints on AWS. The module provides an \AwsTerraformInterpreter\ to convert Tapir endpoints into an \AwsTerraformApiGateway\ model, which is then encoded into JSON using \AwsTerraformEncoders\. The generated configuration provisions an AWS API Gateway v2 (HTTP protocol), an AWS Lambda function, associated IAM roles and permissions, and the necessary routes and integrations. Users can configure options such as the AWS region, Lambda function name, timeout, memory size, and source (S3, image, or code file) via \AwsTerraformOptions\.
serverless/aws/terraform · high confidence
Introduce Armeria server interpreter with Future-based API
This change adds a new server interpreter for the Armeria HTTP framework, enabling users to run Tapir endpoints using Scala \Future\ instead of the previous implementation. It includes the core interpreter logic (\TapirFutureService\), request/response body handling (\ArmeriaRequestBody\, \ArmeriaToResponseBody\), and route mapping (\RouteMapping\) that correctly identifies streaming requirements (unary, request/response/bidi) based on endpoint inputs and outputs. The implementation also provides \ArmeriaFutureServerOptions\ for customizing interceptors and file handling, along with a dedicated test suite to verify the new behavior.
server/armeria-server · high confidence
Introduce Cats-effect integration for the Vert.x server interpreter
This change adds a new \server/vertx-server/cats\ module that provides a Cats-effect (fs2) interpreter for the Vert.x server. It introduces \VertxCatsServerInterpreter\ and \VertxCatsServerOptions\ to bridge Vert.x's \Future\-based API with Cats \Async\ effects, enabling support for fs2 streams and WebSockets within the Cats ecosystem. The implementation includes specific handling for dispatcher-based execution, stream compatibility, and WebSocket frame decoding, along with corresponding test suites to validate the integration.
server/vertx-server/cats · high confidence
Introduce Finatra-Cats server interpreter for Cats Effect
A new \finatra-cats\ module has been added to the Finatra server implementation, providing a \FinatraCatsServerInterpreter\ that bridges Finatra's native \com.twitter.util.Future\ with Cats Effect's \Async\ type class. This allows users to define Tapir server endpoints using \cats.effect.IO\ (or other \Async\ types) while running on the Finatra framework, handling necessary conversions for file operations, interceptors, and request handling via a provided \Dispatcher\.
server/finatra-server/cats · high confidence
Introduce Netty Sync server with Ox-based streaming
A new synchronous Netty server implementation is available in the \server/netty-server/sync\ module, leveraging the Ox concurrency library for direct-style, structured concurrency. This server supports streaming responses (including Server-Sent Events and WebSockets) via Ox flows, allows optional interruption of server logic when requests are cancelled, and defaults to returning a 404 response for unmatched requests. It includes dedicated components for handling multipart uploads, managing reactive streams within the Ox scope, and provides a comprehensive test suite covering timeouts, large stream handling, and graceful shutdown.
server/netty-server/sync · high confidence
Introduce Scala code generation CLI
A new command-line interface is added to generate Scala client/server code from OpenAPI specifications. The \genscala\ subcommand allows users to specify the input OpenAPI file, output package and object names, target Scala version (2 or 3), and various code generation options such as grouping endpoints by tag, enabling validation, customizing JSON/XML libraries, and controlling schema deduplication.
openapi-codegen/cli · high confidence
Introduce ZIO-specific http4s server interpreter and stream conversion
This change adds a new \ztapir\ package within the http4s ZIO server module, providing \ZHttp4sServerInterpreter\ to bridge Tapir's ZIO-based server endpoints (\ZServerEndpoint\) with http4s routes. It includes \ConvertStreams\ to automatically translate between ZIO streams and FS2 streams (used by http4s) for both regular HTTP responses and WebSocket bodies, as well as a \serverSentEventsBody\ helper for SSE support. The addition is accompanied by comprehensive test suites (\ZHttp4sServerTest\, \ZHttp4sServerStubTest\) verifying streaming, WebSocket, and SSE functionality using the Ember server.
server/http4s-server/zio · high confidence
Introduce dedicated Netty Cats server interpreter
A new, separate Netty server interpreter for Cats Effect has been added, extracting the Cats-specific logic from the main Netty module. This new \NettyCatsServerInterpreter\ integrates with Cats Effect 3's \Dispatcher\ to handle asynchronous execution, supports Fs2 streams for request and response bodies, and includes full WebSocket support with improved frame handling and cancellation semantics. The change also includes specific test suites for streaming cancellation and interrupted connections to ensure robust behavior.
server/netty-server/cats · high confidence
Introduce dedicated client options for file creation
Client interpreters for http4s, Play, sttp, and sttp4 now expose a \createFile\ configuration option, allowing users to customize how temporary files are generated during multipart uploads or downloads. Each client module (e.g., \Http4sClientOptions\, \SttpClientOptions\) includes a \default\ setting that uses \Defaults.createTempFile\, ensuring backward compatibility while enabling custom file handling strategies.
repository · high confidence
Introduce direct-style AWS Lambda server interpreter
The \serverless/aws/lambda-core\ module now provides a direct-style server interpreter for AWS Lambda, adding \AwsSyncServerInterpreter\ and \AwsFutureServerInterpreter\ alongside \SyncLambdaHandler\ and \AwsServerOptions\. This new implementation allows users to expose Tapir endpoints via a synchronous, direct-style entry point (supporting both \Identity\ and \Future\ effect types) that handles request decoding, V1-to-V2 API Gateway normalization, and response encoding, replacing or supplementing previous interpreter approaches in this core module.
serverless/aws/lambda-core · high confidence
Introduce http4s client interpreter
Added a new client interpreter for the http4s library, allowing Tapir endpoints to be converted into http4s client requests. This includes the \Http4sClientInterpreter\ class for interpreting public and secure endpoints, an \EndpointToHttp4sClient\ implementation that handles request construction (including path, query, headers, and body encoding), and \Http4sClientOptions\ for configuring client behavior such as file creation.
server/netty-server/zio · high confidence
Introduce new ZIO HTTP server interpreter with WebSocket and multipart support
This change adds a new \zio-http-server\ module that provides a complete server interpreter for the ZIO HTTP library. It introduces full support for ZIO Streams and WebSockets, including handling of fragmented WebSocket frames, auto-pong, and auto-ping. The implementation also adds streaming multipart body parsing and configurable input stream chunk sizes. Additionally, it enables nesting ZIO HTTP routes under a prefix and ensures that ZIO HTTP middlewares are executed only once per request.
server/zio-http-server · high confidence
Introduce sbt OpenAPI codegen plugin with extensive configuration options
This change introduces the \OpenapiCodegenPlugin\ for sbt, which generates Tapir definitions from OpenAPI/Swagger files. The plugin exposes a comprehensive set of configuration keys allowing users to specify the swagger file location, package and object names, and whether to use head tags for object names. It supports multiple JSON serialization libraries (circe, jsoniter) and XML libraries (cats-xml), as well as various streaming implementations (akka, fs2, pekko, zio). Additional features include validation of non-discriminated oneOfs, splitting models into separate files, generating explicit endpoint types, disabling validator generation, using custom jsoniter serdes, adding additional package mappings, managing package dependencies for type aliases, and handling disambiguation codes for ambiguous responses. The plugin also implements incremental compilation by only regenerating sources when input YAMLs or configuration change.
openapi-codegen/sbt-plugin/src/main · high confidence
Introduction of NoStreams capability trait
A new \NoStreams\ trait has been added to the \sttp.tapir.capabilities\ package, providing a concrete implementation of the \Streams\ capability that uses \Nothing\ for both \BinaryStream\ and \Pipe\ types. This allows users to explicitly opt out of stream support in their Tapir endpoints, ensuring that no stream-related functionality is available or expected.
core/src/main/scala/sttp/tapir/capabilities · high confidence
Introduction of direct Protobuf codec support in gRPC
The grpc/pbdirect module now provides a new TapirProtobufPbDirect trait and package object that enable direct serialization and deserialization of Protobuf messages using the pbdirect library. This change introduces a specific Codec\[Array\[Byte\], T, CodecFormat.Grpc\] implementation, allowing users to leverage pbdirect codecs for gRPC body handling, which improves error reporting and simplifies the integration of Protobuf types with Tapir endpoints.
grpc/pbdirect · high confidence
New AWS Lambda and deployment examples for Scala.js and JVM
Added a suite of example applications in the serverless/aws/examples module demonstrating how to run Tapir APIs on AWS Lambda using Scala.js (with both Future and Cats Effect IO runtimes) and the JVM (using Cats Effect IO and synchronous handlers). The examples also include deployment configurations for AWS CDK, AWS SAM, and Terraform, providing concrete templates for infrastructure-as-code integration.
serverless/aws/examples · high confidence
New Cats integration module with typeclass instances and codecs
The \sttp.tapir.integ.cats\ package now provides a comprehensive set of Cats integration features. Users can now leverage \InvariantSemigroupal\ and \InvariantMonoidal\ typeclass instances for \EndpointIO\, \EndpointInput\, and \EndpointOutput\, enabling more flexible composition of endpoint definitions. The module adds \Functor\ support for \Example\ and \ModifyFunctor\ instances for Cats collection types like \NonEmptyList\, \NonEmptySet\, \Chain\, and \NonEmptyChain\. Additionally, it introduces Schema and Codec definitions for these non-empty collections, ensuring they are validated as non-empty during decoding. Finally, syntax extensions are provided for \MonadError\ and \ServerEndpoint\, allowing users to transform effect types using natural transformations (\imapK\).
integrations/cats/src/main · high confidence
New Cats-effect server interpreter for Armeria
Users can now interpret Tapir server endpoints using Cats-effect's Async typeclass with the Armeria HTTP server. This new module provides an interpreter that bridges Armeria's request handling with Cats-effect's asynchronous runtime, enabling seamless integration of Cats-effect based server logic within the Armeria framework.
server/armeria-server/cats · high confidence
New JSON pickler module with configurable serialization and derivation
The \json/pickler/src/main\ area introduces a new \sttp.tapir.json.pickler\ package that provides a compile-time derivation system for JSON serialization. Users can now automatically derive \Pickler\ instances for case classes and sealed hierarchies (enums) using \Pickler.derived\ or \Pickler.derivedEnumeration\. This module adds support for customizing serialization behavior via \PicklerConfiguration\, including options to skip serializing \None\ values (\transientNone\), apply naming conventions like snake\_case or screaming snake\_case to field names and discriminator values, and define custom discriminators for sealed traits. It also includes helper methods like \jsonBody\ and \jsonQuery\ to easily integrate these derived picklers into endpoint definitions.
json/pickler/src/main · high confidence
New JSON serialization examples for Circe, Jsoniter, and streaming
Added four new Scala examples in the JSON examples directory demonstrating how to use Tapir with different JSON libraries and server configurations. The examples include a Circe-based Netty sync server with auto-derived codecs, a Circe example showing how to serialize null bodies, a Jsoniter-based Netty sync server, and a Jsoniter streaming example that parses JSON from an input stream without accumulating it in memory, complete with Swagger UI documentation.
examples/src/main/scala/sttp/tapir/examples/json · high confidence
New MatchType derivation macro for Scala 3
A new \MatchTypeMacros\ implementation has been added for Scala 3, providing an inline implicit derivation for \MatchType\ using Magnolia 1 and Scala's \Mirror\. This enables runtime type matching and validation for case classes and sealed traits by leveraging Magnolia's derivation capabilities to recursively check instance compatibility and parameter types.
core/src/main/scala-3/sttp/tapir/typelevel · high confidence
New Netty Sync Server examples for Server-Sent Events
Added two new example files demonstrating Server-Sent Events (SSE) using the Netty sync server with ox-based streaming. The first example shows a basic endpoint emitting timed SSE events, while the second demonstrates an endpoint that conditionally returns either SSE or JSON responses based on a query parameter.
examples/src/main/scala/sttp/tapir/examples/sse · high confidence
New OpenAPI documentation examples for Scalar, ReDoc, and Pekko HTTP
Added new example files demonstrating how to expose OpenAPI documentation using the Scalar and ReDoc UIs, alongside updated examples for Pekko HTTP servers. These additions provide users with reference implementations for integrating Scalar and ReDoc with both http4s and ZIO HTTP backends, as well as examples for securing Swagger UI with OAuth 2.
examples/src/main/scala/sttp/tapir/examples/openapi · high confidence
New Play 2.9 HTTP client implementation
Added a new client module for Play 2.9 that interprets Tapir endpoints into Play's StandaloneWSRequest/Response model. This allows users to generate HTTP requests and parse responses using the Play 2.9 WebSocket client, supporting path, query, header, and body encoding, as well as secure endpoint handling.
client/play29-client/src/main · high confidence
New Scala 2 macro implementations for schema derivation and endpoint mapping
This change introduces a suite of new Scala 2-specific macro implementations in the \sttp.tapir.internal\ package to support automatic derivation and mapping. Key additions include \CaseClassUtil\ for reflection-based case class analysis, \SchemaAnnotationsMacro\ for deriving schema metadata from annotations, and macros for enumerations (\SchemaEnumerationMacro\, \CodecEnumerationMacro\) and value classes (\CodecValueClassMacro\). It also adds macros for generating \EndpointInput\ and \EndpointOutput\ from annotated case classes (\EndpointInputAnnotationsMacro\, \EndpointOutputAnnotationsMacro\), handling form and multipart codecs (\FormCodecMacro\, \MultipartCodecMacro\), and supporting \oneOf\ schemas (\OneOfMacro\). These macros enable compile-time generation of codecs, schemas, and endpoint mappings, reducing boilerplate for Scala 2 users.
core/src/main/scala-2/sttp/tapir/internal · high confidence
New Scala 3 macro implementations for schema derivation and codecs
The core library now includes a comprehensive set of Scala 3-specific macros in the \sttp.tapir.macros\ package to support automatic derivation and code generation. This adds support for deriving schemas for maps (including arbitrary keys), sealed traits, enums, and union types, as well as generating codecs for form data, multipart uploads, and enumerations. It also introduces macros for deriving endpoint inputs and outputs from case classes and provides utilities for modifying nested schemas and validating enumeration values, enabling seamless Tapir usage with Scala 3's type system features.
core/src/main/scala-3/sttp/tapir/macros · high confidence
New Scala 3 macro-based derivation for endpoint inputs, outputs, and schema annotations
This change introduces a suite of new Scala 3 macros in the \sttp.tapir.internal\ package to replace or supplement previous derivation mechanisms. \AnnotationsMacros\ now derives \EndpointInput\ and \EndpointOutput\ structures by inspecting case class fields for specific annotations (e.g., \@path\, \@query\, \@header\, \@body\, \@bearer\, \@basic\), enabling automatic construction of endpoint IOs from annotated data classes. \SchemaAnnotationsMacro\ derives schema metadata (description, example, default, format, deprecated, hidden, encodedName, validate, validateEach, customise) directly from field and class annotations. Additional macros handle value class codecs (\CodecValueClassMacro\), enumeration detection (\EnumerationMacros\), mapping between tuples and products (\MappingMacros\), and full type name extraction (\SNameMacros\). This provides a more robust, compile-time-checked foundation for Scala 3 users defining endpoints and schemas using annotations.
core/src/main/scala-3/sttp/tapir/internal · high confidence
New Tapir examples for Pekko HTTP, Netty, and static content serving
Added a suite of new example applications demonstrating Tapir's integration with Pekko HTTP and various Netty server configurations (including cats-effect, Future, and sync variants), as well as examples for serving static files from directories and resources with range request and security support.
examples/src/main/scala/sttp/tapir/examples · high confidence
New WebSocket server examples for Netty Sync, Http4s, ZIO HTTP, and Pekko
Added five new example files in the WebSocket examples directory demonstrating how to implement WebSocket endpoints using different server backends and effect systems: a multi-client chat using Netty Sync with Ox, a byte counter using Http4s with Ember, a basic echo and tick example using Netty Sync, a custom codec example using ZIO HTTP, a JSON example using ZIO HTTP, and an echo example using Pekko HTTP. These examples showcase the integration of Tapir's WebSocket support with various streaming capabilities (OxStreams, Fs2Streams, ZioStreams, PekkoStreams) and include client-side interaction code.
examples/src/main/scala/sttp/tapir/examples/websocket · high confidence
New ZIO + Netty logging example with correlation ID support
Added a new example demonstrating how to implement structured logging with correlation IDs in a ZIO-based Netty server. The example shows how to use a custom RequestInterceptor to annotate ZIO logs with a correlation ID extracted from the request header, and includes a client test that sends requests with and without the header to verify the logging behavior.
examples/src/main/scala/sttp/tapir/examples/logging · high confidence
New ZIO 2 integration for the Vert.x server
This change introduces a new server interpreter module for Vert.x that integrates with ZIO 2. It provides a \VertxZioServerInterpreter\ and \VertxZioServerOptions\ to handle HTTP requests and responses using ZIO effects (\RIO\), supporting ZIO streams for request/response bodies and WebSockets. The implementation includes specific handling for Vert.x 5 compatibility, such as managing response safety and pause/resume behavior on ended requests, and ensures that ZIO effects are not executed on the Vert.x event loop thread.
server/vertx-server/zio · high confidence
New ZIO integration module (ztapir)
This change introduces the \ztapir\ package, providing a dedicated integration layer for ZIO. It includes \RIOMonadError\ to support ZIO's effect types within Tapir's monad error abstraction, \ZTapir\ trait offering extension methods like \zServerLogic\ and \zServerSecurityLogic\ for defining ZIO-based server endpoints, and \ZioServerSentEvents\ for serializing and parsing Server-Sent Events using ZIO streams.
integrations/zio/src/main · high confidence
New client output parameter decoding logic in core module
The client/core module now includes a new ClientOutputParams class that handles the decoding of endpoint outputs into parameters. This implementation processes various output types including body codecs, one-of body variants, stream bodies, WebSocket bodies, headers, status codes, and mapped pairs. It specifically handles content-type matching for one-of variants and provides recursive decoding for nested output structures.
client/core · high confidence
New custom type handling examples for Tapir
Added five new Scala 3 examples in the custom\_types category demonstrating how to integrate custom types with Tapir endpoints. These include using custom codecs for path and query parameters (EndpointWithCustomTypes), a full semi-auto derivation demo with Pekko HTTP and Swagger UI (booksExampleSemiauto), handling comma-separated query parameters with enums (commaSeparatedQueryParameter), mapping Scala 3 enums to query parameters (enumQueryParameter), and serializing sealed trait hierarchies to JSON using discriminators (sealedTraitWithDiscriminator).
_examples/src/main/scala/sttp/tapir/examples/custom\types · high confidence
New error-handling examples for Tapir
Added five new Scala 3 examples in the errors package demonstrating advanced error handling patterns: using union types for error variants with http4s/Ember, customizing decode failure messages with Iron refinements on Netty, customizing decode failure responses on Pekko HTTP, converting all errors to a JSON Error case class on Pekko HTTP, and handling optional server logic results with 404 responses on Pekko HTTP.
examples/src/main/scala/sttp/tapir/examples/errors · high confidence
New http4s client interpreter for generating requests
Added the \Http4sClientInterpreter\ and \EndpointToHttp4sClient\ components in the \client/http4s-client\ module, enabling users to interpret Tapir endpoints into \org.http4s.Request\[F\]\ objects. This new interpreter supports encoding path segments, query parameters (including flag parameters and excluding empty values), headers, cookies, and various body types (including streaming bodies via fs2 and oneOf bodies), allowing direct integration with http4s clients.
client/http4s-client/src/main · high confidence
New http4s server interpreter with Ember, FS2 streams, and context support
The http4s server module has been rewritten to use the Ember server backend instead of Blaze, enabling support for Scala 3 and http4s 0.23+. This update introduces a new interpreter architecture that leverages FS2 streams for request and response bodies, adding support for Server-Sent Events (SSE) and stream-based WebSockets. It also adds the ability to access http4s middleware context (such as authentication data) via \contextIn\ and \contextSecurityIn\ inputs, and allows customization of server options like interceptors and file handling through \Http4sServerOptions\.
server/http4s-server · high confidence
New macro-based derivation for schemas, codecs, and endpoint mappings
The Scala 2 macro implementation in the tapir core has been reorganized and expanded to provide new automatic derivation capabilities. Users can now derive schemas for arbitrary map keys (not just String keys) via \Schema.schemaForMap\, and generate schemas and codecs for Scala enumerations and value classes using dedicated macro methods. Additionally, endpoint inputs and outputs can now be automatically derived from annotated case classes via \EndpointInput.derived\ and \EndpointOutput.derived\, and mapping methods like \mapInTo\ and \mapSecurityInTo\ are now implemented via macros for more convenient endpoint construction.
core/src/main/scala-2/sttp/tapir/macros · high confidence
New observability examples for tracing and metrics
Added five new Scala example files in the observability package demonstrating how to integrate Tapir with OpenTelemetry and other monitoring tools. These include examples for OpenTelemetry tracing with Netty sync servers, ZIO OpenTelemetry tracing with ZIO HTTP, and metrics reporting via Prometheus, DataDog, and OpenTelemetry OTLP exporters with Netty Future servers.
examples/src/main/scala/sttp/tapir/examples/observability · high confidence
New security examples for OAuth2, Basic Auth, CORS, and external role verification
Added several new Scala examples in the security package demonstrating modern authentication and security patterns. These include an OAuth2 example using Google and NettySyncServer, Basic Authentication with Pekko HTTP, CORS interceptor configurations for both Pekko HTTP and Vert.x servers, an external security interceptor example for Netty that validates roles via headers, and examples showing how to separate security logic from server logic using reusable base endpoints with Pekko HTTP (including cookie refresh).
examples/src/main/scala/sttp/tapir/examples/security · high confidence
New static content API for serving files and resources
The \files\ module now exposes a new static content API that allows serving files from the local filesystem and resources from the classpath. This includes endpoints for GET and HEAD requests, support for range requests, conditional requests via ETags and Last-Modified headers, and automatic serving of pre-gzipped content when supported by the client. The API provides \staticFilesGetServerEndpoint\ for local files and \staticResourcesGetEndpoint\ for classpath resources, both configurable with prefixes and extra headers.
files · high confidence
New streaming and client interpreter examples for http4s, Netty, ZIO, Pekko, and Ox
Added a suite of new example files in the streaming and client directories demonstrating how to handle streaming request and response bodies across multiple server backends and effect systems. These include http4s with fs2 streams (proxying, standard streaming, and error handling), Netty with both Cats Effect and ZIO, ZIO HTTP, Pekko HTTP, and a new synchronous Netty example using Ox Flows. Additionally, a new http4s client interpreter example shows how to derive requests and response parsers from Tapir endpoints.
examples/src/main/scala/sttp/tapir/examples/streaming · high confidence
New sttp-based MockServer client for testing
Adds a new \SttpMockServerClient\ implementation in the \server/sttp-mock-server\ module, enabling users to configure and verify expectations against a MockServer instance using sttp-client4. This client supports creating expectations for both success and error responses (including JSON and plain text bodies), verifying request counts, and clearing or resetting the mock server state, with dedicated JSON codecs and model definitions to handle request/response serialization.
server/sttp-mock-server · high confidence
New sttp-stub-server module for testing Tapir server endpoints
A new \sttp-stub-server\ module has been added, providing a way to test Tapir server endpoints by stubbing the underlying HTTP server using the sttp client library. This module introduces \TapirStubInterpreter\ and \SttpStubServer\ to allow developers to define expected responses for specific endpoint inputs, handle security logic, and apply custom interceptors, effectively enabling unit testing of server-side logic without running a real HTTP server.
server/sttp-stub-server · high confidence
New sttp-stub4-server module for Tapir stubbing
A new \sttp-stub4-server\ module has been added, providing a stub server implementation built on top of sttp client4. This module introduces \TapirStubInterpreter\ classes (sync, stream, and WebSocket variants) that allow users to create stub backends for testing Tapir endpoints. It includes \SttpRequest\, \SttpRequestBody\, \SttpRequestDecoder\, and \SttpResponseEncoder\ to bridge Tapir's server request/response models with sttp client4's types, supporting features like multipart bodies, file ranges, and one-of body mappings.
server/sttp-stub4-server · high confidence
Prometheus metrics implementation with configurable endpoint and phase tracking
The Prometheus metrics module now provides a concrete implementation for collecting HTTP request metrics, including active request gauges, total request counters, and request duration histograms. Users can expose metrics via a configurable endpoint (defaulting to 'metrics') and customize the namespace. The request duration histogram now includes a 'phase' label to distinguish between header and body processing times, and supports custom bucket configurations. Additionally, the implementation correctly handles responses generated by interceptors by using a placeholder endpoint for label generation, ensuring consistent metric labeling across all request paths.
metrics/prometheus-metrics/src/main · high confidence
Repository initialization and build configuration setup
The repository has been initialized with a comprehensive set of configuration files to support the Tapir project's build and development workflow. This includes setting up the build tool (sbt) with increased memory limits in .sbtopts, configuring the Scala code formatter (scalafmt) for multi-version support, and defining dependency update rules via .scala-steward.conf. Additionally, the project now includes a ReadTheDocs configuration for documentation hosting, a scalafix configuration for import organization, and a context7.json file providing AI-assisted coding rules. The legacy version.sbt file has been removed in favor of the new configuration structure.
(repo-wide) · high confidence
Support for Iron intersection and union type predicates
The Iron integration now supports complex type predicates using intersection (AND) and union (OR) logic. This change introduces \IntersectionTypeMirror\ and \UnionTypeMirror\ macros to decompose compound Iron types into individual constraints, allowing the codec layer to validate values against multiple predicates simultaneously (e.g., \String :\| (MinLength\[5\] & MaxLength\[10\])\) or accept values matching any of several constraints. This enables more sophisticated validation rules in Tapir schemas and codecs that leverage the Iron library's advanced type-level features.
integrations/iron/src/main · high confidence
Support for delimited query parameters in Scala 3/2.13+
Users of Scala 3 or Scala 2.13+ can now handle query parameters that contain multiple values separated by a delimiter (such as commas). This change introduces a new \delimited\ codec extension that automatically splits incoming strings into a list of values for decoding and joins them back together for encoding. The schema for these parameters is configured with \explode=false\ and the specific delimiter, ensuring correct representation in OpenAPI documentation and proper parsing of multi-value inputs.
core/src/main/scala-3-2.13+ · high confidence
Removals
Removal of experimental Swagger code generation scaffolding
The experimental Swagger-first code generation scaffolding in the core module has been removed. This includes the deletion of \AroundDirectives.scala\ (Akka HTTP request/response wrapping logic), \Main.scala\ (the primary DSL for defining endpoints, path segments, and server/client generation logic using Shapeless), and \Method.scala\ (HTTP method definitions). Users relying on this initial prototype for generating Akka HTTP routes or clients from Swagger definitions will no longer have access to these components.
core/src/main/scala/com · high confidence
Security
OpenAPI codegen security hardening and Scala 3 support
The OpenAPI codegen core has been refactored to address code injection vulnerabilities ([GHSA redacted]) by validating and escaping untrusted input from OpenAPI specifications, including server URLs, parameter locations, and schema references. Additionally, the code generator now supports Scala 3, utilizing version-specific helper files to handle reserved keywords and generating native Scala 3 enums with appropriate derivation macros instead of the previous enumeratum-based approach.
openapi-codegen/core/src/main · high confidence
Architecture
Enumeration codec and schema derivation macros moved to macros package
The internal macro implementations for deriving enumeration codecs and schemas have been relocated to the \sttp.tapir.macros\ package. This change introduces \CreateDerivedEnumerationCodec\ and \CreateDerivedEnumerationSchema\ classes, which handle the generation of codecs and schemas for Scala enumerations, including support for string-based defaults and validation. Additionally, a \ModifyMacroFunctorSupport\ trait is added to support macro-based modification patterns. This refactoring isolates macro logic, potentially improving build times or binary compatibility, while preserving the existing enumeration derivation capabilities.
core/src/main/scala/sttp/tapir/macros · high confidence
Behavioural changes
Add Scarf analytics tracking to documentation
The documentation templates now include a Scarf tracking pixel in the footer of every page. This change injects a specific image tag with a no-referrer policy into the generated HTML, enabling usage analytics for the project without altering the visual layout for users.
_doc/\_templates, generated-doc/out/\templates · high confidence
Added boilerplate templates for tuple and sequence parameter conversion
The codebase now includes generated boilerplate templates for handling tuple arity, tuple operations (joining, folding, appending), and conversions between sequences and parameter tuples. These templates enable the framework to correctly process nested tuples and support \jsonBody\[Unit\]\ by providing the necessary compile-time type-level machinery for parameter manipulation in client interpreters.
core/src/main/boilerplate · medium confidence
Caching test suite now uses sttp-apispec for OpenAPI generation
The sbt-plugin caching test has been updated to generate OpenAPI documentation using the sttp-apispec library instead of the previous sttp-tapir-based approach. This change reflects a migration in the test's code generation workflow to align with the newer sttp-apispec integration.
openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/caching/src · high confidence
Circe JSON integration with improved error reporting and query parameter support
The Circe integration now provides dedicated methods for handling JSON bodies (including a raw string variant) and JSON query parameters. Decoding errors are accumulated using Circe's \decodeAccumulating\ to report multiple failures at once, with error paths split into specific field names for clearer diagnostics. Additionally, schemas for \Json\ and \JsonObject\ are explicitly defined to support arbitrary JSON handling.
json/circe/src/main · high confidence
Documentation site migrated to Sphinx with mdoc and Nix dev shell
The documentation build system has been replaced with Sphinx, utilizing mdoc for compiling Scala code examples and the Read the Docs theme. This change introduces a Nix flake for the documentation development environment, a Makefile for building, and custom CSS for example tags. The site now includes an adopters page, a new 'generate' page embedding the adopt-tapir form, and an llms.txt file for AI agent discovery.
doc · high confidence
Documentation site rebuilt with Sphinx and Read the Docs theme
The generated documentation site has been migrated to a Sphinx-based build system using the Read the Docs theme. This update introduces a new project structure including a Makefile, Python 3.12 environment, and Nix flake for local development. The site now features a redesigned adopters page with company logos, a new 'Generate a Tapir project' section with an embedded form, and custom CSS styling for example tags. The build configuration also enables the sphinx-llms-txt extension for AI agent support.
generated-doc/out · high confidence
Extract CatsMonadError to new tapir-cats-effect module
The CatsMonadError implementation has been moved from the tapir-cats integration into a new, dedicated tapir-cats-effect module. This change isolates the Cats Effect-specific monad error handling logic, making it available as a standalone component for users who wish to integrate Tapir with Cats Effect without pulling in the broader tapir-cats dependencies.
integrations/cats-effect · high confidence
Finatra server interpreter migrated to explicit interpreter architecture
The Finatra server module has been rewritten to use an explicit interpreter pattern, introducing dedicated components such as FinatraServerInterpreter, FinatraRequestBody, FinatraToResponseBody, and FinatraBodyListener. This migration replaces the previous implementation with a modular structure that handles request parsing, response body conversion, and streaming support (via FileChunk and RangeInputStream) while integrating with the standard Tapir interceptor and server options framework.
server/finatra-server · high confidence
Internal path template rendering logic moved to dedicated class
The logic for generating string representations of endpoint path and query templates has been extracted into a new internal \ShowPathTemplate\ object. This change encapsulates the formatting of path captures, fixed paths, and query parameters, making the internal implementation more modular without altering the public API or user-facing behavior.
core/src/main/scala/sttp/tapir/internal · high confidence
Introduce NettyFutureServer with comprehensive configuration and compression support
The Netty server implementation has been refactored into a new \NettyFutureServer\ component, replacing the previous structure. This change introduces a unified \NettyConfig\ that centralizes networking settings, including explicit support for HTTP response compression via \NettyCompressionConfig\, configurable timeouts (request, connection, idle, linger), and socket options (TCP\_NODELAY, keep-alive, buffer sizes). The server now supports graceful shutdown with a configurable timeout and allows custom routes to be added via a \RejectHandler\ mechanism. Additionally, the \NettyFutureServerInterpreter\ and \NettyFutureServerOptions\ provide a streamlined way to configure interceptors and file handling for the Future-based async model.
server/netty-server · high confidence
Introduction of Mapping abstraction and reorganization of core Tapir types
The core module now introduces a new \Mapping\ trait that provides a bi-directional, composable way to transform between low-level and high-level types, integrating validation directly into the decode/encode cycle. This abstraction underpins the refactored \Codec\ system, allowing mappings to be chained and validated. Additionally, the \Tapir\ trait and associated aliases have been reorganized to expose these new core types (\Mapping\, \Codec\, \StreamBodyIO\) and consolidate type aliases in \TapirAliases\, while the \package.scala\ continues to provide the main entry point for the library's public API.
core/src/main/scala/sttp/tapir · high confidence
Migrate Akka HTTP server to explicit interpreters and new interceptor model
The Akka HTTP server implementation has been rewritten to use an explicit interpreter pattern, introducing \AkkaHttpServerInterpreter\ and \AkkaHttpServerOptions\ to replace the previous implicit-based approach. This change brings the Akka HTTP module in line with other server interpreters by supporting a new interceptor framework (including request, exception, and logging interceptors) and explicit configuration of file creation/deletion and logging. The migration also includes updated handling of request bodies, response bodies, web sockets, and Server-Sent Events (SSE), along with specific fixes for HEAD requests, strict body handling, and stream size exceptions.
server/akka-http-server · high confidence
Migrate http4s server from Blaze to Ember
The http4s server backend now uses the Ember HTTP client instead of the legacy Blaze implementation. This change improves performance and compatibility with modern http4s versions, providing a more robust foundation for server-side HTTP handling.
project · high confidence
Migrate sttp client interpreter to explicit options and sttp-client 3
The sttp client interpreter has been migrated to use sttp-client 3 and now requires explicit configuration via \SttpClientOptions\ (passed to the interpreter) rather than relying on implicit defaults. This change introduces a new \SttpClientOptions\ case class that accepts a \createFile\ function for handling file uploads, and updates the \WebSocketToPipe\ trait to support the new capabilities model. Users will now see stricter handling of request encoding, including explicit support for flag query parameters and improved content-type header management for multipart bodies, while the interpreter methods now take options as explicit parameters instead of relying on implicit resolution.
client/sttp-client/src/main/scala · high confidence
New WebSocket exception types added to model package
The model package now includes specific exception classes for WebSocket handling: UnsupportedWebSocketFrameException and WebSocketFrameDecodeFailure. These exceptions extend the existing WebSocketException base class and provide detailed error messages including the problematic frame and, in the case of decode failures, the underlying decode result failure. This allows users to catch and handle specific WebSocket error conditions more precisely.
core/src/main/scala/sttp/tapir/model · high confidence
New automatic schema derivation for Scala 2 using Magnolia
The Scala 2 generic auto-derivation module has been restructured to use the Magnolia library for generating schemas. This change introduces new source files (SchemaDerivation.scala, SchemaMagnoliaDerivation.scala, and package.scala) that replace previous macro-based implementations. Users benefit from improved support for deriving schemas for tuples, sealed traits with discriminator fields, and value classes, as well as the ability to apply annotations like @title, @validateEach, and @encodedName during automatic schema generation.
core/src/main/scala-2/sttp/tapir/generic/auto · high confidence
New static content endpoints with range request and caching support
The \core/src/main/scalajvm/sttp/tapir/static\ module introduces a new implementation for serving static files and resources, featuring support for HTTP range requests (partial content via 206 status), ETag-based conditional requests (If-None-Match), and If-Modified-Since headers. The new endpoints automatically determine MIME types from file extensions and handle path traversal security checks. Existing methods like \filesGetEndpoint\ and \resourcesGetEndpoint\ are now deprecated in favor of the new API, which provides more granular control over static content serving including HEAD request support and proper handling of Accept-Encoding for potential future compression integration.
core/src/main/scalajvm/sttp/tapir/static · high confidence
Play client interpreter migrated to explicit options and Play 3
The Play HTTP client implementation has been refactored to support Play 3 and uses an explicit \PlayClientOptions\ configuration object instead of relying on implicit parameters. This change updates the client interpreter to accept options directly, allowing users to customize client behavior (such as file creation via \TapirFile\) explicitly when instantiating the interpreter, rather than depending on implicit resolution.
client/play-client/src/main · high confidence
Play server interpreter migrated to Pekko Streams
The Play server interpreter has been rewritten to use Pekko Streams instead of the previous Akka Streams implementation. This migration updates the underlying streaming capabilities (PekkoStreams) and aligns the server with the Play framework's transition to Pekko HTTP. Users will see the Play server now relying on the Pekko actor system and stream materializers, ensuring compatibility with the latest Play versions while maintaining existing API surface for routing, WebSocket handling, and body parsing.
server/play-server · high confidence
Refactor Scala 2 generic derivation to use Magnolia 1
The Scala 2 generic derivation implementation has been reorganized to utilize Magnolia 1 for generating derived typeclass instances. This change updates the internal macro logic to delegate to Magnolia's generation capabilities, aligning the library with the newer Magnolia API while maintaining the existing derived functionality for users.
core/src/main/scala-2/sttp/tapir/generic/internal · medium confidence
Refactored server interceptor API with new context types and combined logging
The server interceptor API has been restructured to improve extensibility and logging precision. A new \CustomiseInterceptors\ class centralizes the configuration of the interceptor stack, allowing users to easily customize or disable built-in interceptors (metrics, CORS, reject, exception, logging) and add custom ones. New context classes (\DecodeFailureContext\, \DecodeSuccessContext\, \SecurityFailureContext\) provide richer information to interceptors. Logging and exception handling are now combined in \ServerLogAndExceptionInterceptor\ to ensure exceptions are logged before being handled, and the \ServerLog\ trait has been expanded with more granular callbacks (e.g., \requestHandledByInterceptor\, \securityFailureHandled\). The \ExceptionHandler\ and \RejectHandler\ are now effectful, and a new \EndpointHandler\ trait decouples the handling of decode success, security failure, and decode failure events.
server/core · high confidence
Refactored type-level tuple and type-matching operations
The type-level utilities in the \sttp/tapir/typelevel\ package have been restructured to improve how nested tuples are handled in server and client interpreters and to enhance runtime type checking. New traits \BinaryTupleOp\, \ErasureSameAsType\, and \MatchType\ have been introduced to support these capabilities, with \MatchType\ providing thread-safe type matching without relying on \TypeTag\. The \ParamConcat\ trait and its associated implicit resolution hierarchy have been rewritten to manage parameter list concatenation and arity calculations more robustly, ensuring correct tuple joining for endpoint inputs and outputs.
core/src/main/scala/sttp/tapir/typelevel · high confidence
Refined URL encoding and MIME type handling in path rendering
The internal path rendering logic now uses RFC 3986-compliant encoding for path segments and standard URL encoding for query parameters, ensuring that special characters in paths are handled correctly according to web standards. Additionally, the MIME type database lookup has been moved to JVM-specific sources, maintaining consistent content-type resolution for file extensions on the JVM platform.
core/src/main/scalajvm/sttp/tapir/internal · high confidence
Refined macro support for modifying collections and maps in Scala 2.13+
The internal macro implementation for modifying collections and maps has been updated to leverage Scala 2.13-specific collection APIs. In Scala 2.13+, the \ModifyMacroSupport\ trait now uses \Factory\ and \Iterable\ for traversable modifications and provides a simpler \each\ extension method for maps. For Scala 2.13-, the implementation retains the legacy \CanBuildFrom\ and \TraversableLike\ approach but also exposes a dedicated \ModifyMapAtFunctor\ trait for map-specific modifications. This change ensures that the \each\ modifier works correctly with the respective collection hierarchies of each Scala version, maintaining consistent behavior for users modifying nested structures.
core/src/main/scala-2.13- · high confidence
Sbt-openapi-codegen test suites now target OpenAPI 3.1.0
The sbt-openapi-codegen scripted tests (minimal and option-overrides) have been updated to generate OpenAPI 3.1.0 specifications. This is evidenced by the generated swagger.yaml files now declaring 'openapi: 3.1.0' and the Main.scala files importing from sttp.apispec.openapi.circe.yaml instead of the previous sttp.tapir equivalents, reflecting the migration to sttp-apispec.
openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/minimal, openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/option-overrides · high confidence
Security logic can now contribute to the response output
The server endpoint API has been updated to allow security logic to return additional data that is automatically included in the final HTTP response. Previously, security checks only determined access (principal or error); now, via the new \PartialServerEndpointWithSecurityOutput\ and \PartialServerEndpointWithSecurityOutputSync\ classes, security handlers can return a \SECURITY\_OUTPUT\ alongside the principal. This output is prepended to the main endpoint's output, enabling use cases like returning authentication tokens, user metadata, or headers directly from the security layer without requiring the main business logic to re-fetch or re-calculate that information.
core/src/main/scala/sttp/tapir/server · high confidence
Stabilize MatchType macro implementation using Magnolia
The MatchType typeclass derivation for Scala 2 has been refactored to use Magnolia for automatic macro generation, replacing the previous experimental implementation. This change stabilizes the MatchType functionality, making it a non-experimental feature for users relying on automatic type matching derivation.
core/src/main/scala-2/sttp/tapir/typelevel · high confidence
Static content endpoints trait moved to JVM-only sources
The \TapirStaticContentEndpoints\ trait has been relocated from the shared Scala.js sources to the JVM-only sources directory. This change restricts the availability of this specific trait to JVM-based applications, effectively removing it from the Scala.js build target while keeping the implementation logic intact for native JVM usage.
core/src/main/scalajs/sttp/tapir/static · high confidence
Support for relative requests and platform-specific WebSocket handling in Scala.js client
The Scala.js sttp client now allows creating requests without a base URI, enabling relative requests when the \baseUri\ parameter is omitted in the new \toQuickClient\ and \toQuickSecureClient\ helper methods. Additionally, WebSocket success detection is handled specifically for the Scala.js platform by treating HTTP 200 OK as a successful connection, addressing a limitation where the 101 Switching Protocols status code is not accessible in this environment.
client/sttp-client/src/main/scalajs/sttp/tapir/client/sttp · high confidence
Support for relative requests and platform-specific WebSocket handling in Sttp client
The Sttp client integration now allows creating requests without a mandatory base URI, enabling relative requests when the \baseUri\ parameter is omitted. Additionally, WebSocket success status code detection is now handled via a platform-specific extension trait to address JVM/JS differences (specifically JS lacking access to the 101 status code).
client/sttp-client/src/main/scalajvm/sttp/tapir/client/sttp · high confidence
Vert.x server interpreter restructured for safer response handling and WebSocket support
The Vert.x server interpreter has been refactored to improve reliability and add new capabilities. Response termination is now handled via a new \RichResponse\ helper that checks if a response has already ended before closing it, preventing errors on double-closure. A dedicated \VertxErrorHandler\ trait ensures errors are handled consistently across interpreters. The \VertxFutureServerInterpreter\ now supports WebSockets and streaming via \VertxStreams\, and request decoding has been reorganized into specific decoders for request bodies and server metadata. Additionally, a \LimitedReadStream\ adapter enforces \MaxContentLength\ limits by throwing a \StreamMaxLengthExceededException\ when the byte limit is surpassed, and a \Pipe\ implementation manages backpressure for both HTTP streams and WebSocket frames.
server/vertx-server · high confidence
Fixes
Fix tethys package name copy-paste error
Corrected a copy-paste error in the tethys JSON integration module where the package declaration was incorrect. This ensures the \TapirJsonTethys\ trait and its associated codec implementations are properly located within the \sttp.tapir.json.tethys\ namespace, allowing users to correctly import and use the tethys-based JSON body and query codecs.
json/tethys · high confidence
Test coverage
Add Scala 3 test suite for oneOf JSON roundtrip and enum support; Add sbt-plugin test for zio-json oneOf roundtripping; Add sbt-plugin test suite for full Petstore code generation; Added Akka HTTP client tests for Scala 2; Added JSON roundtrip test for jsoniter with OneOf schemas; Added JVM-specific tests for Play JSON codec behavior; Added JVM-specific tests for custom Date serialization in uPickle integration; Added JVM-specific tests for date/time codecs and schema serialization; Added Play 2.9 client test suite; Added Play client test suite; Added Scala 2-specific tests for json4s codec; Added Scala 2-specific tests for schema derivation and companion apply behavior; Added Scala 3 jsoniter roundtrip test for oneOf schemas; Added Scala 3 oneOf JSON roundtrip test suite; Added Scala 3 test for jsoniter oneOf round-tripping and recursive schemas; Added Scala 3 test infrastructure for codegen; Added Scala 3 tests for Iron codec integration; Added Scala 3-specific test coverage for enums, union types, and codecs; Added Scala Native test extension trait for uPickle JSON support; Added Scala Native test extension traits; Added Scala Native test platform support; Added Scala Native test suite for sttp client; Added Scala.js test suite for Sttp client with ZIO support; Added Scala.js-specific test extensions for codec and type-level tests; Added client test suites for basic, multipart, streaming, and WebSocket operations; Added comprehensive test coverage for OpenAPI code generation; Added integration tests for AWS CDK; Added integration tests for generated code capabilities; Added petstore integration test verifying content negotiation and serialization; Added platform-specific test configuration for Scala.js and JVM; Added sbt-plugin test for oneOf JSON roundtripping; Added test coverage for cats integration instances; Added test coverage for core Tapir components; Added test coverage for sttp client request handling and multipart encoding; Added test coverage for sttp-client4 across multiple runtimes; Added test data for builtin typename collision scenarios; Added test for jsoniter serialization of inline enums in Scala 3; Added test for jsoniter-scala oneOf roundtrip code generation; Added test for separate model file generation; Added test infrastructure for type-level matching and JSON libraries; Added test server for client integration tests; Added test suite for Tapir endpoint definitions and utilities; Added test suite for the Pickler JSON serialization module; Added test suite for the http4s client interpreter; Added test suites for AWS Lambda handlers using Cats Effect and ZIO; Added test suites for AWS Lambda handlers using Cats Effect and ZIO; Added test suites for sttp client integration with ZIO, Pekko, and fs2; Added tests for Circe JSON decoding errors and schema handling; Added tests for Datadog metrics collection; Added tests for EndpointVerifier shadow detection logic; Added tests for JSON-specific decode error reporting; Added tests for MIME type lookup by file extension; Added tests for MatchType and ParamConcat type-level utilities; Added tests for OpenAPI codegen caching behavior; Added tests for OpenAPI codegen model parsers; Added tests for Play JSON codec integration; Added tests for Refined integration validation and compilation; Added tests for Scala 3 refined integration; Added tests for Spray JSON integration; Added tests for ZIO JSON codec integration; Added tests for ZIO TestMonadError instance; Added tests for ZIO integration error handling and Server-Sent Events serialization; Added tests for annotation-based endpoint input/output derivation; Added tests for delimited codec encoding and decoding; Added tests for enumeratum codec schema and validator behavior; Added tests for generic codec and schema derivation; Added tests for generic codec and schema derivation error handling; Added tests for legacy schema derivation in Scala 2; Added tests for macro-generated schema namespacing; Added tests for oneOf JSON roundtrip, binary content negotiation, and XML serialization; Added tests for the gRPC protobuf renderer and interpreter; Added unit tests for internal endpoint input/output utilities and URL encoding; Added unit tests for the uPickle JSON codec integration; Comprehensive server test suite and test infrastructure; New testing examples for Cats-effect and Pekko HTTP server stubs; Removed legacy test files in typed-schema and typedapi; Sbt-plugin test suite adds multi-file OpenAPI code generation scenario; Test suite for schema inheritance and aliasing behavior; Test verifies enum schema generation in OpenAPI output; Updated NiFi API code-generation test expectations.
Dependencies
Add documentation build dependencies and OpenAPI codegen test fixtures
The project now includes a \doc/requirements.txt\ file specifying the Python dependencies for building documentation (Sphinx 7.3.7, sphinx-rtd-theme 2.0.0, myst-parser 2.0.0, and sphinx-llms-txt). Additionally, new sbt test fixtures for the \sbt-openapi-codegen\ plugin have been added under \openapi-codegen/sbt-plugin/src/sbt-test/sbt-openapi-codegen/\, covering scenarios such as minimal generation, multi-file output, caching, and JSON roundtrips using various libraries (Circe, ZIO, jsoniter) and Scala versions.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 63 → 63 (-0.0)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 53 → 52 (-1.0)
- Architecture 93 → 93 (+0.0)
- Maturity 75 → 84 (+8.8)
- Readiness 65 → 66 (+1.2)
- Security 77 → 70 (-7.3)
- Performance 80 → 89 (+8.5)
Resolved (59)
- Classify ADR enforcement: 1. Explicit encode function on Validator.Enum (doc/adr/0001-explicit-encode-function-on-validator-enum.md)
- Classify ADR enforcement: 10. Security refactoring (doc/adr/0010-security-refactoring.md)
- Classify ADR enforcement: 11. Dedicated schema macros (doc/adr/0011-dedicated-schema-macros.md)
- Classify ADR enforcement: 12. Extracting schema as a module (doc/adr/0012-extracting-schema-as-a-module.md)
- Classify ADR enforcement: 2. Codecs, schemas, validators (doc/adr/0002-codecs-schemas-validators.md)
- Classify ADR enforcement: 3. Shape of IOs (doc/adr/0003-shape-of-ios.md)
- Classify ADR enforcement: 4. Codecs parametrised by raw values (doc/adr/0004-codecs-parametrised-by-raw-values.md)
- Classify ADR enforcement: 5. Rethinking codecs (doc/adr/0005-rethinking-codecs.md)
- Classify ADR enforcement: 6. Partial server logic (doc/adr/0006-partial-server-logic.md)
- Classify ADR enforcement: 7. Codecs and schemas derivation configs (doc/adr/0007-codecs-schemas-configuration.md)
- Classify ADR enforcement: 8. No effectful maps (doc/adr/0008-effectful-maps.md)
- Classify ADR enforcement: 9. Lists are optional (doc/adr/0009-lists-are-optional.md)
- Duplicated block (10 lines × 4) (client/sttp-client/src/main/scalajs/sttp/tapir/client/sttp/ws/fs2/WebSocketToFs2Pipe.scala)
- Duplicated block (11 lines × 2) (openapi-codegen/core/src/main/scala/sttp/tapir/codegen/json/CirceSerdeImpl.scala)
- Duplicated block (11 lines × 2) (server/akka-http-server/src/main/scala/sttp/tapir/server/akkahttp/AkkaToResponseBody.scala)
- Duplicated block (12 lines × 2) (docs/redoc/src/main/scala/sttp/tapir/redoc/Redoc.scala)
- Duplicated block (12 lines × 4) (client/sttp-client/src/main/scalajs/sttp/tapir/client/sttp/ws/fs2/WebSocketToFs2Pipe.scala)
- Duplicated block (14 lines × 4) (client/sttp-client/src/main/scalajs/sttp/tapir/client/sttp/ws/fs2/WebSocketToFs2Pipe.scala)
- Duplicated block (15 lines × 2) (client/play-client/src/main/scala/sttp/tapir/client/play/EndpointToPlayClient.scala)
- Duplicated block (15 lines × 2) (server/sttp-stub-server/src/main/scala/sttp/tapir/server/stub/SttpRequestDecoder.scala)
- …and 39 more
New (135)
- Edited copies of one member (3 members, 1+ corresponding lines) (client/http4s-client/src/main/scala/sttp/tapir/client/http4s/EndpointToHttp4sClient.scala)
- Edited copies of one member (3 members, 10+ corresponding lines) (json/pickler/src/main/scala/sttp/tapir/json/pickler/Pickler.scala)
- Edited copies of one member (3 members, 10+ corresponding lines) (server/core/src/main/scala/sttp/tapir/server/interceptor/metrics/MetricsEndpointInterceptor.scala)
- Edited copies of one member (3 members, 12+ corresponding lines) (core/src/main/scala/sttp/tapir/Endpoint.scala)
- Edited copies of one member (3 members, 14+ corresponding lines) (docs/openapi-docs/src/main/scala/sttp/tapir/docs/openapi/EndpointInputToParameterConverter.scala)
- Edited copies of one member (3 members, 17+ corresponding lines) (server/http4s-server/src/main/scala/sttp/tapir/server/http4s/Http4sWebSockets.scala)
- Edited copies of one member (3 members, 18+ corresponding lines) (observability/zio-opentelemetry/src/main/scala/sttp/tapir/server/ziopentelemetry/ZIOpenTelemetryTracingConfig.scala)
- Edited copies of one member (3 members, 3+ corresponding lines) (server/netty-server/cats/src/main/scala/sttp/tapir/server/netty/cats/NettyCatsServer.scala)
- Edited copies of one member (3 members, 4+ corresponding lines) (client/sttp-client4/src/main/scala/sttp/tapir/client/sttp4/SttpClientInterpreter.scala)
- Edited copies of one member (3 members, 4+ corresponding lines) (client/sttp-client4/src/main/scala/sttp/tapir/client/sttp4/SttpClientInterpreter.scala)
- Edited copies of one member (3 members, 4+ corresponding lines) (client/sttp-client4/src/main/scala/sttp/tapir/client/sttp4/SttpClientInterpreter.scala)
- Edited copies of one member (3 members, 4+ corresponding lines) (server/armeria-server/cats/src/main/scala/sttp/tapir/server/armeria/cats/ArmeriaCatsServerOptions.scala)
- Edited copies of one member (3 members, 4+ corresponding lines) (server/core/src/main/scala/sttp/tapir/server/interceptor/decodefailure/DecodeFailureHandler.scala)
- Edited copies of one member (3 members, 4+ corresponding lines) (server/core/src/main/scala/sttp/tapir/server/interceptor/decodefailure/DecodeFailureHandler.scala)
- Edited copies of one member (3 members, 4+ corresponding lines) (server/core/src/main/scala/sttp/tapir/server/interpreter/ServerInterpreter.scala)
- Edited copies of one member (3 members, 5+ corresponding lines) (core/src/main/scala/sttp/tapir/Codec.scala)
- Edited copies of one member (3 members, 5+ corresponding lines) (observability/zio-opentelemetry/src/main/scala/sttp/tapir/server/ziopentelemetry/ZIOpenTelemetryTracingConfig.scala)
- Edited copies of one member (3 members, 66+ corresponding lines) (openapi-codegen/core/src/main/scala/sttp/tapir/codegen/json/CirceSerdeImpl.scala)
- Edited copies of one member (3 members, 9+ corresponding lines) (docs/redoc-bundle/src/main/scala/sttp/tapir/redoc/bundle/RedocInterpreter.scala)
- Edited copies of one member (4 members, 1+ corresponding lines) (client/sttp-client/src/main/scala/sttp/tapir/client/sttp/SttpClientInterpreter.scala)
- …and 115 more
Changes since last survey
- 32 commits — 32 feature/other, 0 fixes
By area
- project/Versions.scala — 15 commits
- examples/src — 5 commits
- openapi-codegen/sbt-plugin — 5 commits
- .github/workflows — 3 commits
- (root) — 2 commits
- doc/endpoint — 1 commit
- project/plugins.sbt — 1 commit
Notable commits
- change: Bump actions/setup-java from 6.1.0 to 6.2.0 (#5654)
- change: Bump sbt/setup-sbt from 1.5.12 to 1.5.13 (#5641)
- change: Bump sbt/setup-sbt from 1.5.13 to 1.5.14 (#5653)
- change: Update Scala3 recursive type schema guidelines (#5630)
- change: Update armeria to 1.43.0 (#5658)
- change: Update aws-lambda-java-runtime-interface-client to 2.12.2 (#5632)
- change: Update cats, circe to 4.1.0 (#5634)
- change: Update client4:core to 4.0.27 (#5635)
- change: Update guava to 33.8.0-jre (#5647)
- change: Update jackson-module-scala to 2.23.0 (#5663)
- change: Update jsoniter-scala-core, ... to 2.42.0 (#5633)
- change: Update jsoniter-scala-core, ... to 2.42.2 (#5643)
- change: Update jsoniter-scala-core, ... to 2.42.3 (#5657)
- change: Update jsoniter-scala-core, ... to 2.43.0 (#5665)
- change: Update logback-classic to 1.6.6 (#5631)
- change: Update mockserver-netty to 9.2.0 (#5639)
- change: Update netty-all to 4.2.20.Final (#5648)
- change: Update opentelemetry-api, ... to 1.68.0 (#5660)
- change: Update opentelemetry-exporter-otlp, ... to 1.68.0 (#5664)
- change: Update opentelemetry-semconv to 1.45.0 (#5649)
- …and 12 more
Architecture
- Unchanged — 0 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
softwaremill/tapir was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit c93928648b1b3495d7cc31b46dca24f327cb11d1 — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.